From 3267392074dbb151e4d90c9d547182469de1c5b5 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 2 Aug 2022 20:51:29 -0700
Subject: [PATCH 001/227] Added updateStateCommitment and GetAppsUpdated

---
 persistence/application.go           | 35 +++++++++++++++++++
 persistence/pre_persistence/app.go   |  5 +++
 persistence/schema/base_actor.go     |  4 +++
 persistence/schema/protocol_actor.go |  2 ++
 persistence/schema/shared_sql.go     |  5 +++
 persistence/shared_sql.go            | 52 ++++++++++++++++++++++++++++
 persistence/test/state_hash_test.go  |  7 ++++
 shared/modules/persistence_module.go |  1 +
 shared/types/genesis/validator.go    |  3 ++
 utility/block.go                     |  3 ++
 utility/state.go                     | 44 +++++++++++++++++++++++
 11 files changed, 161 insertions(+)
 create mode 100644 persistence/test/state_hash_test.go
 create mode 100644 utility/state.go

diff --git a/persistence/application.go b/persistence/application.go
index 169524df4..e2cf8ee13 100644
--- a/persistence/application.go
+++ b/persistence/application.go
@@ -4,16 +4,51 @@ import (
 	"encoding/hex"
 	"log"
 
+	"github.com/golang/protobuf/proto"
 	"github.com/pokt-network/pocket/persistence/schema"
 	"github.com/pokt-network/pocket/shared/types"
+
+	typesGenesis "github.com/pokt-network/pocket/shared/types/genesis"
 )
 
 func (p PostgresContext) GetAppExists(address []byte, height int64) (exists bool, err error) {
 	return p.GetExists(schema.ApplicationActor, address, height)
 }
 
+func (p PostgresContext) GetAppsUpdated(height int64) (apps [][]byte, err error) {
+	actors, err := p.GetActorsUpdated(schema.ApplicationActor, height)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, actor := range actors {
+		// This breaks the pattern of protos in persistence
+		app := typesGenesis.App{
+			Address:   []byte(actor.Address),
+			PublicKey: []byte(actor.PublicKey),
+			// Paused:          actor.Paused,
+			// Status:          actor.Status,
+			Chains:          actor.Chains,
+			MaxRelays:       actor.ActorSpecificParam,
+			StakedTokens:    actor.StakedTokens,
+			PausedHeight:    actor.PausedHeight,
+			UnstakingHeight: actor.UnstakingHeight,
+			Output:          []byte(actor.OutputAddress),
+		}
+		appBytes, err := proto.Marshal(&app)
+		if err != nil {
+			return nil, err
+		}
+		apps = append(apps, appBytes)
+	}
+	return
+}
+
 func (p PostgresContext) GetApp(address []byte, height int64) (operator, publicKey, stakedTokens, maxRelays, outputAddress string, pauseHeight, unstakingHeight int64, chains []string, err error) {
 	actor, err := p.GetActor(schema.ApplicationActor, address, height)
+	if err != nil {
+		return
+	}
 	operator = actor.Address
 	publicKey = actor.PublicKey
 	stakedTokens = actor.StakedTokens
diff --git a/persistence/pre_persistence/app.go b/persistence/pre_persistence/app.go
index a1d5ac455..e0de24234 100644
--- a/persistence/pre_persistence/app.go
+++ b/persistence/pre_persistence/app.go
@@ -11,6 +11,11 @@ import (
 	"google.golang.org/protobuf/proto"
 )
 
+func (m *PrePersistenceContext) GetAppsUpdated(height int64) ([][]byte, error) {
+	// Not implemented
+	return nil, nil
+}
+
 func (m *PrePersistenceContext) GetAppExists(address []byte, height int64) (exists bool, err error) {
 	db := m.Store()
 	key := append(AppPrefixKey, address...)
diff --git a/persistence/schema/base_actor.go b/persistence/schema/base_actor.go
index 3b0c6c0a3..77c92842c 100644
--- a/persistence/schema/base_actor.go
+++ b/persistence/schema/base_actor.go
@@ -64,6 +64,10 @@ func (actor *BaseProtocolActorSchema) GetChainsTableSchema() string {
 	return ProtocolActorChainsTableSchema(actor.chainsHeightConstraintName)
 }
 
+func (actor *BaseProtocolActorSchema) GetUpdatedAtHeightQuery(height int64) string {
+	return SelectAtHeight(AllColsSelector, height, actor.tableName)
+}
+
 func (actor *BaseProtocolActorSchema) GetQuery(address string, height int64) string {
 	return Select(AllColsSelector, address, height, actor.tableName)
 }
diff --git a/persistence/schema/protocol_actor.go b/persistence/schema/protocol_actor.go
index a24bf1afd..19cc5f461 100644
--- a/persistence/schema/protocol_actor.go
+++ b/persistence/schema/protocol_actor.go
@@ -16,6 +16,8 @@ type ProtocolActorSchema interface {
 
 	/*** Read/Get Queries ***/
 
+	// Returns a query to retrieve all of a Actors updated at that specific height.
+	GetUpdatedAtHeightQuery(height int64) string
 	// Returns a query to retrieve all of a single Actor's attributes.
 	GetQuery(address string, height int64) string
 	// Returns a query for the existence of an Actor given its address.
diff --git a/persistence/schema/shared_sql.go b/persistence/schema/shared_sql.go
index 63f059051..a47ae7ab3 100644
--- a/persistence/schema/shared_sql.go
+++ b/persistence/schema/shared_sql.go
@@ -69,6 +69,11 @@ func ProtocolActorChainsTableSchema(constraintName string) string {
 		)`, AddressCol, ChainIDCol, HeightCol, DefaultBigInt, constraintName, AddressCol, ChainIDCol, HeightCol)
 }
 
+func SelectAtHeight(selector string, height int64, tableName string) string {
+	return fmt.Sprintf(`SELECT %s FROM %s WHERE height=%d`,
+		selector, tableName, height)
+}
+
 func Select(selector, address string, height int64, tableName string) string {
 	return fmt.Sprintf(`SELECT %s FROM %s WHERE address='%s' AND height<=%d ORDER BY height DESC LIMIT 1`,
 		selector, tableName, address, height)
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
index 369cbe402..4319ced81 100644
--- a/persistence/shared_sql.go
+++ b/persistence/shared_sql.go
@@ -41,6 +41,58 @@ func (p *PostgresContext) GetExists(actorSchema schema.ProtocolActorSchema, addr
 	return
 }
 
+func (p *PostgresContext) GetActorsUpdated(actorSchema schema.ProtocolActorSchema, height int64) (actors []schema.BaseActor, err error) {
+	ctx, conn, err := p.GetCtxAndConnection()
+	if err != nil {
+		return
+	}
+
+	rows, err := conn.Query(ctx, actorSchema.GetUpdatedAtHeightQuery(height))
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var actor schema.BaseActor
+	for rows.Next() {
+		if err = rows.Scan(
+			&actor.Address, &actor.PublicKey, &actor.StakedTokens, &actor.ActorSpecificParam,
+			&actor.OutputAddress, &actor.PausedHeight, &actor.UnstakingHeight,
+			&actor.Chains, &height,
+		); err != nil {
+			return
+		}
+
+		if actorSchema.GetChainsTableName() == "" {
+			continue
+		}
+
+		chainRows, chainsErr := conn.Query(ctx, actorSchema.GetChainsQuery(actor.Address, height))
+		if err != nil {
+			return nil, chainsErr // Why couldn't I just `return` here and use `err`?
+		}
+		defer chainRows.Close()
+
+		var chainAddr string
+		var chainID string
+		var chainEndHeight int64 // unused
+		for rows.Next() {
+			err = rows.Scan(&chainAddr, &chainID, &chainEndHeight)
+			if err != nil {
+				return
+			}
+			if chainAddr != actor.Address {
+				return nil, fmt.Errorf("weird")
+			}
+			actor.Chains = append(actor.Chains, chainID)
+		}
+
+		actors = append(actors, actor)
+	}
+
+	return
+}
+
 func (p *PostgresContext) GetActor(actorSchema schema.ProtocolActorSchema, address []byte, height int64) (actor schema.BaseActor, err error) {
 	ctx, conn, err := p.GetCtxAndConnection()
 	if err != nil {
diff --git a/persistence/test/state_hash_test.go b/persistence/test/state_hash_test.go
new file mode 100644
index 000000000..c57c2c699
--- /dev/null
+++ b/persistence/test/state_hash_test.go
@@ -0,0 +1,7 @@
+package test
+
+import "testing"
+
+func TestSomething(t *testing.T) {
+
+}
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index 06854ca39..d9b6fd4e4 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -71,6 +71,7 @@ type PersistenceContext interface {
 	SetAccountAmount(address []byte, amount string) error // TECHDEBT(team): Delete this function
 
 	// App Operations
+	GetAppsUpdated(height int64) ([][]byte, error) // Returns the apps updates at the given height
 	GetAppExists(address []byte, height int64) (exists bool, err error)
 	InsertApp(address []byte, publicKey []byte, output []byte, paused bool, status int, maxRelays string, stakedAmount string, chains []string, pausedHeight int64, unstakingHeight int64) error
 	UpdateApp(address []byte, maxRelays string, stakedAmount string, chainsToUpdate []string) error
diff --git a/shared/types/genesis/validator.go b/shared/types/genesis/validator.go
index d40406af8..0030f4452 100644
--- a/shared/types/genesis/validator.go
+++ b/shared/types/genesis/validator.go
@@ -7,6 +7,9 @@ import (
 	"google.golang.org/protobuf/encoding/protojson"
 )
 
+// TODO_IN_THIS_COMMIT: See https://github.com/pokt-network/pocket/pull/139/files to remove this shit
+
+
 // HACK: Since the protocol actor protobufs (e.g. validator, fisherman, etc) use `bytes` for some
 // fields (e.g. `address`, `output`, `publicKey`), we need to use a helper struct to unmarshal the
 // the types when they are defined via json (e.g. genesis file, testing configurations, etc...).
diff --git a/utility/block.go b/utility/block.go
index 8d57dcbac..3a8d2e501 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -74,6 +74,9 @@ func (u *UtilityContext) EndBlock(proposer []byte) types.Error {
 	if err := u.BeginUnstakingMaxPaused(); err != nil {
 		return err
 	}
+	if err := u.updateStateCommitment(); err != nil {
+		return err
+	}
 	return nil
 }
 
diff --git a/utility/state.go b/utility/state.go
new file mode 100644
index 000000000..4f128ac2a
--- /dev/null
+++ b/utility/state.go
@@ -0,0 +1,44 @@
+package utility
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/pokt-network/pocket/shared/types"
+	typesUtil "github.com/pokt-network/pocket/utility/types"
+)
+
+func (u *UtilityContext) updateStateCommitment() types.Error {
+	// Update the Merkle Tree associated with each actor
+	for _, actorType := range typesUtil.ActorTypes {
+		// Need to get all the actors updated at this height
+		switch actorType {
+		case typesUtil.ActorType_App:
+			apps, err := u.Context.GetAppsUpdated(u.LatestHeight) // shouldn't need to pass in a height here
+			if err != nil {
+				return types.NewError(types.Code(42), "Couldn't figure out apps updated")
+			}
+			fmt.Println("apps: ", apps)
+		case typesUtil.ActorType_Val:
+			fallthrough
+		case typesUtil.ActorType_Fish:
+			fallthrough
+		case typesUtil.ActorType_Node:
+			fallthrough
+		default:
+			log.Fatalf("Not supported yet")
+		}
+	}
+
+	// TODO: Update Merkle Tree for Accounts
+
+	// TODO: Update Merkle Tree for Pools
+
+	// TODO:Update Merkle Tree for Blocks
+
+	// TODO: Update Merkle Tree for Params
+
+	// TODO: Update Merkle Tree for Flags
+
+	return nil
+}

From b0bbbb4e0fed1ff1c461dfb205e45dac16a8d7e0 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 2 Aug 2022 20:55:00 -0700
Subject: [PATCH 002/227] Added celestiaorg/smt tree

---
 go.mod | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/go.mod b/go.mod
index fca0bc766..11300d8ae 100644
--- a/go.mod
+++ b/go.mod
@@ -41,7 +41,7 @@ require (
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b // indirect
 	github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6 // indirect
-	github.com/golang/protobuf v1.5.2 // indirect
+	github.com/golang/protobuf v1.5.2
 	github.com/golang/snappy v0.0.3 // indirect
 	github.com/google/flatbuffers v1.12.1 // indirect
 	github.com/gotestyourself/gotestyourself v2.2.0+incompatible // indirect

From b52d59a0e4eeceebcd8a351f2f24be25fc718082 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 2 Aug 2022 21:49:03 -0700
Subject: [PATCH 003/227] Added updating merkle tree using app protos

---
 go.mod                               |  1 +
 go.sum                               |  2 ++
 persistence/application.go           | 13 +++++++
 persistence/db.go                    |  6 ++--
 persistence/module.go                | 51 ++++++++++++++++++++++++++++
 persistence/pre_persistence/app.go   |  5 +++
 shared/modules/persistence_module.go |  4 ++-
 utility/state.go                     |  5 +--
 8 files changed, 82 insertions(+), 5 deletions(-)

diff --git a/go.mod b/go.mod
index 11300d8ae..3b51bf12d 100644
--- a/go.mod
+++ b/go.mod
@@ -58,6 +58,7 @@ require (
 
 require (
 	filippo.io/edwards25519 v1.0.0-rc.1 // indirect
+	github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884 // indirect
 	github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/fsnotify/fsnotify v1.5.1 // indirect
diff --git a/go.sum b/go.sum
index 786bc0d0c..873a26c37 100644
--- a/go.sum
+++ b/go.sum
@@ -21,6 +21,8 @@ github.com/ProtonMail/go-ecvrf v0.0.1/go.mod h1:fhZbiRYn62/JGnBG2NGwCx0oT+gr/+I5
 github.com/ajstarks/svgo v0.0.0-20180226025133-644b8db467af/go.mod h1:K08gAheRH3/J6wwsYMMT4xOr94bZjxIelGM0+d/wbFw=
 github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
 github.com/boombuler/barcode v1.0.0/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8=
+github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884 h1:iRNKw2WmAbVgGMNYzDH5Y2yY3+jyxwEK9Hc5pwIjZAE=
+github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884/go.mod h1:/sdYDakowo/XaxS2Fl7CBqtuf/O2uTqF2zmAUFAtAiw=
 github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4=
 github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
 github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
diff --git a/persistence/application.go b/persistence/application.go
index e2cf8ee13..ccc1a5ff9 100644
--- a/persistence/application.go
+++ b/persistence/application.go
@@ -15,6 +15,19 @@ func (p PostgresContext) GetAppExists(address []byte, height int64) (exists bool
 	return p.GetExists(schema.ApplicationActor, address, height)
 }
 
+func (p PostgresContext) UpdateAppTree(apps [][]byte) error {
+	for _, app := range apps {
+		appProto := typesGenesis.App{}
+		if err := proto.Unmarshal(app, &appProto); err != nil {
+			return err
+		}
+		if _, err := p.MerkleTrees[AppMerkleTree].Update(appProto.Address, app); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 func (p PostgresContext) GetAppsUpdated(height int64) (apps [][]byte, err error) {
 	actors, err := p.GetActorsUpdated(schema.ApplicationActor, height)
 	if err != nil {
diff --git a/persistence/db.go b/persistence/db.go
index 56e6be62c..a144d1ce0 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -7,6 +7,7 @@ import (
 	"math/rand"
 	"time"
 
+	"github.com/celestiaorg/smt"
 	"github.com/jackc/pgx/v4"
 	"github.com/pokt-network/pocket/persistence/kvstore"
 	"github.com/pokt-network/pocket/persistence/schema"
@@ -35,8 +36,9 @@ type PostgresContext struct {
 
 	// IMPROVE: Depending on how the use of `PostgresContext` evolves, we may be able to get
 	// access to these directly via the postgres module.
-	PostgresDB *pgx.Conn
-	BlockStore kvstore.KVStore
+	PostgresDB  *pgx.Conn
+	BlockStore  kvstore.KVStore
+	MerkleTrees map[MerkleTree]*smt.SparseMerkleTree
 }
 
 func (pg *PostgresContext) GetCtxAndConnection() (context.Context, *pgx.Conn, error) {
diff --git a/persistence/module.go b/persistence/module.go
index 49f21d627..f5ed6d152 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -1,8 +1,10 @@
 package persistence
 
 import (
+	"crypto/sha256"
 	"log"
 
+	"github.com/celestiaorg/smt"
 	"github.com/jackc/pgx/v4"
 	"github.com/pokt-network/pocket/persistence/kvstore"
 	"github.com/pokt-network/pocket/shared/config"
@@ -46,6 +48,20 @@ func (p PostgresContext) SetValidatorStakeAmount(address []byte, stakeAmount str
 	panic("TODO: implement PostgresContext.SetValidatorStakeAmount")
 }
 
+type MerkleTree float64
+
+const (
+	AppMerkleTree MerkleTree = iota
+	ValMerkleTree
+	FishMerkleTree
+	ServiceNodeMerkleTree
+	AccountMerkleTree
+	PoolMerkleTree
+	BlocksMerkleTree
+	ParamsMerkleTree
+	FlagsMerkleTree
+)
+
 type persistenceModule struct {
 	bus modules.Bus
 
@@ -56,6 +72,8 @@ type persistenceModule struct {
 	blockStore kvstore.KVStore
 	// A mapping of context IDs to persistence contexts
 	contexts map[contextId]modules.PersistenceContext
+	// Merkle trees
+	trees map[MerkleTree]*smt.SparseMerkleTree
 }
 
 type contextId uint64
@@ -77,6 +95,7 @@ func Create(c *config.Config) (modules.PersistenceModule, error) {
 		postgresConn: postgresDb,
 		blockStore:   blockStore,
 		contexts:     make(map[contextId]modules.PersistenceContext),
+		trees:        make(map[MerkleTree]*smt.SparseMerkleTree),
 	}, nil
 }
 
@@ -98,6 +117,10 @@ func (p *persistenceModule) Start() error {
 		log.Println("Loading state from previous state...")
 	}
 
+	if err != p.initializeTrees() {
+		return err
+	}
+
 	return nil
 }
 
@@ -159,3 +182,31 @@ func (m *persistenceModule) shouldHydrateGenesisDb() (bool, error) {
 
 	return m.blockStore.Exists(heightToBytes(int64(maxHeight)))
 }
+
+func (m *persistenceModule) initializeTrees() error {
+	// Initialise two new key-value store to store the nodes and values of the tree
+	nodeStore := smt.NewSimpleMap()
+	valueStore := smt.NewSimpleMap()
+
+	// Initialise the tree
+	tree := smt.NewSparseMerkleTree(nodeStore, valueStore, sha256.New())
+
+	m.trees[AppMerkleTree] = tree
+
+	return nil
+}
+
+// 	// Update the key "foo" with the value "bar"
+// 	_, _ = tree.Update([]byte("foo"), []byte("bar"))
+
+// 	// Generate a Merkle proof for foo=bar
+// 	proof, _ := tree.Prove([]byte("foo"))
+// 	root := tree.Root() // We also need the current tree root for the proof
+
+// 	// Verify the Merkle proof for foo=bar
+// 	if smt.VerifyProof(proof, root, []byte("foo"), []byte("bar"), sha256.New()) {
+// 		fmt.Println("Proof verification succeeded.")
+// 	} else {
+// 		fmt.Println("Proof verification failed.")
+// 	}
+// }
diff --git a/persistence/pre_persistence/app.go b/persistence/pre_persistence/app.go
index e0de24234..1d1b1a9ae 100644
--- a/persistence/pre_persistence/app.go
+++ b/persistence/pre_persistence/app.go
@@ -16,6 +16,11 @@ func (m *PrePersistenceContext) GetAppsUpdated(height int64) ([][]byte, error) {
 	return nil, nil
 }
 
+func (m *PrePersistenceContext) UpdateAppTree([][]byte) error {
+	// Not implemented
+	return nil
+}
+
 func (m *PrePersistenceContext) GetAppExists(address []byte, height int64) (exists bool, err error) {
 	db := m.Store()
 	key := append(AppPrefixKey, address...)
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index d9b6fd4e4..a03deb5d4 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -71,7 +71,6 @@ type PersistenceContext interface {
 	SetAccountAmount(address []byte, amount string) error // TECHDEBT(team): Delete this function
 
 	// App Operations
-	GetAppsUpdated(height int64) ([][]byte, error) // Returns the apps updates at the given height
 	GetAppExists(address []byte, height int64) (exists bool, err error)
 	InsertApp(address []byte, publicKey []byte, output []byte, paused bool, status int, maxRelays string, stakedAmount string, chains []string, pausedHeight int64, unstakingHeight int64) error
 	UpdateApp(address []byte, maxRelays string, stakedAmount string, chainsToUpdate []string) error
@@ -85,6 +84,9 @@ type PersistenceContext interface {
 	SetAppStatusAndUnstakingHeightIfPausedBefore(pausedBeforeHeight, unstakingHeight int64, status int) error
 	SetAppPauseHeight(address []byte, height int64) error
 	GetAppOutputAddress(operator []byte, height int64) (output []byte, err error)
+	// App Operations - For Tree Merkling
+	GetAppsUpdated(height int64) ([][]byte, error) // Returns the apps updates at the given height
+	UpdateAppTree([][]byte) error
 
 	// ServiceNode Operations
 	GetServiceNodeExists(address []byte, height int64) (exists bool, err error)
diff --git a/utility/state.go b/utility/state.go
index 4f128ac2a..b75e02287 100644
--- a/utility/state.go
+++ b/utility/state.go
@@ -1,7 +1,6 @@
 package utility
 
 import (
-	"fmt"
 	"log"
 
 	"github.com/pokt-network/pocket/shared/types"
@@ -18,7 +17,9 @@ func (u *UtilityContext) updateStateCommitment() types.Error {
 			if err != nil {
 				return types.NewError(types.Code(42), "Couldn't figure out apps updated")
 			}
-			fmt.Println("apps: ", apps)
+			if err := u.Context.UpdateAppTree(apps); err != nil {
+				return nil
+			}
 		case typesUtil.ActorType_Val:
 			fallthrough
 		case typesUtil.ActorType_Fish:

From 24f358ada37154b8799e6d48cc15c4320ef2b3c0 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Fri, 5 Aug 2022 23:14:07 -0400
Subject: [PATCH 004/227] WIP - trees

---
 Makefile                             |   5 ++
 persistence/application.go           |  17 ++--
 persistence/block.go                 |   8 ++
 persistence/db.go                    |   4 +-
 persistence/kvstore/kvstore.go       |  11 ++-
 persistence/module.go                |  66 +++-----------
 persistence/pre_persistence/app.go   |   8 +-
 persistence/state.go                 | 124 +++++++++++++++++++++++++++
 persistence/state_test.go            |  15 ++++
 persistence/test/state_hash_test.go  |   7 --
 shared/modules/persistence_module.go |   2 +-
 utility/state.go                     |  45 ----------
 12 files changed, 191 insertions(+), 121 deletions(-)
 create mode 100644 persistence/state.go
 create mode 100644 persistence/state_test.go
 delete mode 100644 persistence/test/state_hash_test.go
 delete mode 100644 utility/state.go

diff --git a/Makefile b/Makefile
index 61c5621c6..9c59a435c 100644
--- a/Makefile
+++ b/Makefile
@@ -221,6 +221,11 @@ test_sortition:
 test_persistence:
 	go test ${VERBOSE_TEST} -p=1 ./persistence/...
 
+.PHONY: test_persistence_state_hash
+## Run all go unit tests in the Persistence module
+test_persistence_state_hash:
+	go test -run StateHash ${VERBOSE_TEST} -p=1 ./persistence/...
+
 .PHONY: benchmark_sortition
 ## Benchmark the Sortition library
 benchmark_sortition:
diff --git a/persistence/application.go b/persistence/application.go
index ccc1a5ff9..98d62fd7f 100644
--- a/persistence/application.go
+++ b/persistence/application.go
@@ -28,7 +28,9 @@ func (p PostgresContext) UpdateAppTree(apps [][]byte) error {
 	return nil
 }
 
-func (p PostgresContext) GetAppsUpdated(height int64) (apps [][]byte, err error) {
+// TODO_IN_THIS_COMMIT: Not exposed via interface yet
+// func (p PostgresContext) getAppsUpdated(height int64) (apps [][]byte, err error) {
+func (p PostgresContext) getAppsUpdated(height int64) (apps []*typesGenesis.App, err error) {
 	actors, err := p.GetActorsUpdated(schema.ApplicationActor, height)
 	if err != nil {
 		return nil, err
@@ -36,7 +38,7 @@ func (p PostgresContext) GetAppsUpdated(height int64) (apps [][]byte, err error)
 
 	for _, actor := range actors {
 		// This breaks the pattern of protos in persistence
-		app := typesGenesis.App{
+		app := &typesGenesis.App{
 			Address:   []byte(actor.Address),
 			PublicKey: []byte(actor.PublicKey),
 			// Paused:          actor.Paused,
@@ -48,11 +50,12 @@ func (p PostgresContext) GetAppsUpdated(height int64) (apps [][]byte, err error)
 			UnstakingHeight: actor.UnstakingHeight,
 			Output:          []byte(actor.OutputAddress),
 		}
-		appBytes, err := proto.Marshal(&app)
-		if err != nil {
-			return nil, err
-		}
-		apps = append(apps, appBytes)
+		// appBytes, err := proto.Marshal(&app)
+		// if err != nil {
+		// 	return nil, err
+		// }
+		// apps = append(apps, appBytes)
+		apps = append(apps, app)
 	}
 	return
 }
diff --git a/persistence/block.go b/persistence/block.go
index fc9c3eceb..8055ee566 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -4,10 +4,18 @@ import (
 	"encoding/binary"
 	"encoding/hex"
 	"log"
+	"os"
 
 	"github.com/pokt-network/pocket/persistence/schema"
 )
 
+func (p *persistenceModule) shouldLoadBlockStore() bool {
+	if _, err := os.Stat(p.GetBus().GetConfig().Persistence.BlockStorePath); err == nil {
+		return true
+	}
+	return false
+}
+
 // OPTIMIZE(team): get from blockstore or keep in cache/memory
 func (p PostgresContext) GetLatestBlockHeight() (latestHeight int64, err error) {
 	ctx, conn, err := p.GetCtxAndConnection()
diff --git a/persistence/db.go b/persistence/db.go
index a144d1ce0..2a2f411a6 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -37,8 +37,8 @@ type PostgresContext struct {
 	// IMPROVE: Depending on how the use of `PostgresContext` evolves, we may be able to get
 	// access to these directly via the postgres module.
 	PostgresDB  *pgx.Conn
-	BlockStore  kvstore.KVStore
-	MerkleTrees map[MerkleTree]*smt.SparseMerkleTree
+	BlockStore  kvstore.KVStore                      // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the module (i.e. not context)
+	MerkleTrees map[MerkleTree]*smt.SparseMerkleTree // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the module (i.e. not context)
 }
 
 func (pg *PostgresContext) GetCtxAndConnection() (context.Context, *pgx.Conn, error) {
diff --git a/persistence/kvstore/kvstore.go b/persistence/kvstore/kvstore.go
index b598038f9..ec00c5427 100644
--- a/persistence/kvstore/kvstore.go
+++ b/persistence/kvstore/kvstore.go
@@ -1,6 +1,7 @@
 package kvstore
 
 import (
+	"errors"
 	"log"
 
 	badger "github.com/dgraph-io/badger/v3"
@@ -19,11 +20,19 @@ type KVStore interface {
 
 var _ KVStore = &badgerKVStore{}
 
+var (
+	ErrKVStoreExists    = errors.New("kvstore already exists")
+	ErrKVStoreNotExists = errors.New("kvstore does not exist")
+)
+
 type badgerKVStore struct {
 	db *badger.DB
 }
 
-func NewKVStore(path string) (KVStore, error) {
+// REFACTOR: Loads or creates a badgerDb at `path`. This may potentially need to be refactored
+// into `NewKVStore` and `LoadKVStore` depending on how state sync evolves by leveraging `os.Stat`
+// on the file path.
+func OpenKVStore(path string) (KVStore, error) {
 	db, err := badger.Open(badger.DefaultOptions(path))
 	if err != nil {
 		return nil, err
diff --git a/persistence/module.go b/persistence/module.go
index f5ed6d152..08346c423 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -1,7 +1,6 @@
 package persistence
 
 import (
-	"crypto/sha256"
 	"log"
 
 	"github.com/celestiaorg/smt"
@@ -48,20 +47,6 @@ func (p PostgresContext) SetValidatorStakeAmount(address []byte, stakeAmount str
 	panic("TODO: implement PostgresContext.SetValidatorStakeAmount")
 }
 
-type MerkleTree float64
-
-const (
-	AppMerkleTree MerkleTree = iota
-	ValMerkleTree
-	FishMerkleTree
-	ServiceNodeMerkleTree
-	AccountMerkleTree
-	PoolMerkleTree
-	BlocksMerkleTree
-	ParamsMerkleTree
-	FlagsMerkleTree
-)
-
 type persistenceModule struct {
 	bus modules.Bus
 
@@ -84,7 +69,7 @@ func Create(c *config.Config) (modules.PersistenceModule, error) {
 		return nil, err
 	}
 
-	blockStore, err := kvstore.NewKVStore(c.Persistence.BlockStorePath)
+	blockStore, err := kvstore.OpenKVStore(c.Persistence.BlockStorePath)
 	if err != nil {
 		return nil, err
 	}
@@ -102,24 +87,25 @@ func Create(c *config.Config) (modules.PersistenceModule, error) {
 func (p *persistenceModule) Start() error {
 	log.Println("Starting persistence module...")
 
-	shouldHydrateGenesis := false
-	shouldHydrateGenesis, err := p.shouldHydrateGenesisDb()
-	if err != nil {
-		return err
-	}
-
-	if shouldHydrateGenesis {
+	if shouldHydrateGenesis, err := p.shouldHydrateGenesisDb(); err != nil {
+		return nil
+	} else if shouldHydrateGenesis {
+		log.Println("Hydrating genesis state...")
 		if err := p.hydrateGenesisDbState(); err != nil {
 			return err
 		}
-		log.Println("Hydrating genesis state...")
 	} else {
-		log.Println("Loading state from previous state...")
+		log.Println("TODO: Finish loading previous state...")
+
 	}
 
-	if err != p.initializeTrees() {
+	// DISCUSS_IN_THIS_COMMIT: We've been using the module function pattern, but this is cleaner and easier to test
+	trees, err := initializeTrees()
+	if err != nil {
 		return err
 	}
+	// TODO_IN_THIS_COMMIT: load trees from state
+	p.trees = trees
 
 	return nil
 }
@@ -182,31 +168,3 @@ func (m *persistenceModule) shouldHydrateGenesisDb() (bool, error) {
 
 	return m.blockStore.Exists(heightToBytes(int64(maxHeight)))
 }
-
-func (m *persistenceModule) initializeTrees() error {
-	// Initialise two new key-value store to store the nodes and values of the tree
-	nodeStore := smt.NewSimpleMap()
-	valueStore := smt.NewSimpleMap()
-
-	// Initialise the tree
-	tree := smt.NewSparseMerkleTree(nodeStore, valueStore, sha256.New())
-
-	m.trees[AppMerkleTree] = tree
-
-	return nil
-}
-
-// 	// Update the key "foo" with the value "bar"
-// 	_, _ = tree.Update([]byte("foo"), []byte("bar"))
-
-// 	// Generate a Merkle proof for foo=bar
-// 	proof, _ := tree.Prove([]byte("foo"))
-// 	root := tree.Root() // We also need the current tree root for the proof
-
-// 	// Verify the Merkle proof for foo=bar
-// 	if smt.VerifyProof(proof, root, []byte("foo"), []byte("bar"), sha256.New()) {
-// 		fmt.Println("Proof verification succeeded.")
-// 	} else {
-// 		fmt.Println("Proof verification failed.")
-// 	}
-// }
diff --git a/persistence/pre_persistence/app.go b/persistence/pre_persistence/app.go
index 1d1b1a9ae..cad4d4ce2 100644
--- a/persistence/pre_persistence/app.go
+++ b/persistence/pre_persistence/app.go
@@ -11,10 +11,10 @@ import (
 	"google.golang.org/protobuf/proto"
 )
 
-func (m *PrePersistenceContext) GetAppsUpdated(height int64) ([][]byte, error) {
-	// Not implemented
-	return nil, nil
-}
+// func (m *PrePersistenceContext) GetAppsUpdated(height int64) ([][]byte, error) {
+// 	// Not implemented
+// 	return nil, nil
+// }
 
 func (m *PrePersistenceContext) UpdateAppTree([][]byte) error {
 	// Not implemented
diff --git a/persistence/state.go b/persistence/state.go
new file mode 100644
index 000000000..ffab52aea
--- /dev/null
+++ b/persistence/state.go
@@ -0,0 +1,124 @@
+package persistence
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"log"
+	"sort"
+
+	"github.com/celestiaorg/smt"
+	"github.com/pokt-network/pocket/shared/types"
+	"google.golang.org/protobuf/proto"
+)
+
+type MerkleTree float64
+
+// A work-in-progress list of all the trees we need to update to maintain the overall state
+const (
+	AppMerkleTree MerkleTree = iota
+	ValMerkleTree
+	FishMerkleTree
+	ServiceNodeMerkleTree
+	AccountMerkleTree
+	PoolMerkleTree
+	BlocksMerkleTree
+	ParamsMerkleTree
+	FlagsMerkleTree
+	lastMerkleTree // Used for iteration purposes only - see https://stackoverflow.com/a/64178235/768439
+)
+
+func initializeTrees() (map[MerkleTree]*smt.SparseMerkleTree, error) {
+	// We need a separate Merkle tree for each type of actor or storage
+	trees := make(map[MerkleTree]*smt.SparseMerkleTree, int(lastMerkleTree))
+
+	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
+		// Initialize two new key-value store to store the nodes and values of the tree
+		nodeStore := smt.NewSimpleMap()
+		valueStore := smt.NewSimpleMap()
+
+		trees[treeType] = smt.NewSparseMerkleTree(nodeStore, valueStore, sha256.New())
+	}
+	return trees, nil
+}
+
+func loadTrees(map[MerkleTree]*smt.SparseMerkleTree, error) {
+
+}
+
+func (p *PostgresContext) updateStateCommitment() ([]byte, error) {
+	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
+		switch treeType {
+		case AppMerkleTree:
+			apps, err := p.getAppsUpdated(p.Height)
+			if err != nil {
+				return nil, types.NewError(types.Code(42), "Couldn't figure out apps updated") // TODO_IN_THIS_COMMIT
+			}
+			for _, app := range apps {
+				// OPTIMIZE: Do we want to store the serialized bytes or a hash of it in the KV store?
+				appBytes, err := proto.Marshal(app)
+				if err != nil {
+					return nil, err
+				}
+				if _, err := p.MerkleTrees[treeType].Update(app.Address, appBytes); err != nil {
+					return nil, err
+				}
+			}
+		default:
+			log.Fatalln("Not handeled uet in state commitment update")
+		}
+	}
+
+	// Get the root of each Merkle Tree
+	roots := make([][]byte, 0)
+	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
+		roots = append(roots, p.MerkleTrees[treeType].Root())
+	}
+
+	// Sort the merkle roots lexicographically
+	sort.Slice(roots, func(r1, r2 int) bool {
+		return bytes.Compare(roots[r1], roots[r2]) < 0
+	})
+
+	// Get the state hash
+	rootsConcat := bytes.Join(roots, []byte{})
+	stateHash := sha256.Sum256(rootsConcat)
+
+	return stateHash[:], nil
+}
+
+// computeStateHash(root)
+// context := p.
+// Update the Merkle Tree associated with each actor
+// for _, actorType := range typesUtil.ActorTypes {
+// 	// Need to get all the actors updated at this height
+// 	switch actorType {
+// 	case typesUtil.ActorType_App:
+// 		apps, err := u.Context.GetAppsUpdated(u.LatestHeight) // shouldn't need to pass in a height here
+// 		if err != nil {
+// 			return types.NewError(types.Code(42), "Couldn't figure out apps updated")
+// 		}
+// 		if err := u.Context.UpdateAppTree(apps); err != nil {
+// 			return nil
+// 		}
+// 	case typesUtil.ActorType_Val:
+// 		fallthrough
+// 	case typesUtil.ActorType_Fish:
+// 		fallthrough
+// 	case typesUtil.ActorType_Node:
+// 		fallthrough
+// 	default:
+// 		log.Fatalf("Actor type not supported: %s", actorType)
+// 	}
+// }
+
+// TODO: Update Merkle Tree for Accounts
+
+// TODO: Update Merkle Tree for Pools
+
+// TODO:Update Merkle Tree for Blocks
+
+// TODO: Update Merkle Tree for Params
+
+// TODO: Update Merkle Tree for Flags
+
+// return nil
diff --git a/persistence/state_test.go b/persistence/state_test.go
new file mode 100644
index 000000000..9570f4c00
--- /dev/null
+++ b/persistence/state_test.go
@@ -0,0 +1,15 @@
+package persistence
+
+import "testing"
+
+func TestStateHash_InitializeTrees(t *testing.T) {
+
+}
+
+func TestStateHash_LoadTrees(t *testing.T) {
+
+}
+
+func TestStateHash_ComputeStateHash(t *testing.T) {
+
+}
diff --git a/persistence/test/state_hash_test.go b/persistence/test/state_hash_test.go
deleted file mode 100644
index c57c2c699..000000000
--- a/persistence/test/state_hash_test.go
+++ /dev/null
@@ -1,7 +0,0 @@
-package test
-
-import "testing"
-
-func TestSomething(t *testing.T) {
-
-}
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index a03deb5d4..a3a7242d4 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -85,7 +85,7 @@ type PersistenceContext interface {
 	SetAppPauseHeight(address []byte, height int64) error
 	GetAppOutputAddress(operator []byte, height int64) (output []byte, err error)
 	// App Operations - For Tree Merkling
-	GetAppsUpdated(height int64) ([][]byte, error) // Returns the apps updates at the given height
+	// GetAppsUpdated(height int64) ([][]byte, error) // Returns the apps updates at the given height
 	UpdateAppTree([][]byte) error
 
 	// ServiceNode Operations
diff --git a/utility/state.go b/utility/state.go
deleted file mode 100644
index b75e02287..000000000
--- a/utility/state.go
+++ /dev/null
@@ -1,45 +0,0 @@
-package utility
-
-import (
-	"log"
-
-	"github.com/pokt-network/pocket/shared/types"
-	typesUtil "github.com/pokt-network/pocket/utility/types"
-)
-
-func (u *UtilityContext) updateStateCommitment() types.Error {
-	// Update the Merkle Tree associated with each actor
-	for _, actorType := range typesUtil.ActorTypes {
-		// Need to get all the actors updated at this height
-		switch actorType {
-		case typesUtil.ActorType_App:
-			apps, err := u.Context.GetAppsUpdated(u.LatestHeight) // shouldn't need to pass in a height here
-			if err != nil {
-				return types.NewError(types.Code(42), "Couldn't figure out apps updated")
-			}
-			if err := u.Context.UpdateAppTree(apps); err != nil {
-				return nil
-			}
-		case typesUtil.ActorType_Val:
-			fallthrough
-		case typesUtil.ActorType_Fish:
-			fallthrough
-		case typesUtil.ActorType_Node:
-			fallthrough
-		default:
-			log.Fatalf("Not supported yet")
-		}
-	}
-
-	// TODO: Update Merkle Tree for Accounts
-
-	// TODO: Update Merkle Tree for Pools
-
-	// TODO:Update Merkle Tree for Blocks
-
-	// TODO: Update Merkle Tree for Params
-
-	// TODO: Update Merkle Tree for Flags
-
-	return nil
-}

From a493f1f1870b860df64e7545fb6e8711e623d5d1 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sat, 6 Aug 2022 19:27:19 -0400
Subject: [PATCH 005/227] Update go.mod

---
 go.mod | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/go.mod b/go.mod
index 3b51bf12d..65f7bd77d 100644
--- a/go.mod
+++ b/go.mod
@@ -22,6 +22,7 @@ require (
 )
 
 require (
+	github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884
 	github.com/dgraph-io/badger/v3 v3.2103.2
 	github.com/iancoleman/strcase v0.2.0
 )
@@ -58,7 +59,6 @@ require (
 
 require (
 	filippo.io/edwards25519 v1.0.0-rc.1 // indirect
-	github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884 // indirect
 	github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/fsnotify/fsnotify v1.5.1 // indirect

From fce0b424611042392ebb43f6a39314f014e19472 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sat, 6 Aug 2022 20:04:32 -0400
Subject: [PATCH 006/227] Got tests to pass after self review

---
 consensus/module.go                        |  2 +-
 persistence/application.go                 | 10 ++--
 persistence/block.go                       |  3 +-
 persistence/context.go                     | 17 +++++-
 persistence/db.go                          |  5 +-
 persistence/kvstore/kvstore.go             | 18 ++++--
 persistence/module.go                      |  5 +-
 persistence/pre_persistence/persistence.go |  5 ++
 persistence/shared_sql.go                  | 13 ++++-
 persistence/state.go                       | 64 +++++++---------------
 shared/modules/persistence_module.go       |  1 +
 utility/block.go                           |  4 +-
 12 files changed, 79 insertions(+), 68 deletions(-)

diff --git a/consensus/module.go b/consensus/module.go
index 832ce5f0e..1008a715c 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -243,7 +243,7 @@ func (m *consensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage)
 }
 
 func (m *consensusModule) AppHash() string {
-	return m.appHash
+	return m.appHash // TODO: This is a problem
 }
 
 func (m *consensusModule) CurrentHeight() uint64 {
diff --git a/persistence/application.go b/persistence/application.go
index 98d62fd7f..c3a13e0f2 100644
--- a/persistence/application.go
+++ b/persistence/application.go
@@ -28,8 +28,6 @@ func (p PostgresContext) UpdateAppTree(apps [][]byte) error {
 	return nil
 }
 
-// TODO_IN_THIS_COMMIT: Not exposed via interface yet
-// func (p PostgresContext) getAppsUpdated(height int64) (apps [][]byte, err error) {
 func (p PostgresContext) getAppsUpdated(height int64) (apps []*typesGenesis.App, err error) {
 	actors, err := p.GetActorsUpdated(schema.ApplicationActor, height)
 	if err != nil {
@@ -37,12 +35,14 @@ func (p PostgresContext) getAppsUpdated(height int64) (apps []*typesGenesis.App,
 	}
 
 	for _, actor := range actors {
-		// This breaks the pattern of protos in persistence
+		// DISCUSS_IN_THIS_COMMIT: This breaks the pattern of protos in persistence.
+		// 	- Is it okay?
+		// 	- Do we embed this logic in `UpdateAppTree`
 		app := &typesGenesis.App{
 			Address:   []byte(actor.Address),
 			PublicKey: []byte(actor.PublicKey),
-			// Paused:          actor.Paused,
-			// Status:          actor.Status,
+			// Paused:          actor.Paused, // DISCUSS_IN_THIS_COMMIT: Is this just a check for pause height = -1?
+			// Status:          actor.Status, // TODO_IN_THIS_COMMIT: Use logic from `GetActorStatus` without an extra query
 			Chains:          actor.Chains,
 			MaxRelays:       actor.ActorSpecificParam,
 			StakedTokens:    actor.StakedTokens,
diff --git a/persistence/block.go b/persistence/block.go
index 8055ee566..2f01afeca 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -9,6 +9,7 @@ import (
 	"github.com/pokt-network/pocket/persistence/schema"
 )
 
+// TODO_IN_THIS_COMMIT: Out of scope so we might just need to do this as part of state sync
 func (p *persistenceModule) shouldLoadBlockStore() bool {
 	if _, err := os.Stat(p.GetBus().GetConfig().Persistence.BlockStorePath); err == nil {
 		return true
@@ -61,7 +62,7 @@ func (p PostgresContext) StoreBlock(blockProtoBytes []byte) error {
 	// INVESTIGATE: Note that we are writing this directly to the blockStore. Depending on how
 	// the use of the PostgresContext evolves, we may need to write this to `ContextStore` and copy
 	// over to `BlockStore` when the block is committed.
-	return p.BlockStore.Put(heightToBytes(p.Height), blockProtoBytes)
+	return p.BlockStore.Set(heightToBytes(p.Height), blockProtoBytes)
 }
 
 func (p PostgresContext) InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error {
diff --git a/persistence/context.go b/persistence/context.go
index 1cbf22739..9809bbd2c 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -14,9 +14,17 @@ func (p PostgresContext) RollbackToSavePoint(bytes []byte) error {
 	return nil
 }
 
+func (p PostgresContext) UpdateAppHash() ([]byte, error) {
+	if _, err := p.updateStateHash(); err != nil {
+		return nil, err
+	}
+	return p.StateHash, nil
+}
+
 func (p PostgresContext) AppHash() ([]byte, error) {
-	log.Println("TODO: AppHash not implemented")
-	return []byte("A real app hash, I am not"), nil
+	// log.Println("TODO: AppHash not implemented")
+	// return []byte("A real app hash, I am not"), n
+	return p.StateHash, nil
 }
 
 func (p PostgresContext) Reset() error {
@@ -24,8 +32,11 @@ func (p PostgresContext) Reset() error {
 }
 
 func (p PostgresContext) Commit() error {
-	// HACK: The data has already been written to the postgres DB, so what should we do here? The idea I have is:
 	log.Println("TODO: Postgres context commit is currently a NOOP")
+	// HACK: The data has already been written to the postgres DB, so what should we do here? The idea I have is:
+	// if _, err := p.updateStateHash(); err != nil {
+	// 	return err
+	// }
 	return nil
 }
 
diff --git a/persistence/db.go b/persistence/db.go
index 2a2f411a6..469f7abf7 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -33,12 +33,13 @@ var _ modules.PersistenceContext = &PostgresContext{}
 type PostgresContext struct {
 	Height       int64
 	ContextStore kvstore.KVStore
+	StateHash    []byte
 
 	// IMPROVE: Depending on how the use of `PostgresContext` evolves, we may be able to get
 	// access to these directly via the postgres module.
 	PostgresDB  *pgx.Conn
-	BlockStore  kvstore.KVStore                      // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the module (i.e. not context)
-	MerkleTrees map[MerkleTree]*smt.SparseMerkleTree // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the module (i.e. not context)
+	BlockStore  kvstore.KVStore                      // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context)
+	MerkleTrees map[MerkleTree]*smt.SparseMerkleTree // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context)
 }
 
 func (pg *PostgresContext) GetCtxAndConnection() (context.Context, *pgx.Conn, error) {
diff --git a/persistence/kvstore/kvstore.go b/persistence/kvstore/kvstore.go
index ec00c5427..7eb632089 100644
--- a/persistence/kvstore/kvstore.go
+++ b/persistence/kvstore/kvstore.go
@@ -4,21 +4,26 @@ import (
 	"errors"
 	"log"
 
+	"github.com/celestiaorg/smt"
 	badger "github.com/dgraph-io/badger/v3"
 )
 
+// TODO_IN_THIS_COMMIT: We might be able to remove the `KVStore` interface altogether if we end up using smt.MapStore
 type KVStore interface {
 	// Lifecycle methods
 	Stop() error
 
-	// Accessors
-	Put(key []byte, value []byte) error
-	Get(key []byte) ([]byte, error)
 	Exists(key []byte) (bool, error)
 	ClearAll() error
+
+	// Same interface as in `smt.MapStore``
+	Set(key []byte, value []byte) error
+	Get(key []byte) ([]byte, error)
+	Delete(key []byte) error
 }
 
 var _ KVStore = &badgerKVStore{}
+var _ smt.MapStore = &badgerKVStore{}
 
 var (
 	ErrKVStoreExists    = errors.New("kvstore already exists")
@@ -48,7 +53,7 @@ func NewMemKVStore() KVStore {
 	return badgerKVStore{db: db}
 }
 
-func (store badgerKVStore) Put(key []byte, value []byte) error {
+func (store badgerKVStore) Set(key []byte, value []byte) error {
 	txn := store.db.NewTransaction(true)
 	defer txn.Discard()
 
@@ -85,6 +90,11 @@ func (store badgerKVStore) Get(key []byte) ([]byte, error) {
 	return value, nil
 }
 
+func (store badgerKVStore) Delete(key []byte) error {
+	log.Fatalf("badgerKVStore.Delete not implemented yet")
+	return nil
+}
+
 func (store badgerKVStore) Exists(key []byte) (bool, error) {
 	val, err := store.Get(key)
 	if err != nil {
diff --git a/persistence/module.go b/persistence/module.go
index 08346c423..3ca47ddcc 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -99,8 +99,9 @@ func (p *persistenceModule) Start() error {
 
 	}
 
-	// DISCUSS_IN_THIS_COMMIT: We've been using the module function pattern, but this is cleaner and easier to test
-	trees, err := initializeTrees()
+	// DISCUSS_IN_THIS_COMMIT: We've been using the module function pattern, but this making `initializeTrees`
+	// be able to create and/or load trees outside the scope of the persistence module makes it easier to test.
+	trees, err := newMerkleTrees()
 	if err != nil {
 		return err
 	}
diff --git a/persistence/pre_persistence/persistence.go b/persistence/pre_persistence/persistence.go
index 7bdb3b7b4..237ba93f1 100644
--- a/persistence/pre_persistence/persistence.go
+++ b/persistence/pre_persistence/persistence.go
@@ -184,6 +184,11 @@ func (m *PrePersistenceContext) RollbackToSavePoint(bytes []byte) error {
 	return nil
 }
 
+func (m *PrePersistenceContext) UpdateAppHash() ([]byte, error) {
+	// log.Fatalf("PrePersistenceContext not implementing UpdateAppHash")
+	return nil, nil
+}
+
 // AppHash creates a unique hash based on the global state object
 // NOTE: AppHash is an inefficient, arbitrary, mock implementation that enables the functionality
 // TODO written for replacement, taking any and all better implementation suggestions - even if a temporary measure
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
index 4319ced81..aacfb36e5 100644
--- a/persistence/shared_sql.go
+++ b/persistence/shared_sql.go
@@ -41,6 +41,7 @@ func (p *PostgresContext) GetExists(actorSchema schema.ProtocolActorSchema, addr
 	return
 }
 
+// TODO_IN_THIS_COMMIT: Consolidate logic with `GetActor` to reduce code footprint
 func (p *PostgresContext) GetActorsUpdated(actorSchema schema.ProtocolActorSchema, height int64) (actors []schema.BaseActor, err error) {
 	ctx, conn, err := p.GetCtxAndConnection()
 	if err != nil {
@@ -56,9 +57,15 @@ func (p *PostgresContext) GetActorsUpdated(actorSchema schema.ProtocolActorSchem
 	var actor schema.BaseActor
 	for rows.Next() {
 		if err = rows.Scan(
-			&actor.Address, &actor.PublicKey, &actor.StakedTokens, &actor.ActorSpecificParam,
-			&actor.OutputAddress, &actor.PausedHeight, &actor.UnstakingHeight,
-			&actor.Chains, &height,
+			&actor.Address,
+			&actor.PublicKey,
+			&actor.StakedTokens,
+			&actor.ActorSpecificParam,
+			&actor.OutputAddress,
+			&actor.PausedHeight,
+			&actor.UnstakingHeight,
+			&actor.Chains,
+			&height,
 		); err != nil {
 			return
 		}
diff --git a/persistence/state.go b/persistence/state.go
index ffab52aea..b685208ba 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -15,24 +15,26 @@ type MerkleTree float64
 
 // A work-in-progress list of all the trees we need to update to maintain the overall state
 const (
+	// Actors
 	AppMerkleTree MerkleTree = iota
 	ValMerkleTree
 	FishMerkleTree
 	ServiceNodeMerkleTree
 	AccountMerkleTree
 	PoolMerkleTree
+	// Data / state
 	BlocksMerkleTree
 	ParamsMerkleTree
 	FlagsMerkleTree
 	lastMerkleTree // Used for iteration purposes only - see https://stackoverflow.com/a/64178235/768439
 )
 
-func initializeTrees() (map[MerkleTree]*smt.SparseMerkleTree, error) {
+func newMerkleTrees() (map[MerkleTree]*smt.SparseMerkleTree, error) {
 	// We need a separate Merkle tree for each type of actor or storage
 	trees := make(map[MerkleTree]*smt.SparseMerkleTree, int(lastMerkleTree))
 
 	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
-		// Initialize two new key-value store to store the nodes and values of the tree
+		// TODO_IN_THIS_COMMIT: Rather than using `NewSimpleMap`, use a disk based key-value store
 		nodeStore := smt.NewSimpleMap()
 		valueStore := smt.NewSimpleMap()
 
@@ -41,11 +43,18 @@ func initializeTrees() (map[MerkleTree]*smt.SparseMerkleTree, error) {
 	return trees, nil
 }
 
-func loadTrees(map[MerkleTree]*smt.SparseMerkleTree, error) {
-
+func loadMerkleTrees(map[MerkleTree]*smt.SparseMerkleTree, error) {
+	log.Fatalf("loadMerkleTrees not implemented yet")
 }
 
-func (p *PostgresContext) updateStateCommitment() ([]byte, error) {
+// DISCUSS_IN_THIS_COMMIT(drewskey): Thoughts on this approach?
+// 1. Retrieves all of the actors / data types updated at the current height
+// 2. Updates the Merkle Tree associated with each actor / data type
+//    - This operation is idempotent so you can call `updateStateHash` as often as you want
+// 3. Update the context's "cached" state hash
+// 4. Returns the state hash
+func (p *PostgresContext) updateStateHash() ([]byte, error) {
+	// Update all the merkle trees
 	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
 		switch treeType {
 		case AppMerkleTree:
@@ -54,17 +63,18 @@ func (p *PostgresContext) updateStateCommitment() ([]byte, error) {
 				return nil, types.NewError(types.Code(42), "Couldn't figure out apps updated") // TODO_IN_THIS_COMMIT
 			}
 			for _, app := range apps {
-				// OPTIMIZE: Do we want to store the serialized bytes or a hash of it in the KV store?
 				appBytes, err := proto.Marshal(app)
 				if err != nil {
 					return nil, err
 				}
+				// An update results in a create/update that is idempotent
 				if _, err := p.MerkleTrees[treeType].Update(app.Address, appBytes); err != nil {
 					return nil, err
 				}
+				// TODO_IN_THIS_COMMIT: Add support for `Delete` operations to remove it from the tree
 			}
 		default:
-			log.Fatalln("Not handeled uet in state commitment update")
+			log.Fatalln("Not handled yet in state commitment update", treeType)
 		}
 	}
 
@@ -83,42 +93,6 @@ func (p *PostgresContext) updateStateCommitment() ([]byte, error) {
 	rootsConcat := bytes.Join(roots, []byte{})
 	stateHash := sha256.Sum256(rootsConcat)
 
-	return stateHash[:], nil
+	p.StateHash = stateHash[:]
+	return p.StateHash, nil
 }
-
-// computeStateHash(root)
-// context := p.
-// Update the Merkle Tree associated with each actor
-// for _, actorType := range typesUtil.ActorTypes {
-// 	// Need to get all the actors updated at this height
-// 	switch actorType {
-// 	case typesUtil.ActorType_App:
-// 		apps, err := u.Context.GetAppsUpdated(u.LatestHeight) // shouldn't need to pass in a height here
-// 		if err != nil {
-// 			return types.NewError(types.Code(42), "Couldn't figure out apps updated")
-// 		}
-// 		if err := u.Context.UpdateAppTree(apps); err != nil {
-// 			return nil
-// 		}
-// 	case typesUtil.ActorType_Val:
-// 		fallthrough
-// 	case typesUtil.ActorType_Fish:
-// 		fallthrough
-// 	case typesUtil.ActorType_Node:
-// 		fallthrough
-// 	default:
-// 		log.Fatalf("Actor type not supported: %s", actorType)
-// 	}
-// }
-
-// TODO: Update Merkle Tree for Accounts
-
-// TODO: Update Merkle Tree for Pools
-
-// TODO:Update Merkle Tree for Blocks
-
-// TODO: Update Merkle Tree for Params
-
-// TODO: Update Merkle Tree for Flags
-
-// return nil
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index a3a7242d4..555075312 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -37,6 +37,7 @@ type PersistenceContext interface {
 	Commit() error
 	Release() // IMPROVE: Return an error?
 
+	UpdateAppHash() ([]byte, error)
 	AppHash() ([]byte, error)
 	GetHeight() (int64, error)
 
diff --git a/utility/block.go b/utility/block.go
index 3a8d2e501..4ce17aaf3 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -74,8 +74,8 @@ func (u *UtilityContext) EndBlock(proposer []byte) types.Error {
 	if err := u.BeginUnstakingMaxPaused(); err != nil {
 		return err
 	}
-	if err := u.updateStateCommitment(); err != nil {
-		return err
+	if _, err := u.Context.UpdateAppHash(); err != nil {
+		return types.ErrAppHash(err)
 	}
 	return nil
 }

From 4551843bad85bcf5cd4704f3ec0c852fda078548 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 20 Sep 2022 16:04:50 -0700
Subject: [PATCH 007/227] Resolved some conflicts to make 'make develop_test'
 work

---
 go.mod                            |  2 +-
 persistence/application.go        | 30 +++++-----
 persistence/block.go              |  5 +-
 persistence/kvstore/kvstore.go    |  2 -
 persistence/module.go             | 28 ++++-----
 persistence/shared_sql.go         | 10 ++--
 persistence/state.go              | 11 +++-
 shared/indexer/indexer.go         | 11 ++--
 shared/types/genesis/validator.go | 95 +++++++++++++++----------------
 utility/block.go                  |  2 +-
 10 files changed, 100 insertions(+), 96 deletions(-)

diff --git a/go.mod b/go.mod
index 72201023a..f1507cdd9 100644
--- a/go.mod
+++ b/go.mod
@@ -40,7 +40,7 @@ require (
 	github.com/dustin/go-humanize v1.0.0 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b // indirect
-	github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6 // indirect
+	github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e // indirect
 	github.com/golang/protobuf v1.5.2
 	github.com/golang/snappy v0.0.3 // indirect
 	github.com/google/flatbuffers v1.12.1 // indirect
diff --git a/persistence/application.go b/persistence/application.go
index a7f2c4325..cc5a8ed72 100644
--- a/persistence/application.go
+++ b/persistence/application.go
@@ -5,10 +5,9 @@ import (
 	"log"
 
 	"github.com/golang/protobuf/proto"
-	"github.com/pokt-network/pocket/persistence/schema"
-	"github.com/pokt-network/pocket/shared/types"
+	"github.com/pokt-network/pocket/persistence/types"
 
-	typesGenesis "github.com/pokt-network/pocket/shared/types/genesis"
+	"github.com/pokt-network/pocket/shared/modules"
 )
 
 func (p PostgresContext) GetAppExists(address []byte, height int64) (exists bool, err error) {
@@ -17,19 +16,20 @@ func (p PostgresContext) GetAppExists(address []byte, height int64) (exists bool
 
 func (p PostgresContext) UpdateAppTree(apps [][]byte) error {
 	for _, app := range apps {
-		appProto := typesGenesis.App{}
+		appProto := types.Actor{}
 		if err := proto.Unmarshal(app, &appProto); err != nil {
 			return err
 		}
-		if _, err := p.MerkleTrees[AppMerkleTree].Update(appProto.Address, app); err != nil {
+		bzAddr, _ := hex.DecodeString(appProto.Address)
+		if _, err := p.MerkleTrees[AppMerkleTree].Update(bzAddr, app); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-func (p PostgresContext) getAppsUpdated(height int64) (apps []*typesGenesis.App, err error) {
-	actors, err := p.GetActorsUpdated(schema.ApplicationActor, height)
+func (p PostgresContext) getAppsUpdated(height int64) (apps []*types.Actor, err error) {
+	actors, err := p.GetActorsUpdated(types.ApplicationActor, height)
 	if err != nil {
 		return nil, err
 	}
@@ -38,17 +38,17 @@ func (p PostgresContext) getAppsUpdated(height int64) (apps []*typesGenesis.App,
 		// DISCUSS_IN_THIS_COMMIT: This breaks the pattern of protos in persistence.
 		// 	- Is it okay?
 		// 	- Do we embed this logic in `UpdateAppTree`
-		app := &typesGenesis.App{
-			Address:   []byte(actor.Address),
-			PublicKey: []byte(actor.PublicKey),
+		app := &types.Actor{
+			Address:   actor.Address,
+			PublicKey: actor.PublicKey,
 			// Paused:          actor.Paused, // DISCUSS_IN_THIS_COMMIT: Is this just a check for pause height = -1?
 			// Status:          actor.Status, // TODO_IN_THIS_COMMIT: Use logic from `GetActorStatus` without an extra query
-			Chains:          actor.Chains,
-			MaxRelays:       actor.ActorSpecificParam,
-			StakedTokens:    actor.StakedTokens,
+			Chains: actor.Chains,
+			// MaxRelays:       actor.ActorSpecificParam,
+			// StakedTokens:    actor.StakedTokens,
 			PausedHeight:    actor.PausedHeight,
 			UnstakingHeight: actor.UnstakingHeight,
-			Output:          []byte(actor.OutputAddress),
+			Output:          actor.OutputAddress,
 		}
 		// appBytes, err := proto.Marshal(&app)
 		// if err != nil {
@@ -61,7 +61,7 @@ func (p PostgresContext) getAppsUpdated(height int64) (apps []*typesGenesis.App,
 }
 
 func (p PostgresContext) GetApp(address []byte, height int64) (operator, publicKey, stakedTokens, maxRelays, outputAddress string, pauseHeight, unstakingHeight int64, chains []string, err error) {
-	actor, err := p.GetActor(schema.ApplicationActor, address, height)
+	actor, err := p.GetActor(types.ApplicationActor, address, height)
 	if err != nil {
 		return
 	}
diff --git a/persistence/block.go b/persistence/block.go
index 170f81984..a6ba799a8 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -3,8 +3,9 @@ package persistence
 import (
 	"encoding/binary"
 	"encoding/hex"
-	"github.com/pokt-network/pocket/persistence/types"
 	"log"
+
+	"github.com/pokt-network/pocket/persistence/types"
 )
 
 // OPTIMIZE(team): get from blockstore or keep in memory
@@ -52,7 +53,7 @@ func (p PostgresContext) StoreBlock(blockProtoBytes []byte) error {
 	// INVESTIGATE: Note that we are writing this directly to the blockStore. Depending on how
 	// the use of the PostgresContext evolves, we may need to write this to `ContextStore` and copy
 	// over to `BlockStore` when the block is committed.
-	return p.DB.Blockstore.Put(heightToBytes(p.Height), blockProtoBytes)
+	return p.DB.Blockstore.Set(heightToBytes(p.Height), blockProtoBytes)
 }
 
 func (p PostgresContext) InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error {
diff --git a/persistence/kvstore/kvstore.go b/persistence/kvstore/kvstore.go
index 03ee1b83a..b2b11a5bd 100644
--- a/persistence/kvstore/kvstore.go
+++ b/persistence/kvstore/kvstore.go
@@ -15,8 +15,6 @@ type KVStore interface {
 
 	// Accessors
 	// TODO: Add a proper iterator interface
-	Put(key []byte, value []byte) error
-	Get(key []byte) ([]byte, error)
 	// TODO: Add pagination for `GetAll`
 	GetAll(prefixKey []byte, descending bool) ([][]byte, error)
 
diff --git a/persistence/module.go b/persistence/module.go
index b9007bee4..a8ece5bae 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -26,7 +26,6 @@ type PersistenceModule struct {
 	postgresURL string
 	nodeSchema  string
 	genesisPath string
-	blockStore  kvstore.KVStore // INVESTIGATE: We may need to create a custom `BlockStore` package in the future
 
 	// TECHDEBT: Need to implement context pooling (for writes), timeouts (for read & writes), etc...
 	writeContext *PostgresContext // only one write context is allowed at a time
@@ -37,7 +36,7 @@ type PersistenceModule struct {
 	// INVESTIGATE: We may need to create a custom `BlockStore` package in the future.
 	blockStore kvstore.KVStore
 	// A mapping of context IDs to persistence contexts
-	contexts map[contextId]modules.PersistenceContext
+	// contexts map[contextId]modules.PersistenceRWContext
 	// Merkle trees
 	trees map[MerkleTree]*smt.SparseMerkleTree
 }
@@ -81,10 +80,20 @@ func Create(configPath, genesisPath string) (modules.PersistenceModule, error) {
 		genesisPath:  genesisPath,
 		blockStore:   blockStore,
 		writeContext: nil,
-		contexts:     make(map[contextId]modules.PersistenceContext),
-		trees:        make(map[MerkleTree]*smt.SparseMerkleTree),
+		// contexts:     make(map[contextId]modules.PersistenceContext),
+		trees: make(map[MerkleTree]*smt.SparseMerkleTree),
 	}
 
+	// DISCUSS_IN_THIS_COMMIT: We've been using the module function pattern, but this making `initializeTrees`
+	// be able to create and/or load trees outside the scope of the persistence module makes it easier to test.
+	trees, err := newMerkleTrees()
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO_IN_THIS_COMMIT: load trees from state
+	persistenceMod.trees = trees
+
 	// Determine if we should hydrate the genesis db or use the current state of the DB attached
 	if shouldHydrateGenesis, err := persistenceMod.shouldHydrateGenesisDb(); err != nil {
 		return nil, err
@@ -98,15 +107,6 @@ func Create(configPath, genesisPath string) (modules.PersistenceModule, error) {
 		log.Println("Loading state from previous state...")
 	}
 
-	// DISCUSS_IN_THIS_COMMIT: We've been using the module function pattern, but this making `initializeTrees`
-	// be able to create and/or load trees outside the scope of the persistence module makes it easier to test.
-	trees, err := newMerkleTrees()
-	if err != nil {
-		return err
-	}
-	// TODO_IN_THIS_COMMIT: load trees from state
-	p.trees = trees
-
 	return persistenceMod, nil
 }
 
@@ -241,7 +241,7 @@ func initializeBlockStore(blockStorePath string) (kvstore.KVStore, error) {
 	if blockStorePath == "" {
 		return kvstore.NewMemKVStore(), nil
 	}
-	return kvstore.NewKVStore(blockStorePath)
+	return kvstore.OpenKVStore(blockStorePath)
 }
 
 // TODO(drewsky): Simplify and externalize the logic for whether genesis should be populated and
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
index d0b1a323d..1721ce884 100644
--- a/persistence/shared_sql.go
+++ b/persistence/shared_sql.go
@@ -45,19 +45,19 @@ func (p *PostgresContext) GetExists(actorSchema types.ProtocolActorSchema, addre
 }
 
 // TODO_IN_THIS_COMMIT: Consolidate logic with `GetActor` to reduce code footprint
-func (p *PostgresContext) GetActorsUpdated(actorSchema schema.ProtocolActorSchema, height int64) (actors []schema.BaseActor, err error) {
-	ctx, conn, err := p.GetCtxAndConnection()
+func (p *PostgresContext) GetActorsUpdated(actorSchema types.ProtocolActorSchema, height int64) (actors []types.BaseActor, err error) {
+	ctx, tx, err := p.DB.GetCtxAndTxn()
 	if err != nil {
 		return
 	}
 
-	rows, err := conn.Query(ctx, actorSchema.GetUpdatedAtHeightQuery(height))
+	rows, err := tx.Query(ctx, actorSchema.GetUpdatedAtHeightQuery(height))
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
 
-	var actor schema.BaseActor
+	var actor types.BaseActor
 	for rows.Next() {
 		if err = rows.Scan(
 			&actor.Address,
@@ -77,7 +77,7 @@ func (p *PostgresContext) GetActorsUpdated(actorSchema schema.ProtocolActorSchem
 			continue
 		}
 
-		chainRows, chainsErr := conn.Query(ctx, actorSchema.GetChainsQuery(actor.Address, height))
+		chainRows, chainsErr := tx.Query(ctx, actorSchema.GetChainsQuery(actor.Address, height))
 		if err != nil {
 			return nil, chainsErr // Why couldn't I just `return` here and use `err`?
 		}
diff --git a/persistence/state.go b/persistence/state.go
index b685208ba..6e7abd9e7 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -3,11 +3,12 @@ package persistence
 import (
 	"bytes"
 	"crypto/sha256"
+	"encoding/hex"
 	"log"
 	"sort"
 
 	"github.com/celestiaorg/smt"
-	"github.com/pokt-network/pocket/shared/types"
+	typesUtil "github.com/pokt-network/pocket/utility/types"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -60,7 +61,7 @@ func (p *PostgresContext) updateStateHash() ([]byte, error) {
 		case AppMerkleTree:
 			apps, err := p.getAppsUpdated(p.Height)
 			if err != nil {
-				return nil, types.NewError(types.Code(42), "Couldn't figure out apps updated") // TODO_IN_THIS_COMMIT
+				return nil, typesUtil.NewError(typesUtil.Code(42), "Couldn't figure out apps updated") // TODO_IN_THIS_COMMIT
 			}
 			for _, app := range apps {
 				appBytes, err := proto.Marshal(app)
@@ -68,7 +69,11 @@ func (p *PostgresContext) updateStateHash() ([]byte, error) {
 					return nil, err
 				}
 				// An update results in a create/update that is idempotent
-				if _, err := p.MerkleTrees[treeType].Update(app.Address, appBytes); err != nil {
+				addrBz, err := hex.DecodeString(app.Address)
+				if err != nil {
+					return nil, err
+				}
+				if _, err := p.MerkleTrees[treeType].Update(addrBz, appBytes); err != nil {
 					return nil, err
 				}
 				// TODO_IN_THIS_COMMIT: Add support for `Delete` operations to remove it from the tree
diff --git a/shared/indexer/indexer.go b/shared/indexer/indexer.go
index 559ca1f6e..3c5d7167a 100644
--- a/shared/indexer/indexer.go
+++ b/shared/indexer/indexer.go
@@ -5,6 +5,7 @@ package indexer
 import (
 	"encoding/hex"
 	"fmt"
+
 	"github.com/pokt-network/pocket/shared/codec"
 
 	"github.com/jordanorelli/lexnum"
@@ -111,7 +112,7 @@ type txIndexer struct {
 }
 
 func NewTxIndexer(databasePath string) (TxIndexer, error) {
-	db, err := kvstore.NewKVStore(databasePath)
+	db, err := kvstore.OpenKVStore(databasePath)
 	return &txIndexer{
 		db: db,
 	}, err
@@ -198,22 +199,22 @@ func (indexer *txIndexer) get(key []byte) (TxResult, error) {
 
 func (indexer *txIndexer) indexByHash(hash, bz []byte) (hashKey []byte, err error) {
 	key := indexer.hashKey(hash)
-	return key, indexer.db.Put(key, bz)
+	return key, indexer.db.Set(key, bz)
 }
 
 func (indexer *txIndexer) indexByHeightAndIndex(height int64, index int32, bz []byte) error {
-	return indexer.db.Put(indexer.heightAndIndexKey(height, index), bz)
+	return indexer.db.Set(indexer.heightAndIndexKey(height, index), bz)
 }
 
 func (indexer *txIndexer) indexBySender(sender string, bz []byte) error {
-	return indexer.db.Put(indexer.senderKey(sender), bz)
+	return indexer.db.Set(indexer.senderKey(sender), bz)
 }
 
 func (indexer *txIndexer) indexByRecipient(recipient string, bz []byte) error {
 	if recipient == "" {
 		return nil
 	}
-	return indexer.db.Put(indexer.recipientKey(recipient), bz)
+	return indexer.db.Set(indexer.recipientKey(recipient), bz)
 }
 
 // key helper functions
diff --git a/shared/types/genesis/validator.go b/shared/types/genesis/validator.go
index 0030f4452..17c2af5fd 100644
--- a/shared/types/genesis/validator.go
+++ b/shared/types/genesis/validator.go
@@ -1,50 +1,49 @@
 package genesis
 
-import (
-	"encoding/hex"
-	"encoding/json"
-
-	"google.golang.org/protobuf/encoding/protojson"
-)
-
-// TODO_IN_THIS_COMMIT: See https://github.com/pokt-network/pocket/pull/139/files to remove this shit
-
-
-// HACK: Since the protocol actor protobufs (e.g. validator, fisherman, etc) use `bytes` for some
-// fields (e.g. `address`, `output`, `publicKey`), we need to use a helper struct to unmarshal the
-// the types when they are defined via json (e.g. genesis file, testing configurations, etc...).
-// Alternative solutions could include whole wrapper structs (i.e. duplication of schema definition),
-// using strings instead of bytes (i.e. major change with downstream effects) or avoid defining these
-// types in json altogether (i.e. limitation of usability).
-type JsonBytesLoaderHelper struct {
-	Address   HexData `json:"address,omitempty"`
-	PublicKey HexData `json:"public_key,omitempty"`
-	Output    HexData `json:"output,omitempty"`
-}
-
-type HexData []byte
-
-func (h *HexData) UnmarshalJSON(data []byte) error {
-	var s string
-	if err := json.Unmarshal(data, &s); err != nil {
-		return err
-	}
-	decoded, err := hex.DecodeString(s)
-	if err != nil {
-		return err
-	}
-	*h = HexData(decoded)
-	return nil
-}
-
-func (v *Validator) UnmarshalJSON(data []byte) error {
-	var jh JsonBytesLoaderHelper
-	json.Unmarshal(data, &jh)
-
-	protojson.Unmarshal(data, v)
-	v.Address = jh.Address
-	v.PublicKey = jh.PublicKey
-	v.Output = jh.Output
-
-	return nil
-}
+// import (
+// 	"encoding/hex"
+// 	"encoding/json"
+
+// 	"google.golang.org/protobuf/encoding/protojson"
+// )
+
+// // TODO_IN_THIS_COMMIT: See https://github.com/pokt-network/pocket/pull/139/files to remove this shit
+
+// // HACK: Since the protocol actor protobufs (e.g. validator, fisherman, etc) use `bytes` for some
+// // fields (e.g. `address`, `output`, `publicKey`), we need to use a helper struct to unmarshal the
+// // the types when they are defined via json (e.g. genesis file, testing configurations, etc...).
+// // Alternative solutions could include whole wrapper structs (i.e. duplication of schema definition),
+// // using strings instead of bytes (i.e. major change with downstream effects) or avoid defining these
+// // types in json altogether (i.e. limitation of usability).
+// type JsonBytesLoaderHelper struct {
+// 	Address   HexData `json:"address,omitempty"`
+// 	PublicKey HexData `json:"public_key,omitempty"`
+// 	Output    HexData `json:"output,omitempty"`
+// }
+
+// type HexData []byte
+
+// func (h *HexData) UnmarshalJSON(data []byte) error {
+// 	var s string
+// 	if err := json.Unmarshal(data, &s); err != nil {
+// 		return err
+// 	}
+// 	decoded, err := hex.DecodeString(s)
+// 	if err != nil {
+// 		return err
+// 	}
+// 	*h = HexData(decoded)
+// 	return nil
+// }
+
+// func (v *Validator) UnmarshalJSON(data []byte) error {
+// 	var jh JsonBytesLoaderHelper
+// 	json.Unmarshal(data, &jh)
+
+// 	protojson.Unmarshal(data, v)
+// 	v.Address = jh.Address
+// 	v.PublicKey = jh.PublicKey
+// 	v.Output = jh.Output
+
+// 	return nil
+// }
diff --git a/utility/block.go b/utility/block.go
index bc387fabf..acf148ca4 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -90,7 +90,7 @@ func (u *UtilityContext) EndBlock(proposer []byte) typesUtil.Error {
 		return err
 	}
 	if _, err := u.Context.UpdateAppHash(); err != nil {
-		return types.ErrAppHash(err)
+		return typesUtil.ErrAppHash(err)
 	}
 	return nil
 }

From eb9de301cb34df7b703a134c94b9869b41bc091e Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 21 Sep 2022 18:28:10 -0700
Subject: [PATCH 008/227] WIP

---
 Makefile                             |  3 +-
 go.mod                               |  2 +-
 persistence/StateHash.md             | 71 ++++++++++++++++++++++++++++
 persistence/application.go           | 52 ++++++++++----------
 persistence/db.go                    |  1 +
 persistence/genesis.go               |  2 +-
 persistence/shared_sql.go            | 49 +++++--------------
 persistence/state.go                 | 31 ++++++------
 persistence/types/base_actor.go      |  4 +-
 persistence/types/protocol_actor.go  |  2 +-
 shared/modules/persistence_module.go | 53 +++++++++++++++++++--
 11 files changed, 182 insertions(+), 88 deletions(-)
 create mode 100644 persistence/StateHash.md

diff --git a/Makefile b/Makefile
index 12338ed37..c0aa0036f 100644
--- a/Makefile
+++ b/Makefile
@@ -347,9 +347,10 @@ benchmark_p2p_addrbook:
 # HACK          - Like TECHDEBT, but much worse. This needs to be prioritized
 # REFACTOR      - Similar to TECHDEBT, but will require a substantial rewrite and change across the codebase
 # CONSIDERATION - A comment that involves extra work but was thoughts / considered as part of some implementation
+# CONSOLIDATE   - We likely have similar implementations/types of the same thing, and we should consolidate them.
 # DISCUSS_IN_THIS_COMMIT - SHOULD NEVER BE COMMITTED TO MASTER. It is a way for the reviewer of a PR to start / reply to a discussion.
 # TODO_IN_THIS_COMMIT    - SHOULD NEVER BE COMMITTED TO MASTER. It is a way to start the review process while non-critical changes are still in progress
-TODO_KEYWORDS = -e "TODO" -e "TECHDEBT" -e "IMPROVE" -e "DISCUSS" -e "INCOMPLETE" -e "INVESTIGATE" -e "CLEANUP" -e "HACK" -e "REFACTOR" -e "CONSIDERATION" -e "TODO_IN_THIS_COMMIT" -e "DISCUSS_IN_THIS_COMMIT"
+TODO_KEYWORDS = -e "TODO" -e "TECHDEBT" -e "IMPROVE" -e "DISCUSS" -e "INCOMPLETE" -e "INVESTIGATE" -e "CLEANUP" -e "HACK" -e "REFACTOR" -e "CONSIDERATION" -e "TODO_IN_THIS_COMMIT" -e "DISCUSS_IN_THIS_COMMIT" -e "CONSOLIDATE"
 
 # How do I use TODOs?
 # 1. <KEYWORD>: <Description of follow up work>;
diff --git a/go.mod b/go.mod
index f1507cdd9..6e76ac253 100644
--- a/go.mod
+++ b/go.mod
@@ -41,7 +41,7 @@ require (
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b // indirect
 	github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e // indirect
-	github.com/golang/protobuf v1.5.2
+	github.com/golang/protobuf v1.5.2 // indirect
 	github.com/golang/snappy v0.0.3 // indirect
 	github.com/google/flatbuffers v1.12.1 // indirect
 	github.com/gotestyourself/gotestyourself v2.2.0+incompatible // indirect
diff --git a/persistence/StateHash.md b/persistence/StateHash.md
new file mode 100644
index 000000000..bf22494b3
--- /dev/null
+++ b/persistence/StateHash.md
@@ -0,0 +1,71 @@
+# This discussion is aimed at:
+
+1. Defining how we should compute the state hash
+2. Identify potential changes needed in the current codebase
+3. Propose next steps and actionable on implementation
+
+## Goals:
+
+- Define how the state hash will be computed
+- Propose the necessary changes in separate tasks
+- Implement each of the necessary pieces
+
+## Non-goals:
+
+- Choice/decision of Merkle Tree Design & Implementation
+- Selection of a key-value store engine
+
+## Primitives / non-negotiables:
+
+- We will be using Merkle Trees (and Merkle Proofs) for this design (i.e. not vector commitments)
+- We will be using a SQL engine for this (i.e. specifically PostgresSQL)
+- We will be using Protobufs (not Flatbuffers, json, yaml or other) for the schema
+
+## Necessary technical context:
+
+### DB Engines
+
+Insert table from here: [Merkle Tree Design & Implementation](https://tikv.org/deep-dive/key-value-engine/b-tree-vs-lsm/#summary)
+
+- Most **Key-Value Store DB** Engines use **LSM-trees** -> good for writes
+- Most **SQL DB** Engines use **B-Trees** -> good for reads
+
+_Basically all but there can be exceptions_
+
+### Addressable Merkle Trees
+
+State is stored use an Account Based (non UTXO) based Modle
+
+Insert image from: https://www.horizen.io/blockchain-academy/technology/expert/utxo-vs-account-model/#:~:text=The%20UTXO%20model%20is%20a,constructions%2C%20as%20well%20a%20sharding.
+
+---
+
+### Data Flow
+
+## Basics:
+
+1. Get each actor (flag, param, etc...) updated at a certain height (the context's height)
+2. Compute the protobuf (the deterministic schema we use as source of truth)
+3. Serialize the data struct
+4. Update the corresponding merkle tree
+5. Compute a state hash from the aggregated roots of all trees as per pokt-network/pocket-network-protocol@main/persistence#562-state-transition-sequence-diagram
+
+## Q&A
+
+Q: Can the SQL Engine be changed?
+A: Yes
+
+Q: Can the SQL Engine be removed altogether?
+A: Yes, but hard
+
+Q: Can the protobuf schema change?
+A: Yes, but out-of-scope
+
+Q: Can protobufs be replaced?
+A: Maybe, but out-of-scope
+
+---
+
+Consolidations:
+- Consolidate `UtilActorType` and `persistence.ActorType`
+- `modules.Actors` interface vs `types.Actor` in persistenceGenesis
\ No newline at end of file
diff --git a/persistence/application.go b/persistence/application.go
index cc5a8ed72..292bc83ed 100644
--- a/persistence/application.go
+++ b/persistence/application.go
@@ -4,62 +4,60 @@ import (
 	"encoding/hex"
 	"log"
 
-	"github.com/golang/protobuf/proto"
 	"github.com/pokt-network/pocket/persistence/types"
+	"google.golang.org/protobuf/proto"
 
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
-func (p PostgresContext) GetAppExists(address []byte, height int64) (exists bool, err error) {
-	return p.GetExists(types.ApplicationActor, address, height)
-}
-
-func (p PostgresContext) UpdateAppTree(apps [][]byte) error {
+func (p PostgresContext) UpdateApplicationsTree(apps []modules.Actor) error {
 	for _, app := range apps {
-		appProto := types.Actor{}
-		if err := proto.Unmarshal(app, &appProto); err != nil {
+		bzAddr, err := hex.DecodeString(app.GetAddress())
+		if err != nil {
 			return err
 		}
-		bzAddr, _ := hex.DecodeString(appProto.Address)
-		if _, err := p.MerkleTrees[AppMerkleTree].Update(bzAddr, app); err != nil {
+
+		appBz, err := proto.Marshal(app.(*types.Actor))
+		if err != nil {
+			return err
+		}
+
+		if _, err := p.MerkleTrees[appMerkleTree].Update(bzAddr, appBz); err != nil { // NOTE: This is the only line unique to `Application`
 			return err
 		}
 	}
+
 	return nil
 }
 
-func (p PostgresContext) getAppsUpdated(height int64) (apps []*types.Actor, err error) {
-	actors, err := p.GetActorsUpdated(types.ApplicationActor, height)
+func (p PostgresContext) getApplicationsUpdatedAtHeight(height int64) (apps []*types.Actor, err error) {
+	actors, err := p.GetActorsUpdated(types.ApplicationActor, height) // NOTE: This is the only line unique to `Application`
 	if err != nil {
 		return nil, err
 	}
 
+	apps = make([]*types.Actor, len(actors))
 	for _, actor := range actors {
-		// DISCUSS_IN_THIS_COMMIT: This breaks the pattern of protos in persistence.
-		// 	- Is it okay?
-		// 	- Do we embed this logic in `UpdateAppTree`
 		app := &types.Actor{
-			Address:   actor.Address,
-			PublicKey: actor.PublicKey,
-			// Paused:          actor.Paused, // DISCUSS_IN_THIS_COMMIT: Is this just a check for pause height = -1?
-			// Status:          actor.Status, // TODO_IN_THIS_COMMIT: Use logic from `GetActorStatus` without an extra query
-			Chains: actor.Chains,
-			// MaxRelays:       actor.ActorSpecificParam,
-			// StakedTokens:    actor.StakedTokens,
+			ActorType:       types.ActorType_App,
+			Address:         actor.Address,
+			PublicKey:       actor.PublicKey,
+			Chains:          actor.Chains,
+			GenericParam:    actor.ActorSpecificParam,
+			StakedAmount:    actor.StakedTokens,
 			PausedHeight:    actor.PausedHeight,
 			UnstakingHeight: actor.UnstakingHeight,
 			Output:          actor.OutputAddress,
 		}
-		// appBytes, err := proto.Marshal(&app)
-		// if err != nil {
-		// 	return nil, err
-		// }
-		// apps = append(apps, appBytes)
 		apps = append(apps, app)
 	}
 	return
 }
 
+func (p PostgresContext) GetAppExists(address []byte, height int64) (exists bool, err error) {
+	return p.GetExists(types.ApplicationActor, address, height)
+}
+
 func (p PostgresContext) GetApp(address []byte, height int64) (operator, publicKey, stakedTokens, maxRelays, outputAddress string, pauseHeight, unstakingHeight int64, chains []string, err error) {
 	actor, err := p.GetActor(types.ApplicationActor, address, height)
 	if err != nil {
diff --git a/persistence/db.go b/persistence/db.go
index 60526a3ed..ae3bab35a 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+
 	"github.com/pokt-network/pocket/persistence/types"
 
 	"github.com/celestiaorg/smt"
diff --git a/persistence/genesis.go b/persistence/genesis.go
index e7c6abcaa..727fa4f57 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -316,7 +316,7 @@ func (p PostgresContext) GetAllFishermen(height int64) (f []modules.Actor, err e
 	return
 }
 
-// TODO (Team) deprecate with interface #163 <Bumped to #149> as #163 is getting large
+// CONSOLIDATE: Consolidate `types.BaseActor` with `types.Actor`
 func (p PostgresContext) BaseActorToActor(ba types.BaseActor, actorType types.ActorType) *types.Actor {
 	actor := new(types.Actor)
 	actor.ActorType = actorType
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
index 1721ce884..da6498782 100644
--- a/persistence/shared_sql.go
+++ b/persistence/shared_sql.go
@@ -44,7 +44,6 @@ func (p *PostgresContext) GetExists(actorSchema types.ProtocolActorSchema, addre
 	return
 }
 
-// TODO_IN_THIS_COMMIT: Consolidate logic with `GetActor` to reduce code footprint
 func (p *PostgresContext) GetActorsUpdated(actorSchema types.ProtocolActorSchema, height int64) (actors []types.BaseActor, err error) {
 	ctx, tx, err := p.DB.GetCtxAndTxn()
 	if err != nil {
@@ -57,44 +56,16 @@ func (p *PostgresContext) GetActorsUpdated(actorSchema types.ProtocolActorSchema
 	}
 	defer rows.Close()
 
-	var actor types.BaseActor
+	// OPTIMIZE: Consolidate logic with `GetActor` to reduce code footprint
+	var addr string
 	for rows.Next() {
-		if err = rows.Scan(
-			&actor.Address,
-			&actor.PublicKey,
-			&actor.StakedTokens,
-			&actor.ActorSpecificParam,
-			&actor.OutputAddress,
-			&actor.PausedHeight,
-			&actor.UnstakingHeight,
-			&actor.Chains,
-			&height,
-		); err != nil {
+		if err = rows.Scan(&addr); err != nil {
 			return
 		}
 
-		if actorSchema.GetChainsTableName() == "" {
-			continue
-		}
-
-		chainRows, chainsErr := tx.Query(ctx, actorSchema.GetChainsQuery(actor.Address, height))
+		actor, err := p.GetActor(actorSchema, []byte(addr), height)
 		if err != nil {
-			return nil, chainsErr // Why couldn't I just `return` here and use `err`?
-		}
-		defer chainRows.Close()
-
-		var chainAddr string
-		var chainID string
-		var chainEndHeight int64 // unused
-		for rows.Next() {
-			err = rows.Scan(&chainAddr, &chainID, &chainEndHeight)
-			if err != nil {
-				return
-			}
-			if chainAddr != actor.Address {
-				return nil, fmt.Errorf("weird")
-			}
-			actor.Chains = append(actor.Chains, chainID)
+			return nil, err
 		}
 
 		actors = append(actors, actor)
@@ -116,10 +87,16 @@ func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, addres
 	return p.GetChainsForActor(ctx, txn, actorSchema, actor, height)
 }
 
+// IMPORTANT: Need to consolidate `persistence/types.BaseActor` with `persistence/genesisTypes.Actor`
 func (p *PostgresContext) GetActorFromRow(row pgx.Row) (actor types.BaseActor, height int64, err error) {
 	err = row.Scan(
-		&actor.Address, &actor.PublicKey, &actor.StakedTokens, &actor.ActorSpecificParam,
-		&actor.OutputAddress, &actor.PausedHeight, &actor.UnstakingHeight,
+		&actor.Address,
+		&actor.PublicKey,
+		&actor.StakedTokens,
+		&actor.ActorSpecificParam,
+		&actor.OutputAddress,
+		&actor.PausedHeight,
+		&actor.UnstakingHeight,
 		&height)
 	return
 }
diff --git a/persistence/state.go b/persistence/state.go
index 6e7abd9e7..221ed3f90 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -16,18 +16,21 @@ type MerkleTree float64
 
 // A work-in-progress list of all the trees we need to update to maintain the overall state
 const (
-	// Actors
-	AppMerkleTree MerkleTree = iota
-	ValMerkleTree
-	FishMerkleTree
-	ServiceNodeMerkleTree
-	AccountMerkleTree
-	PoolMerkleTree
-	// Data / state
-	BlocksMerkleTree
-	ParamsMerkleTree
-	FlagsMerkleTree
-	lastMerkleTree // Used for iteration purposes only - see https://stackoverflow.com/a/64178235/768439
+	// Actor  Merkle Trees
+	appMerkleTree MerkleTree = iota
+	valMerkleTree
+	fishMerkleTree
+	serviceNodeMerkleTree
+	accountMerkleTree
+	poolMerkleTree
+
+	// Data / State Merkle Trees
+	blocksMerkleTree
+	paramsMerkleTree
+	flagsMerkleTree
+
+	// Used for iteration purposes only - see https://stackoverflow.com/a/64178235/768439
+	lastMerkleTree
 )
 
 func newMerkleTrees() (map[MerkleTree]*smt.SparseMerkleTree, error) {
@@ -58,8 +61,8 @@ func (p *PostgresContext) updateStateHash() ([]byte, error) {
 	// Update all the merkle trees
 	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
 		switch treeType {
-		case AppMerkleTree:
-			apps, err := p.getAppsUpdated(p.Height)
+		case appMerkleTree:
+			apps, err := p.getApplicationsUpdatedAtHeight(p.Height)
 			if err != nil {
 				return nil, typesUtil.NewError(typesUtil.Code(42), "Couldn't figure out apps updated") // TODO_IN_THIS_COMMIT
 			}
diff --git a/persistence/types/base_actor.go b/persistence/types/base_actor.go
index 9cead8390..054d10393 100644
--- a/persistence/types/base_actor.go
+++ b/persistence/types/base_actor.go
@@ -61,7 +61,7 @@ func (actor *BaseProtocolActorSchema) GetChainsTableSchema() string {
 }
 
 func (actor *BaseProtocolActorSchema) GetUpdatedAtHeightQuery(height int64) string {
-	return SelectAtHeight(AllColsSelector, height, actor.tableName)
+	return SelectAtHeight(AddressCol, height, actor.tableName)
 }
 
 func (actor *BaseProtocolActorSchema) GetQuery(address string, height int64) string {
@@ -154,5 +154,5 @@ func (x *Actor) GetActorTyp() modules.ActorType {
 	if x != nil {
 		return x.GetActorType()
 	}
-	return ActorType_App
+	return ActorType_App // HACK: Is this a hack?
 }
diff --git a/persistence/types/protocol_actor.go b/persistence/types/protocol_actor.go
index 9dd894fca..cb1e23fbf 100644
--- a/persistence/types/protocol_actor.go
+++ b/persistence/types/protocol_actor.go
@@ -16,7 +16,7 @@ type ProtocolActorSchema interface {
 
 	/*** Read/Get Queries ***/
 
-	// Returns a query to retrieve all of a Actors updated at that specific height.
+	// Returns a query to retrieve the addresses of all the Actors updated at that specific height
 	GetUpdatedAtHeightQuery(height int64) string
 	// Returns a query to retrieve all of a single Actor's attributes.
 	GetQuery(address string, height int64) string
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index fdb0c0875..2030f0861 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -1,7 +1,7 @@
 package modules
 
 import (
-	"github.com/pokt-network/pocket/persistence/kvstore"
+	"github.com/pokt-network/pocket/persistence/kvstore" // Should be moved to shared
 	"github.com/pokt-network/pocket/shared/debug"
 )
 
@@ -86,10 +86,6 @@ type PersistenceWriteContext interface {
 	SetAppUnstakingHeightAndStatus(address []byte, unstakingHeight int64, status int) error
 	SetAppStatusAndUnstakingHeightIfPausedBefore(pausedBeforeHeight, unstakingHeight int64, status int) error
 	SetAppPauseHeight(address []byte, height int64) error
-	GetAppOutputAddress(operator []byte, height int64) (output []byte, err error)
-	// App Operations - For Tree Merkling
-	// GetAppsUpdated(height int64) ([][]byte, error) // Returns the apps updates at the given height
-	UpdateAppTree([][]byte) error
 
 	// ServiceNode Operations
 	InsertServiceNode(address []byte, publicKey []byte, output []byte, paused bool, status int, serviceURL string, stakedTokens string, chains []string, pausedHeight int64, unstakingHeight int64) error
@@ -129,6 +125,29 @@ type PersistenceWriteContext interface {
 	// Flag Operations
 	InitFlags() error
 	SetFlag(paramName string, value interface{}, enabled bool) error
+
+	// Tree Operations
+
+	// # Option 1:
+
+	UpdateApplicationsTree([]Actor) error
+	// UpdateValidatorsTree([]Actor) error
+	// UpdateServiceNodesTree([]Actor) error
+	// UpdateFishermanTree([]Actor) error
+	// Update<FutureActors>Tree([]Actor) error
+	// Update<Other>Tree([]Other) error
+
+	// # Option 2:
+	// UpdateActorTree(types.ProtocolActorSchema, []Actor) error
+	// Update<Other>Tree([]Other) error
+
+	// # Option 3:
+	// UpdateApplicationsTree([]Application) error
+	// UpdateValidatorsTree([]Validator) error
+	// UpdateServiceNodesTree([]ServiceNode) error
+	// UpdateFishermanTree([]Fisherman) error
+	// Update<FutureActors>Tree([]FutureActor) error
+	// Update<Other>Tree([]Other) error
 }
 
 type PersistenceReadContext interface {
@@ -207,4 +226,28 @@ type PersistenceReadContext interface {
 	GetIntFlag(paramName string, height int64) (int, bool, error)
 	GetStringFlag(paramName string, height int64) (string, bool, error)
 	GetBytesFlag(paramName string, height int64) ([]byte, bool, error)
+
+	// Tree Operations
+
+	// # Option 1:
+
+	// GetApplicationsUpdatedAtHeight(height int64) ([]Actor, error)
+	// GetValidatorsUpdatedAtHeight(height int64) ([]Actor, error)
+	// GetServiceNodesUpdatedAtHeight(height int64) ([]Actor, error)
+	// GetFishermanUpdatedAtHeight(height int64) ([]Actor, error)
+	// Get<FutureActor>UpdatedAtHeight(height int64) ([]Actor, error)
+	// Get<Other>UpdatedAtHeight(height int64) ([]Actor, error)
+	// Update<Other>Tree(height int64) ([]Actor, error)
+
+	// # Option 2:
+	// Get<FutureActor>UpdatedAtHeight(types.ProtocolActorSchema, height int64) ([]Actor, error)
+	// Get<Other>UpdatedAtHeight(height int64) ([]Other, error)
+
+	// # Option 3:
+	// GetApplicationsUpdatedAtHeight(height int64) ([]Application, error)
+	// GetValidatorsUpdatedAtHeight(height int64) ([]Validator, error)
+	// GetServiceNodesUpdatedAtHeight(height int64) ([]ServiceNode, error)
+	// GetFishermanUpdatedAtHeight(height int64) ([]Fisherman, error)
+	// Get<FutureActor>UpdatedAtHeight(height int64) ([]FutureActor, error)
+	// Get<Other>UpdatedAtHeight(height int64) ([]Other, error)
 }

From e27ff8e8895625d1926bd1f12f9afd8e27fd62ee Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 21 Sep 2022 19:28:18 -0700
Subject: [PATCH 009/227] Interim commit on block related stuff

---
 consensus/block.go                      | 15 +++------------
 consensus/consensus_tests/utils_test.go |  3 +--
 persistence/StateHash.md                |  5 +++--
 persistence/application.go              |  6 ++++--
 persistence/block.go                    | 11 ++++-------
 persistence/context.go                  |  3 ---
 persistence/db.go                       |  3 +--
 persistence/kvstore/kvstore.go          | 11 ++++++++---
 persistence/state.go                    |  7 +------
 shared/indexer/indexer.go               |  8 ++++----
 shared/modules/persistence_module.go    |  3 ++-
 shared/modules/utility_module.go        |  1 -
 utility/block.go                        | 13 +------------
 13 files changed, 32 insertions(+), 57 deletions(-)

diff --git a/consensus/block.go b/consensus/block.go
index ae531bcb8..80b495d95 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -2,9 +2,10 @@ package consensus
 
 import (
 	"encoding/hex"
-	"github.com/pokt-network/pocket/shared/codec"
 	"unsafe"
 
+	"github.com/pokt-network/pocket/shared/codec"
+
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
 
@@ -111,18 +112,8 @@ func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 		return err
 	}
 
-	// IMPROVE(olshansky): temporary solution. `ApplyBlock` above applies the
-	// transactions to the postgres database, and this stores it in the KV store upon commitment.
-	// Instead of calling this directly, an alternative solution is to store the block metadata in
-	// the persistence context and have `CommitPersistenceContext` do this under the hood. However,
-	// additional `Block` metadata will need to be passed through and may change when we merkle the
-	// state hash.
-	if err := m.utilityContext.StoreBlock(blockProtoBytes); err != nil {
-		return err
-	}
-
 	// Commit and release the context
-	if err := m.utilityContext.CommitPersistenceContext(); err != nil {
+	if err := m.utilityContext.CommitPersistenceContext(blockProtoBytes); err != nil {
 		return err
 	}
 
diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 2ab4ff850..b14d01ab3 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -354,7 +354,7 @@ func baseUtilityMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockUti
 		MaxTimes(4)
 
 	utilityContextMock.EXPECT().GetPersistenceContext().Return(persistenceContextMock).AnyTimes()
-	utilityContextMock.EXPECT().CommitPersistenceContext().Return(nil).AnyTimes()
+	utilityContextMock.EXPECT().CommitPersistenceContext(gomock.Any()).Return(nil).AnyTimes()
 	utilityContextMock.EXPECT().ReleaseContext().Return().AnyTimes()
 	utilityContextMock.EXPECT().
 		GetProposalTransactions(gomock.Any(), maxTxBytes, gomock.AssignableToTypeOf(emptyByzValidators)).
@@ -364,7 +364,6 @@ func baseUtilityMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockUti
 		ApplyBlock(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
 		Return(appHash, nil).
 		AnyTimes()
-	utilityContextMock.EXPECT().StoreBlock(gomock.Any()).AnyTimes().Return(nil)
 
 	persistenceContextMock.EXPECT().Commit().Return(nil).AnyTimes()
 
diff --git a/persistence/StateHash.md b/persistence/StateHash.md
index bf22494b3..a930df4fc 100644
--- a/persistence/StateHash.md
+++ b/persistence/StateHash.md
@@ -66,6 +66,7 @@ A: Maybe, but out-of-scope
 
 ---
 
-Consolidations:
+Learnings / Ideas:
+
 - Consolidate `UtilActorType` and `persistence.ActorType`
-- `modules.Actors` interface vs `types.Actor` in persistenceGenesis
\ No newline at end of file
+- `modules.Actors` interface vs `types.Actor` in persistenceGenesis
diff --git a/persistence/application.go b/persistence/application.go
index 292bc83ed..0bd6750bd 100644
--- a/persistence/application.go
+++ b/persistence/application.go
@@ -22,7 +22,8 @@ func (p PostgresContext) UpdateApplicationsTree(apps []modules.Actor) error {
 			return err
 		}
 
-		if _, err := p.MerkleTrees[appMerkleTree].Update(bzAddr, appBz); err != nil { // NOTE: This is the only line unique to `Application`
+		// OPTIMIZE: This is the only line unique to `Application`
+		if _, err := p.MerkleTrees[appMerkleTree].Update(bzAddr, appBz); err != nil {
 			return err
 		}
 	}
@@ -31,7 +32,8 @@ func (p PostgresContext) UpdateApplicationsTree(apps []modules.Actor) error {
 }
 
 func (p PostgresContext) getApplicationsUpdatedAtHeight(height int64) (apps []*types.Actor, err error) {
-	actors, err := p.GetActorsUpdated(types.ApplicationActor, height) // NOTE: This is the only line unique to `Application`
+	// OPTIMIZE: This is the only line unique to `Application`
+	actors, err := p.GetActorsUpdated(types.ApplicationActor, height)
 	if err != nil {
 		return nil, err
 	}
diff --git a/persistence/block.go b/persistence/block.go
index a6ba799a8..49de236fc 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -49,13 +49,6 @@ func (p PostgresContext) StoreTransaction(transactionProtoBytes []byte) error {
 	return nil
 }
 
-func (p PostgresContext) StoreBlock(blockProtoBytes []byte) error {
-	// INVESTIGATE: Note that we are writing this directly to the blockStore. Depending on how
-	// the use of the PostgresContext evolves, we may need to write this to `ContextStore` and copy
-	// over to `BlockStore` when the block is committed.
-	return p.DB.Blockstore.Set(heightToBytes(p.Height), blockProtoBytes)
-}
-
 func (p PostgresContext) InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error {
 	ctx, tx, err := p.DB.GetCtxAndTxn()
 	if err != nil {
@@ -72,3 +65,7 @@ func heightToBytes(height int64) []byte {
 	binary.LittleEndian.PutUint64(heightBytes, uint64(height))
 	return heightBytes
 }
+
+func (p PostgresContext) storeBlock(blockProtoBytes []byte) error {
+	return p.DB.Blockstore.Put(heightToBytes(p.Height), blockProtoBytes)
+}
diff --git a/persistence/context.go b/persistence/context.go
index da6ae9117..57e15e0ad 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -23,8 +23,6 @@ func (p PostgresContext) UpdateAppHash() ([]byte, error) {
 }
 
 func (p PostgresContext) AppHash() ([]byte, error) {
-	// log.Println("TODO: AppHash not implemented")
-	// return []byte("A real app hash, I am not"), n
 	return p.StateHash, nil
 }
 
@@ -46,7 +44,6 @@ func (p PostgresContext) Commit() error {
 	}
 	if err := p.DB.conn.Close(ctx); err != nil {
 		log.Println("[TODO][ERROR] Implement connection pooling. Error when closing DB connecting...", err)
-
 	}
 	return nil
 }
diff --git a/persistence/db.go b/persistence/db.go
index ae3bab35a..060cec041 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -45,8 +45,7 @@ type PostgresContext struct {
 	Height int64
 	DB     PostgresDB
 
-	ContextStore kvstore.KVStore
-	StateHash    []byte
+	StateHash []byte
 
 	// IMPROVE: Depending on how the use of `PostgresContext` evolves, we may be able to get
 	// access to these directly via the postgres module.
diff --git a/persistence/kvstore/kvstore.go b/persistence/kvstore/kvstore.go
index b2b11a5bd..2b5e94292 100644
--- a/persistence/kvstore/kvstore.go
+++ b/persistence/kvstore/kvstore.go
@@ -8,7 +8,6 @@ import (
 	badger "github.com/dgraph-io/badger/v3"
 )
 
-// TODO_IN_THIS_COMMIT: We might be able to remove the `KVStore` interface altogether if we end up using smt.MapStore
 type KVStore interface {
 	// Lifecycle methods
 	Stop() error
@@ -22,7 +21,7 @@ type KVStore interface {
 	ClearAll() error
 
 	// Same interface as in `smt.MapStore``
-	Set(key []byte, value []byte) error
+	Put(key, value []byte) error
 	Get(key []byte) ([]byte, error)
 	Delete(key []byte) error
 }
@@ -58,7 +57,7 @@ func NewMemKVStore() KVStore {
 	return badgerKVStore{db: db}
 }
 
-func (store badgerKVStore) Set(key []byte, value []byte) error {
+func (store badgerKVStore) Put(key, value []byte) error {
 	txn := store.db.NewTransaction(true)
 	defer txn.Discard()
 
@@ -70,6 +69,12 @@ func (store badgerKVStore) Set(key []byte, value []byte) error {
 	return txn.Commit()
 }
 
+// CONSOLIDATE: We might be able to remove the `KVStore` interface altogether if we end up using `smt.MapStore`
+// A wrapper around `Put` to conform to the `smt.MapStore` interface
+func (store *badgerKVStore) Set(key, value []byte) error {
+	return store.Put(key, value)
+}
+
 func (store badgerKVStore) Get(key []byte) ([]byte, error) {
 	txn := store.db.NewTransaction(false)
 	defer txn.Discard()
diff --git a/persistence/state.go b/persistence/state.go
index 221ed3f90..f35f3622b 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -51,12 +51,7 @@ func loadMerkleTrees(map[MerkleTree]*smt.SparseMerkleTree, error) {
 	log.Fatalf("loadMerkleTrees not implemented yet")
 }
 
-// DISCUSS_IN_THIS_COMMIT(drewskey): Thoughts on this approach?
-// 1. Retrieves all of the actors / data types updated at the current height
-// 2. Updates the Merkle Tree associated with each actor / data type
-//    - This operation is idempotent so you can call `updateStateHash` as often as you want
-// 3. Update the context's "cached" state hash
-// 4. Returns the state hash
+// Question: Is this the right approach?
 func (p *PostgresContext) updateStateHash() ([]byte, error) {
 	// Update all the merkle trees
 	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
diff --git a/shared/indexer/indexer.go b/shared/indexer/indexer.go
index 3c5d7167a..59355787f 100644
--- a/shared/indexer/indexer.go
+++ b/shared/indexer/indexer.go
@@ -199,22 +199,22 @@ func (indexer *txIndexer) get(key []byte) (TxResult, error) {
 
 func (indexer *txIndexer) indexByHash(hash, bz []byte) (hashKey []byte, err error) {
 	key := indexer.hashKey(hash)
-	return key, indexer.db.Set(key, bz)
+	return key, indexer.db.Put(key, bz)
 }
 
 func (indexer *txIndexer) indexByHeightAndIndex(height int64, index int32, bz []byte) error {
-	return indexer.db.Set(indexer.heightAndIndexKey(height, index), bz)
+	return indexer.db.Put(indexer.heightAndIndexKey(height, index), bz)
 }
 
 func (indexer *txIndexer) indexBySender(sender string, bz []byte) error {
-	return indexer.db.Set(indexer.senderKey(sender), bz)
+	return indexer.db.Put(indexer.senderKey(sender), bz)
 }
 
 func (indexer *txIndexer) indexByRecipient(recipient string, bz []byte) error {
 	if recipient == "" {
 		return nil
 	}
-	return indexer.db.Set(indexer.recipientKey(recipient), bz)
+	return indexer.db.Put(indexer.recipientKey(recipient), bz)
 }
 
 // key helper functions
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index 2030f0861..14d102c1b 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -51,6 +51,8 @@ type PersistenceWriteContext interface {
 	Commit() error
 	Release() error
 
+	// Question:
+
 	UpdateAppHash() ([]byte, error)
 	AppHash() ([]byte, error)
 
@@ -63,7 +65,6 @@ type PersistenceWriteContext interface {
 	// TODO_TEMPORARY: Including two functions for the SQL and KV Store as an interim solution
 	//                 until we include the schema as part of the SQL Store because persistence
 	//                 currently has no access to the protobuf schema which is the source of truth.
-	StoreBlock(blockProtoBytes []byte) error                                              // Store the block in the KV Store
 	InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error // Writes the block in the SQL database
 
 	// Pool Operations
diff --git a/shared/modules/utility_module.go b/shared/modules/utility_module.go
index 6a58c9440..538579618 100644
--- a/shared/modules/utility_module.go
+++ b/shared/modules/utility_module.go
@@ -14,7 +14,6 @@ type UtilityContext interface {
 	// Block operations
 	GetProposalTransactions(proposer []byte, maxTransactionBytes int, lastBlockByzantineValidators [][]byte) (transactions [][]byte, err error)
 	ApplyBlock(height int64, proposer []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) (appHash []byte, err error)
-	StoreBlock(blockProtoBytes []byte) error
 
 	// Context operations
 	ReleaseContext()
diff --git a/utility/block.go b/utility/block.go
index acf148ca4..00618152c 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -296,18 +296,7 @@ func (u *UtilityContext) StoreBlock(blockProtoBytes []byte) error {
 		return err
 	}
 
-	// Store in SQL Store
-	// OPTIMIZE: Ideally we'd pass in the block proto struct to utility so we don't
-	//           have to unmarshal it here, but that's a major design decision for the interfaces.
-	codec := u.Codec()
-	block := &typesCons.Block{}
-	if err := codec.Unmarshal(blockProtoBytes, block); err != nil {
-		return typesUtil.ErrProtoUnmarshal(err)
-	}
-	header := block.BlockHeader
-	if err := store.InsertBlock(uint64(header.Height), header.Hash, header.ProposerAddress, header.QuorumCertificate); err != nil {
-		return err
-	}
+
 
 	return nil
 }

From 6f5e40a842637fc4aeebe9c66022f066d2535221 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Fri, 23 Sep 2022 15:23:48 -0700
Subject: [PATCH 010/227] Interim commit while cleaning up consensus module

---
 Makefile                                |   3 +-
 consensus/block.go                      |  84 ++-------------
 consensus/consensus_tests/config.json   |   9 ++
 consensus/consensus_tests/genesis.json  |  56 ++++++++++
 consensus/consensus_tests/utils_test.go |   2 +-
 consensus/helpers.go                    |  11 +-
 consensus/hotstuff_handler.go           |  57 ++++++++++
 consensus/hotstuff_leader.go            |  92 ++++++++++++----
 consensus/hotstuff_replica.go           |  80 ++++++++++----
 consensus/module.go                     | 138 ++++++++----------------
 consensus/types/block.go                |  14 +++
 consensus/types/errors.go               |   2 -
 consensus/types/types.go                |   4 +-
 utility/block.go                        |  16 +--
 14 files changed, 337 insertions(+), 231 deletions(-)
 create mode 100755 consensus/consensus_tests/config.json
 create mode 100755 consensus/consensus_tests/genesis.json
 create mode 100644 consensus/hotstuff_handler.go
 create mode 100644 consensus/types/block.go

diff --git a/Makefile b/Makefile
index ac936ae55..311821563 100644
--- a/Makefile
+++ b/Makefile
@@ -343,9 +343,10 @@ benchmark_p2p_addrbook:
 # REFACTOR      - Similar to TECHDEBT, but will require a substantial rewrite and change across the codebase
 # CONSIDERATION - A comment that involves extra work but was thoughts / considered as part of some implementation
 # CONSOLIDATE   - We likely have similar implementations/types of the same thing, and we should consolidate them.
+# DEPRECATE     - Code that should be removed in the future
 # DISCUSS_IN_THIS_COMMIT - SHOULD NEVER BE COMMITTED TO MASTER. It is a way for the reviewer of a PR to start / reply to a discussion.
 # TODO_IN_THIS_COMMIT    - SHOULD NEVER BE COMMITTED TO MASTER. It is a way to start the review process while non-critical changes are still in progress
-TODO_KEYWORDS = -e "TODO" -e "TECHDEBT" -e "IMPROVE" -e "DISCUSS" -e "INCOMPLETE" -e "INVESTIGATE" -e "CLEANUP" -e "HACK" -e "REFACTOR" -e "CONSIDERATION" -e "TODO_IN_THIS_COMMIT" -e "DISCUSS_IN_THIS_COMMIT" -e "CONSOLIDATE"
+TODO_KEYWORDS = -e "TODO" -e "TECHDEBT" -e "IMPROVE" -e "DISCUSS" -e "INCOMPLETE" -e "INVESTIGATE" -e "CLEANUP" -e "HACK" -e "REFACTOR" -e "CONSIDERATION" -e "TODO_IN_THIS_COMMIT" -e "DISCUSS_IN_THIS_COMMIT" -e "CONSOLIDATE" -e "DEPRECATE"
 
 # How do I use TODOs?
 # 1. <KEYWORD>: <Description of follow up work>;
diff --git a/consensus/block.go b/consensus/block.go
index 80b495d95..4ff0a9307 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -1,11 +1,6 @@
 package consensus
 
 import (
-	"encoding/hex"
-	"unsafe"
-
-	"github.com/pokt-network/pocket/shared/codec"
-
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
 
@@ -17,71 +12,6 @@ func (m *ConsensusModule) validateBlock(block *typesCons.Block) error {
 	return nil
 }
 
-// This is a helper function intended to be called by a leader/validator during a view change
-func (m *ConsensusModule) prepareBlockAsLeader() (*typesCons.Block, error) {
-	if m.isReplica() {
-		return nil, typesCons.ErrReplicaPrepareBlock
-	}
-
-	if err := m.refreshUtilityContext(); err != nil {
-		return nil, err
-	}
-
-	txs, err := m.utilityContext.GetProposalTransactions(m.privateKey.Address(), maxTxBytes, lastByzValidators)
-	if err != nil {
-		return nil, err
-	}
-
-	appHash, err := m.utilityContext.ApplyBlock(int64(m.Height), m.privateKey.Address(), txs, lastByzValidators)
-	if err != nil {
-		return nil, err
-	}
-
-	blockHeader := &typesCons.BlockHeader{
-		Height:            int64(m.Height),
-		Hash:              hex.EncodeToString(appHash),
-		NumTxs:            uint32(len(txs)),
-		LastBlockHash:     m.appHash,
-		ProposerAddress:   m.privateKey.Address().Bytes(),
-		QuorumCertificate: []byte("HACK: Temporary placeholder"),
-	}
-
-	block := &typesCons.Block{
-		BlockHeader:  blockHeader,
-		Transactions: txs,
-	}
-
-	return block, nil
-}
-
-// This is a helper function intended to be called by a replica/voter during a view change
-func (m *ConsensusModule) applyBlockAsReplica(block *typesCons.Block) error {
-	if m.isLeader() {
-		return typesCons.ErrLeaderApplyBLock
-	}
-
-	// TODO(olshansky): Add unit tests to verify this.
-	if unsafe.Sizeof(*block) > uintptr(m.MaxBlockBytes) {
-		return typesCons.ErrInvalidBlockSize(uint64(unsafe.Sizeof(*block)), m.MaxBlockBytes)
-	}
-
-	if err := m.refreshUtilityContext(); err != nil {
-		return err
-	}
-
-	appHash, err := m.utilityContext.ApplyBlock(int64(m.Height), block.BlockHeader.ProposerAddress, block.Transactions, lastByzValidators)
-	if err != nil {
-		return err
-	}
-
-	// DISCUSS(drewsky): Is `ApplyBlock` going to return blockHash or appHash?
-	if block.BlockHeader.Hash != hex.EncodeToString(appHash) {
-		return typesCons.ErrInvalidAppHash(block.BlockHeader.Hash, hex.EncodeToString(appHash))
-	}
-
-	return nil
-}
-
 // Creates a new Utility context and clears/nullifies any previous contexts if they exist
 func (m *ConsensusModule) refreshUtilityContext() error {
 	// This is a catch-all to release the previous utility context if it wasn't cleaned up
@@ -106,21 +36,21 @@ func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
 
 	// Store the block in the KV store
-	codec := codec.GetCodec()
-	blockProtoBytes, err := codec.Marshal(block)
-	if err != nil {
-		return err
-	}
+	// codec := codec.GetCodec()
+	// blockProtoBytes, err := codec.Marshal(block)
+	// if err != nil {
+	// 	return err
+	// }
 
 	// Commit and release the context
-	if err := m.utilityContext.CommitPersistenceContext(blockProtoBytes); err != nil {
+	if err := m.utilityContext.CommitPersistenceContext(); err != nil {
 		return err
 	}
 
 	m.utilityContext.ReleaseContext()
 	m.utilityContext = nil
 
-	m.appHash = block.BlockHeader.Hash
+	m.lastAppHash = block.BlockHeader.Hash
 
 	return nil
 }
diff --git a/consensus/consensus_tests/config.json b/consensus/consensus_tests/config.json
new file mode 100755
index 000000000..f3cf88b4a
--- /dev/null
+++ b/consensus/consensus_tests/config.json
@@ -0,0 +1,9 @@
+{
+    "consensus": {
+        "private_key": "70c42b40d1194fcd29a114b0c09fb7a9da32d1bf66039025cf75252cb3e04931b828c891955f35604500a71b9111bddb7bf9481a15250e9508547ea95057f2e9",
+        "max_mempool_bytes": 500000000,
+        "pacemaker_config": {
+            "timeout_msec": 5000
+        }
+    }
+}
\ No newline at end of file
diff --git a/consensus/consensus_tests/genesis.json b/consensus/consensus_tests/genesis.json
new file mode 100755
index 000000000..8650b3b52
--- /dev/null
+++ b/consensus/consensus_tests/genesis.json
@@ -0,0 +1,56 @@
+{
+    "consensus_genesis_state": {
+        "genesis_time": {
+            "seconds": 1663965677,
+            "nanos": 641809000
+        },
+        "chain_id": "testnet",
+        "max_block_bytes": 4000000,
+        "validators": [
+            {
+                "address": "c85045886996fe295a4eaa24a7f07ea74032a0bc",
+                "public_key": "c9356e26cb2987665dc76c2836a1b614646753ab92a517dacecb1a0d472a44fb",
+                "chains": null,
+                "generic_param": "node1.consensus:8080",
+                "staked_amount": "1000000000000",
+                "paused_height": -1,
+                "unstaking_height": -1,
+                "output": "c85045886996fe295a4eaa24a7f07ea74032a0bc",
+                "actor_type": 3
+            },
+            {
+                "address": "e0db8408cea5ed6520e1adc5dc4d1d17239df172",
+                "public_key": "b828c891955f35604500a71b9111bddb7bf9481a15250e9508547ea95057f2e9",
+                "chains": null,
+                "generic_param": "node2.consensus:8080",
+                "staked_amount": "1000000000000",
+                "paused_height": -1,
+                "unstaking_height": -1,
+                "output": "e0db8408cea5ed6520e1adc5dc4d1d17239df172",
+                "actor_type": 3
+            },
+            {
+                "address": "4a1eb7a5787f4c6e556c3b9a3cbfd31a75a4eef4",
+                "public_key": "98762a7038ac4df608200a790ccb5b679d4f720d51a7acf115c5be4a6d0222c0",
+                "chains": null,
+                "generic_param": "node3.consensus:8080",
+                "staked_amount": "1000000000000",
+                "paused_height": -1,
+                "unstaking_height": -1,
+                "output": "4a1eb7a5787f4c6e556c3b9a3cbfd31a75a4eef4",
+                "actor_type": 3
+            },
+            {
+                "address": "3b7500e1509f05533c93c8f6d80af06419901b22",
+                "public_key": "052447ca3b1c8eabb8f5d66d0c34f9ddf466bd03718eb1504ab5a24421a1e5d8",
+                "chains": null,
+                "generic_param": "node4.consensus:8080",
+                "staked_amount": "1000000000000",
+                "paused_height": -1,
+                "unstaking_height": -1,
+                "output": "3b7500e1509f05533c93c8f6d80af06419901b22",
+                "actor_type": 3
+            }
+        ]
+    }
+}
\ No newline at end of file
diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index b14d01ab3..dd687953b 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -354,7 +354,7 @@ func baseUtilityMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockUti
 		MaxTimes(4)
 
 	utilityContextMock.EXPECT().GetPersistenceContext().Return(persistenceContextMock).AnyTimes()
-	utilityContextMock.EXPECT().CommitPersistenceContext(gomock.Any()).Return(nil).AnyTimes()
+	utilityContextMock.EXPECT().CommitPersistenceContext().Return(nil).AnyTimes()
 	utilityContextMock.EXPECT().ReleaseContext().Return().AnyTimes()
 	utilityContextMock.EXPECT().
 		GetProposalTransactions(gomock.Any(), maxTxBytes, gomock.AssignableToTypeOf(emptyByzValidators)).
diff --git a/consensus/helpers.go b/consensus/helpers.go
index 24a84612c..233912ef1 100644
--- a/consensus/helpers.go
+++ b/consensus/helpers.go
@@ -2,9 +2,10 @@ package consensus
 
 import (
 	"encoding/base64"
-	"github.com/pokt-network/pocket/shared/debug"
 	"log"
 
+	"github.com/pokt-network/pocket/shared/debug"
+
 	"google.golang.org/protobuf/proto"
 
 	typesCons "github.com/pokt-network/pocket/consensus/types"
@@ -31,13 +32,11 @@ const (
 
 var (
 	HotstuffSteps = [...]typesCons.HotstuffStep{NewRound, Prepare, PreCommit, Commit, Decide}
-
-	maxTxBytes        = 90000             // TODO(olshansky): Move this to config.json.
-	lastByzValidators = make([][]byte, 0) // TODO(olshansky): Retrieve this from persistence
 )
 
 // ** Hotstuff Helpers ** //
 
+// TODO: Make this method functional (i.e. not have the ConsensusModule receiver)
 func (m *ConsensusModule) getQuorumCertificate(height uint64, step typesCons.HotstuffStep, round uint64) (*typesCons.QuorumCertificate, error) {
 	var pss []*typesCons.PartialSignature
 	for _, msg := range m.MessagePool[step] {
@@ -70,9 +69,9 @@ func (m *ConsensusModule) getQuorumCertificate(height uint64, step typesCons.Hot
 	}
 
 	return &typesCons.QuorumCertificate{
-		Height:             m.Height,
+		Height:             height,
 		Step:               step,
-		Round:              m.Round,
+		Round:              round,
 		Block:              m.Block,
 		ThresholdSignature: thresholdSig,
 	}, nil
diff --git a/consensus/hotstuff_handler.go b/consensus/hotstuff_handler.go
new file mode 100644
index 000000000..a2127cc61
--- /dev/null
+++ b/consensus/hotstuff_handler.go
@@ -0,0 +1,57 @@
+package consensus
+
+import typesCons "github.com/pokt-network/pocket/consensus/types"
+
+// TODO(discuss): Low priority design: think of a way to make `hotstuff_*` files be a sub-package under consensus.
+// This is currently not possible because functions tied to the `ConsensusModule`
+// struct (implementing the ConsensusModule module), which spans multiple files.
+/*
+TODO(discuss): The reason we do not assign both the leader and the replica handlers
+to the leader (which should also act as a replica when it is a leader) is because it
+can create a weird inconsistent state (e.g. both the replica and leader try to restart
+the Pacemaker timeout). This requires additional "replica-like" logic in the leader
+handler which has both pros and cons:
+	Pros:
+		* The leader can short-circuit and optimize replica related logic
+		* Avoids additional code flowing through the P2P pipeline
+		* Allows for micro-optimizations
+	Cons:
+		* The leader's "replica related logic" requires an additional code path
+		* Code is less "generalizable" and therefore potentially more error prone
+*/
+
+type HotstuffMessageHandler interface {
+	HandleNewRoundMessage(*ConsensusModule, *typesCons.HotstuffMessage)
+	HandlePrepareMessage(*ConsensusModule, *typesCons.HotstuffMessage)
+	HandlePrecommitMessage(*ConsensusModule, *typesCons.HotstuffMessage)
+	HandleCommitMessage(*ConsensusModule, *typesCons.HotstuffMessage)
+	HandleDecideMessage(*ConsensusModule, *typesCons.HotstuffMessage)
+}
+
+func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage) {
+	m.nodeLog(typesCons.DebugHandlingHotstuffMessage(msg))
+
+	// Liveness & safety checks
+	if err := m.paceMaker.ValidateMessage(msg); err != nil {
+		// If a replica is not a leader for this round, but has already determined a leader,
+		// and continues to receive NewRound messages, we avoid logging the "message discard"
+		// because it creates unnecessary spam.
+		if !(m.LeaderId != nil && !m.isLeader() && msg.Step == NewRound) {
+			m.nodeLog(typesCons.WarnDiscardHotstuffMessage(msg, err.Error()))
+		}
+		return
+	}
+
+	// Need to execute leader election if there is no leader and we are in a new round.
+	if m.Step == NewRound && m.LeaderId == nil {
+		m.electNextLeader(msg)
+	}
+
+	if m.isReplica() {
+		replicaHandlers[msg.Step](m, msg)
+		return
+	}
+
+	// Note that the leader also acts as a replica, but this logic is implemented in the underlying code.
+	leaderHandlers[msg.Step](m, msg)
+}
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index d691ebc0c..a22ece366 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -1,12 +1,15 @@
 package consensus
 
 import (
+	"encoding/hex"
 	"unsafe"
 
 	consensusTelemetry "github.com/pokt-network/pocket/consensus/telemetry"
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
 
+type HotstuffLeaderMessageHandler struct{}
+
 var (
 	LeaderMessageHandler HotstuffMessageHandler = &HotstuffLeaderMessageHandler{}
 	leaderHandlers                              = map[typesCons.HotstuffStep]func(*ConsensusModule, *typesCons.HotstuffMessage){
@@ -18,32 +21,37 @@ var (
 	}
 )
 
-type HotstuffLeaderMessageHandler struct{}
-
 /*** Prepare Step ***/
 
 func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
 	handler.emitTelemetryEvent(m, msg)
+	defer m.paceMaker.RestartTimer()
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-	// TODO(olshansky): add step specific validation
+
+	// DISCUSS: Do we need to pause for `MinBlockFreqMSec` here to let more transactions or should we stick with optimistic responsiveness?
+
 	if err := m.didReceiveEnoughMessageForStep(NewRound); err != nil {
 		m.nodeLog(typesCons.OptimisticVoteCountWaiting(NewRound, err.Error()))
 		return
 	}
-
-	// TODO(olshansky): Do we need to pause for `MinBlockFreqMSec` here to let more transactions come in?
 	m.nodeLog(typesCons.OptimisticVoteCountPassed(NewRound))
 
+	// Clear the previous utility context, if it exists, and create a new one
+	if err := m.refreshUtilityContext(); err != nil {
+		return
+	}
+
 	// Likely to be `nil` if blockchain is progressing well.
-	highPrepareQC := m.findHighQC(NewRound)
+	highPrepareQC := m.findHighQC(NewRound) // TECHDEBT: How do we validate `highPrepareQC` here?
 
-	// TODO(olshansky): Add more unit tests for these checks...
+	// TODO: Add more unit tests for these checks...
 	if highPrepareQC == nil || highPrepareQC.Height < m.Height || highPrepareQC.Round < m.Round {
-		block, err := m.prepareBlockAsLeader()
+		// Leader prepares a new block if `highPrepareQC` is not applicable
+		block, err := m.prepareAndApplyBlock()
 		if err != nil {
 			m.nodeLogError(typesCons.ErrPrepareBlock.Error(), err)
 			m.paceMaker.InterruptRound()
@@ -51,13 +59,17 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusM
 		}
 		m.Block = block
 	} else {
-		// TODO(discuss): Do we need to validate highPrepareQC here?
+		// Leader acts like a replica if `highPrepareQC` is not `nil`
+		if err := m.applyBlock(highPrepareQC.Block); err != nil {
+			m.nodeLogError(typesCons.ErrApplyBlock.Error(), err)
+			m.paceMaker.InterruptRound()
+			return
+		}
 		m.Block = highPrepareQC.Block
 	}
 
 	m.Step = Prepare
 	m.MessagePool[NewRound] = nil
-	m.paceMaker.RestartTimer()
 
 	prepareProposeMessage, err := CreateProposeMessage(m, Prepare, highPrepareQC)
 	if err != nil {
@@ -71,7 +83,7 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusM
 	prepareVoteMessage, err := CreateVoteMessage(m, Prepare, m.Block)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(Prepare).Error(), err)
-		return // TODO(olshansky): Should we interrupt the round here?
+		return
 	}
 	m.sendToNode(prepareVoteMessage)
 }
@@ -80,18 +92,20 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusM
 
 func (handler *HotstuffLeaderMessageHandler) HandlePrepareMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
 	handler.emitTelemetryEvent(m, msg)
+	defer m.paceMaker.RestartTimer()
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-	// TODO(olshansky): add step specific validation
+
 	if err := m.didReceiveEnoughMessageForStep(Prepare); err != nil {
 		m.nodeLog(typesCons.OptimisticVoteCountWaiting(Prepare, err.Error()))
 		return
 	}
 	m.nodeLog(typesCons.OptimisticVoteCountPassed(Prepare))
 
+	// DISCUSS: What prevents leader from swapping out the block here?
 	prepareQC, err := m.getQuorumCertificate(m.Height, Prepare, m.Round)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrQCInvalid(Prepare).Error(), err)
@@ -101,7 +115,6 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrepareMessage(m *ConsensusMo
 	m.Step = PreCommit
 	m.HighPrepareQC = prepareQC
 	m.MessagePool[Prepare] = nil
-	m.paceMaker.RestartTimer()
 
 	precommitProposeMessages, err := CreateProposeMessage(m, PreCommit, prepareQC)
 	if err != nil {
@@ -115,7 +128,7 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrepareMessage(m *ConsensusMo
 	precommitVoteMessage, err := CreateVoteMessage(m, PreCommit, m.Block)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(PreCommit).Error(), err)
-		return // TODO(olshansky): Should we interrupt the round here?
+		return
 	}
 	m.sendToNode(precommitVoteMessage)
 }
@@ -124,12 +137,13 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrepareMessage(m *ConsensusMo
 
 func (handler *HotstuffLeaderMessageHandler) HandlePrecommitMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
 	handler.emitTelemetryEvent(m, msg)
+	defer m.paceMaker.RestartTimer()
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-	// TODO(olshansky): add step specific validation
+
 	if err := m.didReceiveEnoughMessageForStep(PreCommit); err != nil {
 		m.nodeLog(typesCons.OptimisticVoteCountWaiting(PreCommit, err.Error()))
 		return
@@ -145,7 +159,6 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrecommitMessage(m *Consensus
 	m.Step = Commit
 	m.LockedQC = preCommitQC
 	m.MessagePool[PreCommit] = nil
-	m.paceMaker.RestartTimer()
 
 	commitProposeMessage, err := CreateProposeMessage(m, Commit, preCommitQC)
 	if err != nil {
@@ -168,12 +181,13 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrecommitMessage(m *Consensus
 
 func (handler *HotstuffLeaderMessageHandler) HandleCommitMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
 	handler.emitTelemetryEvent(m, msg)
+	defer m.paceMaker.RestartTimer()
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-	// TODO(olshansky): add step specific validation
+
 	if err := m.didReceiveEnoughMessageForStep(Commit); err != nil {
 		m.nodeLog(typesCons.OptimisticVoteCountWaiting(Commit, err.Error()))
 		return
@@ -188,7 +202,6 @@ func (handler *HotstuffLeaderMessageHandler) HandleCommitMessage(m *ConsensusMod
 
 	m.Step = Decide
 	m.MessagePool[Commit] = nil
-	m.paceMaker.RestartTimer()
 
 	decideProposeMessage, err := CreateProposeMessage(m, Decide, commitQC)
 	if err != nil {
@@ -217,6 +230,7 @@ func (handler *HotstuffLeaderMessageHandler) HandleCommitMessage(m *ConsensusMod
 
 func (handler *HotstuffLeaderMessageHandler) HandleDecideMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
 	handler.emitTelemetryEvent(m, msg)
+	defer m.paceMaker.RestartTimer()
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
@@ -300,3 +314,45 @@ func (m *ConsensusModule) aggregateMessage(msg *typesCons.HotstuffMessage) {
 	// Only the leader needs to aggregate consensus related messages.
 	m.MessagePool[msg.Step] = append(m.MessagePool[msg.Step], msg)
 }
+
+// This is a helper function intended to be called by a leader/validator during a view change
+// to prepare a new block that is applied to the new underlying context.
+func (m *ConsensusModule) prepareAndApplyBlock() (*typesCons.Block, error) {
+	if m.isReplica() {
+		return nil, typesCons.ErrReplicaPrepareBlock
+	}
+
+	// TECHDEBT: Retrieve this from consensus consensus config
+	maxTxBytes := 90000
+
+	// TECHDEBT: Retrieve this from persistence
+	lastByzValidators := make([][]byte, 0)
+
+	// Reap the mempool for transactions to be applied in this block
+	txs, err := m.utilityContext.GetProposalTransactions(m.privateKey.Address(), maxTxBytes, lastByzValidators)
+	if err != nil {
+		return nil, err
+	}
+
+	// Apply all the transactions in the block
+	appHash, err := m.utilityContext.ApplyBlock(int64(m.Height), m.privateKey.Address(), txs, lastByzValidators)
+	if err != nil {
+		return nil, err
+	}
+
+	// Construct the block
+	blockHeader := &typesCons.BlockHeader{
+		Height:            int64(m.Height),
+		Hash:              hex.EncodeToString(appHash),
+		NumTxs:            uint32(len(txs)),
+		LastBlockHash:     m.lastAppHash,
+		ProposerAddress:   m.privateKey.Address().Bytes(),
+		QuorumCertificate: []byte("HACK: Temporary placeholder"),
+	}
+	block := &typesCons.Block{
+		BlockHeader:  blockHeader,
+		Transactions: txs,
+	}
+
+	return block, nil
+}
diff --git a/consensus/hotstuff_replica.go b/consensus/hotstuff_replica.go
index 25041c766..1e814ed41 100644
--- a/consensus/hotstuff_replica.go
+++ b/consensus/hotstuff_replica.go
@@ -1,8 +1,10 @@
 package consensus
 
 import (
+	"encoding/hex"
 	"fmt"
 	"log"
+	"unsafe"
 
 	consensusTelemetry "github.com/pokt-network/pocket/consensus/telemetry"
 	typesCons "github.com/pokt-network/pocket/consensus/types"
@@ -25,13 +27,18 @@ var (
 
 func (handler *HotstuffReplicaMessageHandler) HandleNewRoundMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
 	handler.emitTelemetryEvent(m, msg)
+	defer m.paceMaker.RestartTimer()
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-	// TODO(olshansky): add step specific validation
-	m.paceMaker.RestartTimer()
+
+	// Clear the previous utility context, if it exists, and create a new one
+	if err := m.refreshUtilityContext(); err != nil {
+		return
+	}
+
 	m.Step = Prepare
 }
 
@@ -39,31 +46,33 @@ func (handler *HotstuffReplicaMessageHandler) HandleNewRoundMessage(m *Consensus
 
 func (handler *HotstuffReplicaMessageHandler) HandlePrepareMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
 	handler.emitTelemetryEvent(m, msg)
+	defer m.paceMaker.RestartTimer()
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-	// TODO(olshansky): add step specific validation
+
 	if err := m.validateProposal(msg); err != nil {
 		m.nodeLogError(fmt.Sprintf("Invalid proposal in %s message", Prepare), err)
 		m.paceMaker.InterruptRound()
 		return
 	}
 
-	if err := m.applyBlockAsReplica(msg.Block); err != nil {
+	block := msg.GetBlock()
+	if err := m.applyBlock(block); err != nil {
 		m.nodeLogError(typesCons.ErrApplyBlock.Error(), err)
 		m.paceMaker.InterruptRound()
 		return
 	}
+	m.Block = block
 
 	m.Step = PreCommit
-	m.paceMaker.RestartTimer()
 
-	prepareVoteMessage, err := CreateVoteMessage(m, Prepare, msg.Block)
+	prepareVoteMessage, err := CreateVoteMessage(m, Prepare, block)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(Prepare).Error(), err)
-		return // TODO(olshansky): Should we interrupt the round here?
+		return
 	}
 	m.sendToNode(prepareVoteMessage)
 }
@@ -72,26 +81,27 @@ func (handler *HotstuffReplicaMessageHandler) HandlePrepareMessage(m *ConsensusM
 
 func (handler *HotstuffReplicaMessageHandler) HandlePrecommitMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
 	handler.emitTelemetryEvent(m, msg)
+	defer m.paceMaker.RestartTimer()
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-	// TODO(olshansky): add step specific validation
-	if err := m.validateQuorumCertificate(msg.GetQuorumCertificate()); err != nil {
+
+	quorumCert := msg.GetQuorumCertificate()
+	if err := m.validateQuorumCertificate(quorumCert); err != nil {
 		m.nodeLogError(typesCons.ErrQCInvalid(PreCommit).Error(), err)
 		m.paceMaker.InterruptRound()
 		return
 	}
 
 	m.Step = Commit
-	m.HighPrepareQC = msg.GetQuorumCertificate() // TODO(discuss): Why are we never using this for validation?
-	m.paceMaker.RestartTimer()
+	m.HighPrepareQC = quorumCert // INVESTIGATE: Why are we never using this for validation?
 
 	preCommitVoteMessage, err := CreateVoteMessage(m, PreCommit, msg.Block)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(PreCommit).Error(), err)
-		return // TODO(olshansky): Should we interrupt the round here?
+		return
 	}
 	m.sendToNode(preCommitVoteMessage)
 }
@@ -100,26 +110,27 @@ func (handler *HotstuffReplicaMessageHandler) HandlePrecommitMessage(m *Consensu
 
 func (handler *HotstuffReplicaMessageHandler) HandleCommitMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
 	handler.emitTelemetryEvent(m, msg)
+	defer m.paceMaker.RestartTimer()
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-	// TODO(olshansky): add step specific validation
-	if err := m.validateQuorumCertificate(msg.GetQuorumCertificate()); err != nil {
+
+	quorumCert := msg.GetQuorumCertificate()
+	if err := m.validateQuorumCertificate(quorumCert); err != nil {
 		m.nodeLogError(typesCons.ErrQCInvalid(Commit).Error(), err)
 		m.paceMaker.InterruptRound()
 		return
 	}
 
 	m.Step = Decide
-	m.LockedQC = msg.GetQuorumCertificate() // TODO(discuss): How do the replica recover if it's locked? Replica `formally` agrees on the QC while the rest of the network `verbally` agrees on the QC.
-	m.paceMaker.RestartTimer()
+	m.LockedQC = quorumCert // DISCUSS: How does the replica recover if it's locked? Replica `formally` agrees on the QC while the rest of the network `verbally` agrees on the QC.
 
 	commitVoteMessage, err := CreateVoteMessage(m, Commit, msg.Block)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(Commit).Error(), err)
-		return // TODO(olshansky): Should we interrupt the round here?
+		return
 	}
 	m.sendToNode(commitVoteMessage)
 }
@@ -128,13 +139,15 @@ func (handler *HotstuffReplicaMessageHandler) HandleCommitMessage(m *ConsensusMo
 
 func (handler *HotstuffReplicaMessageHandler) HandleDecideMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
 	handler.emitTelemetryEvent(m, msg)
+	defer m.paceMaker.RestartTimer()
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-	// TODO(olshansky): add step specific validation
-	if err := m.validateQuorumCertificate(msg.GetQuorumCertificate()); err != nil {
+
+	quorumCert := msg.GetQuorumCertificate()
+	if err := m.validateQuorumCertificate(quorumCert); err != nil {
 		m.nodeLogError(typesCons.ErrQCInvalid(Decide).Error(), err)
 		m.paceMaker.InterruptRound()
 		return
@@ -169,7 +182,7 @@ func (handler *HotstuffReplicaMessageHandler) emitTelemetryEvent(m *ConsensusMod
 }
 
 func (m *ConsensusModule) validateProposal(msg *typesCons.HotstuffMessage) error {
-	if !(msg.Type == Propose && msg.Step == Prepare) {
+	if !(msg.GetType() == Propose && msg.GetStep() == Prepare) {
 		return typesCons.ErrProposalNotValidInPrepare
 	}
 
@@ -177,8 +190,9 @@ func (m *ConsensusModule) validateProposal(msg *typesCons.HotstuffMessage) error
 		return err
 	}
 
-	// TODO(discuss): A nil QC implies a successfull CommitQC or TimeoutQC, which have been omitted intentionally since
+	// TODO(discuss): A nil QC implies a successful CommitQC or TimeoutQC, which have been omitted intentionally since
 	// they are not needed for consensus validity. However, if a QC is specified, it must be valid.
+	quorumCert :=
 	if msg.GetQuorumCertificate() != nil {
 		if err := m.validateQuorumCertificate(msg.GetQuorumCertificate()); err != nil {
 			return err
@@ -246,6 +260,30 @@ func (m *ConsensusModule) validateQuorumCertificate(qc *typesCons.QuorumCertific
 	return nil
 }
 
+// This is a helper function intended to be called by a replica/voter during a view change
+func (m *ConsensusModule) applyBlock(block *typesCons.Block) error {
+	// TODO: Add unit tests to verify this.
+	if unsafe.Sizeof(*block) > uintptr(m.MaxBlockBytes) {
+		return typesCons.ErrInvalidBlockSize(uint64(unsafe.Sizeof(*block)), m.MaxBlockBytes)
+	}
+
+	// TECHDEBT: Retrieve this from persistence
+	lastByzValidators := make([][]byte, 0)
+
+	// Apply all the transactions in the block and get the appHash
+	appHash, err := m.utilityContext.ApplyBlock(int64(m.Height), block.BlockHeader.ProposerAddress, block.Transactions, lastByzValidators)
+	if err != nil {
+		return err
+	}
+
+	// CONSOLIDATE: Terminology of `blockHash`, `appHash` and `stateHash`
+	if block.BlockHeader.Hash != hex.EncodeToString(appHash) {
+		return typesCons.ErrInvalidAppHash(block.BlockHeader.Hash, hex.EncodeToString(appHash))
+	}
+
+	return nil
+}
+
 func qcToHotstuffMessage(qc *typesCons.QuorumCertificate) *typesCons.HotstuffMessage {
 	return &typesCons.HotstuffMessage{
 		Height: qc.Height,
diff --git a/consensus/module.go b/consensus/module.go
index d2e3e1481..7095c7a4f 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -18,7 +18,7 @@ import (
 )
 
 const (
-	DefaultLogPrefix    = "NODE" // Just a default that'll be replaced during consensus operations.
+	DefaultLogPrefix    = "NODE" // TODO(#164): Make implicit when logging is standardized
 	ConsensusModuleName = "consensus"
 )
 
@@ -27,8 +27,7 @@ var _ modules.PacemakerConfig = &typesCons.PacemakerConfig{}
 var _ modules.ConsensusConfig = &typesCons.ConsensusConfig{}
 var _ modules.ConsensusModule = &ConsensusModule{}
 
-// TODO(olshansky): Any reason to make all of these attributes local only (i.e. not exposed outside the struct)?
-// TODO(olshansky): Look for a way to not externalize the `ConsensusModule` struct
+// TODO: Do not export the `ConsensusModule` struct or the fields inside of it.
 type ConsensusModule struct {
 	bus        modules.Bus
 	privateKey cryptoPocket.Ed25519PrivateKey
@@ -38,7 +37,7 @@ type ConsensusModule struct {
 	Height uint64
 	Round  uint64
 	Step   typesCons.HotstuffStep
-	Block  *typesCons.Block // The current block being voted on prior to committing to finality
+	Block  *typesCons.Block // The current block being proposed / voted on; it has not been committed to finality
 
 	HighPrepareQC *typesCons.QuorumCertificate // Highest QC for which replica voted PRECOMMIT
 	LockedQC      *typesCons.QuorumCertificate // Highest QC for which replica voted COMMIT
@@ -46,11 +45,11 @@ type ConsensusModule struct {
 	// Leader Election
 	LeaderId       *typesCons.NodeId
 	NodeId         typesCons.NodeId
-	ValAddrToIdMap typesCons.ValAddrToIdMap // TODO(design): This needs to be updated every time the ValMap is modified
-	IdToValAddrMap typesCons.IdToValAddrMap // TODO(design): This needs to be updated every time the ValMap is modified
+	ValAddrToIdMap typesCons.ValAddrToIdMap // TODO: This needs to be updated every time the ValMap is modified
+	IdToValAddrMap typesCons.IdToValAddrMap // TODO: This needs to be updated every time the ValMap is modified
 
 	// Consensus State
-	appHash      string
+	lastAppHash  string // TODO: Need to make sure this is populated and updated correctly
 	validatorMap typesCons.ValidatorMap
 
 	// Module Dependencies
@@ -58,10 +57,13 @@ type ConsensusModule struct {
 	paceMaker         Pacemaker
 	leaderElectionMod leader_election.LeaderElectionModule
 
-	logPrefix   string                                                  // TODO(design): Remove later when we build a shared/proper/injected logger
-	MessagePool map[typesCons.HotstuffStep][]*typesCons.HotstuffMessage // TODO(design): Move this over to the persistence module or elsewhere?
-	// TODO(andrew): Explain (or remove) why have an explicit `MaxBlockBytes` if we are already storing a reference to `consCfg` above?
-	// TODO(andrew): This needs to be updated every time the utility module changes this value. It can be accessed via the "application specific bus" (mimicking the intermodule interface in ABCI)
+	// DEPRECATE: Remove later when we build a shared/proper/injected logger
+	logPrefix string
+
+	// TECHDEBT: Move this over to use the txIndexer
+	MessagePool map[typesCons.HotstuffStep][]*typesCons.HotstuffMessage
+
+	// CLEANUP: Access this value from the configs
 	MaxBlockBytes uint64
 }
 
@@ -120,7 +122,7 @@ func Create(configPath, genesisPath string, useRandomPK bool) (modules.Consensus
 		ValAddrToIdMap: valIdMap,
 		IdToValAddrMap: idValMap,
 
-		appHash:      "",
+		lastAppHash:  "",
 		validatorMap: valMap,
 
 		utilityContext:    nil,
@@ -216,65 +218,11 @@ func (m *ConsensusModule) SetBus(pocketBus modules.Bus) {
 	m.leaderElectionMod.SetBus(pocketBus)
 }
 
-func (m *ConsensusModule) loadPersistedState() error {
-	persistenceContext, err := m.GetBus().GetPersistenceModule().NewReadContext(-1) // Unknown height
-	if err != nil {
-		return nil
-	}
-	defer persistenceContext.Close()
-
-	latestHeight, err := persistenceContext.GetLatestBlockHeight()
-	if err != nil || latestHeight == 0 {
-		m.nodeLog("TODO: State sync not implement")
-		return nil
-	}
-
-	appHash, err := persistenceContext.GetBlockHash(int64(latestHeight))
-	if err != nil {
-		return fmt.Errorf("error getting block hash for height %d even though it's in the database: %s", latestHeight, err)
-	}
-
-	// TODO: Populate the rest of the state from the persistence module: validator set, quorum cert, last block hash, etc...
-	m.Height = uint64(latestHeight) + 1 // +1 because the height of the consensus module is where it is actively participating in consensus
-	m.appHash = string(appHash)
-
-	m.nodeLog(fmt.Sprintf("Starting node at height %d", latestHeight))
-	return nil
-}
-
-// TODO(discuss): Low priority design: think of a way to make `hotstuff_*` files be a sub-package under consensus.
-// This is currently not possible because functions tied to the `ConsensusModule`
-// struct (implementing the ConsensusModule module), which spans multiple files.
-/*
-TODO(discuss): The reason we do not assign both the leader and the replica handlers
-to the leader (which should also act as a replica when it is a leader) is because it
-can create a weird inconsistent state (e.g. both the replica and leader try to restart
-the Pacemaker timeout). This requires additional "replica-like" logic in the leader
-handler which has both pros and cons:
-	Pros:
-		* The leader can short-circuit and optimize replica related logic
-		* Avoids additional code flowing through the P2P pipeline
-		* Allows for micro-optimizations
-	Cons:
-		* The leader's "replica related logic" requires an additional code path
-		* Code is less "generalizable" and therefore potentially more error prone
-*/
-
-// TODO(olshansky): Should we just make these singletons or embed them directly in the ConsensusModule?
-type HotstuffMessageHandler interface {
-	HandleNewRoundMessage(*ConsensusModule, *typesCons.HotstuffMessage)
-	HandlePrepareMessage(*ConsensusModule, *typesCons.HotstuffMessage)
-	HandlePrecommitMessage(*ConsensusModule, *typesCons.HotstuffMessage)
-	HandleCommitMessage(*ConsensusModule, *typesCons.HotstuffMessage)
-	HandleDecideMessage(*ConsensusModule, *typesCons.HotstuffMessage)
-}
-
 func (m *ConsensusModule) HandleMessage(message *anypb.Any) error {
 	switch message.MessageName() {
 	case HotstuffMessage:
 		var hotstuffMessage typesCons.HotstuffMessage
-		err := anypb.UnmarshalTo(message, &hotstuffMessage, proto.UnmarshalOptions{})
-		if err != nil {
+		if err := anypb.UnmarshalTo(message, &hotstuffMessage, proto.UnmarshalOptions{}); err != nil {
 			return err
 		}
 		m.handleHotstuffMessage(&hotstuffMessage)
@@ -287,36 +235,8 @@ func (m *ConsensusModule) HandleMessage(message *anypb.Any) error {
 	return nil
 }
 
-func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage) {
-	m.nodeLog(typesCons.DebugHandlingHotstuffMessage(msg))
-
-	// Liveness & safety checks
-	if err := m.paceMaker.ValidateMessage(msg); err != nil {
-		// If a replica is not a leader for this round, but has already determined a leader,
-		// and continues to receive NewRound messages, we avoid logging the "message discard"
-		// because it creates unnecessary spam.
-		if !(m.LeaderId != nil && !m.isLeader() && msg.Step == NewRound) {
-			m.nodeLog(typesCons.WarnDiscardHotstuffMessage(msg, err.Error()))
-		}
-		return
-	}
-
-	// Need to execute leader election if there is no leader and we are in a new round.
-	if m.Step == NewRound && m.LeaderId == nil {
-		m.electNextLeader(msg)
-	}
-
-	if m.isReplica() {
-		replicaHandlers[msg.Step](m, msg)
-		return
-	}
-
-	// Note that the leader also acts as a replica, but this logic is implemented in the underlying code.
-	leaderHandlers[msg.Step](m, msg)
-}
-
 func (m *ConsensusModule) AppHash() string {
-	return m.appHash
+	return m.lastAppHash
 }
 
 func (m *ConsensusModule) CurrentHeight() uint64 {
@@ -326,3 +246,29 @@ func (m *ConsensusModule) CurrentHeight() uint64 {
 func (m *ConsensusModule) ValidatorMap() modules.ValidatorMap {
 	return typesCons.ValidatorMapToModulesValidatorMap(m.validatorMap)
 }
+
+// TODO: Populate the entire state from the persistence module: validator set, quorum cert, last block hash, etc...
+func (m *ConsensusModule) loadPersistedState() error {
+	persistenceContext, err := m.GetBus().GetPersistenceModule().NewReadContext(-1) // Unknown height
+	if err != nil {
+		return nil
+	}
+	defer persistenceContext.Close()
+
+	latestHeight, err := persistenceContext.GetLatestBlockHeight()
+	if err != nil || latestHeight == 0 {
+		m.nodeLog("TODO: State sync not implement")
+		return nil
+	}
+
+	appHash, err := persistenceContext.GetBlockHash(int64(latestHeight))
+	if err != nil {
+		return fmt.Errorf("error getting block hash for height %d even though it's in the database: %s", latestHeight, err)
+	}
+
+	m.Height = uint64(latestHeight) + 1 // +1 because the height of the consensus module is where it is actively participating in consensus
+	m.lastAppHash = string(appHash)
+
+	m.nodeLog(fmt.Sprintf("Starting node at height %d", latestHeight))
+	return nil
+}
diff --git a/consensus/types/block.go b/consensus/types/block.go
new file mode 100644
index 000000000..f6091b6b3
--- /dev/null
+++ b/consensus/types/block.go
@@ -0,0 +1,14 @@
+package types
+
+import (
+	"github.com/pokt-network/pocket/shared/codec"
+)
+
+func (b *Block) Bytes() ([]byte, error) {
+	codec := codec.GetCodec()
+	blockProtoBz, err := codec.Marshal(b)
+	if err != nil {
+		return nil, err
+	}
+	return blockProtoBz, nil
+}
diff --git a/consensus/types/errors.go b/consensus/types/errors.go
index e3f4d3987..1556295c4 100644
--- a/consensus/types/errors.go
+++ b/consensus/types/errors.go
@@ -142,7 +142,6 @@ const (
 	prepareBlockError                           = "could not prepare block"
 	commitBlockError                            = "could not commit block"
 	replicaPrepareBlockError                    = "node should not call `prepareBlock` if it is not a leader"
-	leaderErrApplyBlock                         = "node should not call `applyBlock` if it is leader"
 	blockSizeTooLargeError                      = "block size is too large"
 	sendMessageError                            = "error sending message"
 	broadcastMessageError                       = "error broadcasting message"
@@ -177,7 +176,6 @@ var (
 	ErrPrepareBlock                           = errors.New(prepareBlockError)
 	ErrCommitBlock                            = errors.New(commitBlockError)
 	ErrReplicaPrepareBlock                    = errors.New(replicaPrepareBlockError)
-	ErrLeaderApplyBLock                       = errors.New(leaderErrApplyBlock)
 	ErrSendMessage                            = errors.New(sendMessageError)
 	ErrBroadcastMessage                       = errors.New(broadcastMessageError)
 	ErrCreateConsensusMessage                 = errors.New(createConsensusMessageError)
diff --git a/consensus/types/types.go b/consensus/types/types.go
index 36896cfaf..86b9a0624 100644
--- a/consensus/types/types.go
+++ b/consensus/types/types.go
@@ -1,8 +1,10 @@
 package types
 
+// TODO: Split this file into multiple types files.
 import (
-	"github.com/pokt-network/pocket/shared/modules"
 	"sort"
+
+	"github.com/pokt-network/pocket/shared/modules"
 )
 
 type NodeId uint64
diff --git a/utility/block.go b/utility/block.go
index 00618152c..c762b35a7 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -3,7 +3,7 @@ package utility
 import (
 	"math/big"
 
-	typesCons "github.com/pokt-network/pocket/consensus/types" // TODO (andrew) importing consensus and persistence in this file?
+	// TODO (andrew) importing consensus and persistence in this file?
 	typesGenesis "github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 
@@ -61,11 +61,13 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 		// 	return nil, err
 		// }
 	}
+
 	// end block lifecycle phase
 	if err := u.EndBlock(proposerAddress); err != nil {
 		return nil, err
 	}
-	// return the app hash (consensus module will get the validator set directly
+
+	// return the app hash; consensus module will get the validator set directly
 	return u.GetAppHash()
 }
 
@@ -289,14 +291,12 @@ func (u *UtilityContext) SetValidatorMissedBlocks(address []byte, missedBlocks i
 }
 
 func (u *UtilityContext) StoreBlock(blockProtoBytes []byte) error {
-	store := u.Store()
+	// store := u.Store()
 
 	// Store in KV Store
-	if err := store.StoreBlock(blockProtoBytes); err != nil {
-		return err
-	}
-
-
+	// if err := store.StoreBlock(blockProtoBytes); err != nil {
+	// 	return err
+	// }
 
 	return nil
 }

From ed735e105ddad84c8acec7198a6002f330629886 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Fri, 23 Sep 2022 15:49:02 -0700
Subject: [PATCH 011/227] Tests running but not passing

---
 consensus/consensus_tests/config.json  |  2 +-
 consensus/consensus_tests/genesis.json | 28 ++++++-------
 consensus/helpers.go                   |  6 ++-
 consensus/hotstuff_leader.go           | 25 +++++------
 consensus/hotstuff_replica.go          | 20 ++++-----
 consensus/messages.go                  | 57 ++++++++++++++------------
 consensus/module.go                    |  2 +-
 7 files changed, 73 insertions(+), 67 deletions(-)

diff --git a/consensus/consensus_tests/config.json b/consensus/consensus_tests/config.json
index f3cf88b4a..688a66b27 100755
--- a/consensus/consensus_tests/config.json
+++ b/consensus/consensus_tests/config.json
@@ -1,6 +1,6 @@
 {
     "consensus": {
-        "private_key": "70c42b40d1194fcd29a114b0c09fb7a9da32d1bf66039025cf75252cb3e04931b828c891955f35604500a71b9111bddb7bf9481a15250e9508547ea95057f2e9",
+        "private_key": "e8561cc9a8cb6396ceeae0747e8365029fb7772f40ee7e82df906fbd6b329a5a8ae7e70016d48453e3fe173d1457a7426c0479623c6ca5ba042d5303ebb0814b",
         "max_mempool_bytes": 500000000,
         "pacemaker_config": {
             "timeout_msec": 5000
diff --git a/consensus/consensus_tests/genesis.json b/consensus/consensus_tests/genesis.json
index 8650b3b52..88156506b 100755
--- a/consensus/consensus_tests/genesis.json
+++ b/consensus/consensus_tests/genesis.json
@@ -1,54 +1,54 @@
 {
     "consensus_genesis_state": {
         "genesis_time": {
-            "seconds": 1663965677,
-            "nanos": 641809000
+            "seconds": 1663973128,
+            "nanos": 273119000
         },
         "chain_id": "testnet",
         "max_block_bytes": 4000000,
         "validators": [
             {
-                "address": "c85045886996fe295a4eaa24a7f07ea74032a0bc",
-                "public_key": "c9356e26cb2987665dc76c2836a1b614646753ab92a517dacecb1a0d472a44fb",
+                "address": "27ce0b388a1a3b2c663f755d78206e96eea4362a",
+                "public_key": "bb6329890486544b0101e23f26fd5a74f0355843d6b63e48ca95954c6fea6ee2",
                 "chains": null,
                 "generic_param": "node1.consensus:8080",
                 "staked_amount": "1000000000000",
                 "paused_height": -1,
                 "unstaking_height": -1,
-                "output": "c85045886996fe295a4eaa24a7f07ea74032a0bc",
+                "output": "27ce0b388a1a3b2c663f755d78206e96eea4362a",
                 "actor_type": 3
             },
             {
-                "address": "e0db8408cea5ed6520e1adc5dc4d1d17239df172",
-                "public_key": "b828c891955f35604500a71b9111bddb7bf9481a15250e9508547ea95057f2e9",
+                "address": "210658c6938dd7b02fad44774c06b8d33067c283",
+                "public_key": "26b785bddc4f48911dcb7c99ad7657f4cce39f3af659ef17ccec26f44aeb4dee",
                 "chains": null,
                 "generic_param": "node2.consensus:8080",
                 "staked_amount": "1000000000000",
                 "paused_height": -1,
                 "unstaking_height": -1,
-                "output": "e0db8408cea5ed6520e1adc5dc4d1d17239df172",
+                "output": "210658c6938dd7b02fad44774c06b8d33067c283",
                 "actor_type": 3
             },
             {
-                "address": "4a1eb7a5787f4c6e556c3b9a3cbfd31a75a4eef4",
-                "public_key": "98762a7038ac4df608200a790ccb5b679d4f720d51a7acf115c5be4a6d0222c0",
+                "address": "9c17a6256e9fddf888608d7573f403f35b57a5ce",
+                "public_key": "92e1f441b5002f110e3321ed122ac3e2dba1a800a7477ffcae0dfb5ccfcde95c",
                 "chains": null,
                 "generic_param": "node3.consensus:8080",
                 "staked_amount": "1000000000000",
                 "paused_height": -1,
                 "unstaking_height": -1,
-                "output": "4a1eb7a5787f4c6e556c3b9a3cbfd31a75a4eef4",
+                "output": "9c17a6256e9fddf888608d7573f403f35b57a5ce",
                 "actor_type": 3
             },
             {
-                "address": "3b7500e1509f05533c93c8f6d80af06419901b22",
-                "public_key": "052447ca3b1c8eabb8f5d66d0c34f9ddf466bd03718eb1504ab5a24421a1e5d8",
+                "address": "e4aa8d7cebb13f1832fe91695818ce09fb1c444b",
+                "public_key": "8ae7e70016d48453e3fe173d1457a7426c0479623c6ca5ba042d5303ebb0814b",
                 "chains": null,
                 "generic_param": "node4.consensus:8080",
                 "staked_amount": "1000000000000",
                 "paused_height": -1,
                 "unstaking_height": -1,
-                "output": "3b7500e1509f05533c93c8f6d80af06419901b22",
+                "output": "e4aa8d7cebb13f1832fe91695818ce09fb1c444b",
                 "actor_type": 3
             }
         ]
diff --git a/consensus/helpers.go b/consensus/helpers.go
index 233912ef1..dd90c9b66 100644
--- a/consensus/helpers.go
+++ b/consensus/helpers.go
@@ -97,13 +97,13 @@ func getThresholdSignature(
 	return thresholdSig, nil
 }
 
-func isSignatureValid(m *typesCons.HotstuffMessage, pubKeyString string, signature []byte) bool {
+func isSignatureValid(msg *typesCons.HotstuffMessage, pubKeyString string, signature []byte) bool {
 	pubKey, err := cryptoPocket.NewPublicKey(pubKeyString)
 	if err != nil {
 		log.Println("[WARN] Error getting PublicKey from bytes:", err)
 		return false
 	}
-	bytesToVerify, err := getSignableBytes(m)
+	bytesToVerify, err := getSignableBytes(msg)
 	if err != nil {
 		log.Println("[WARN] Error getting bytes to verify:", err)
 		return false
@@ -211,10 +211,12 @@ func (m *ConsensusModule) electNextLeader(message *typesCons.HotstuffMessage) {
 
 /*** General Infrastructure Helpers ***/
 
+// TODO(#164): Remove this once we have a proper logging system.
 func (m *ConsensusModule) nodeLog(s string) {
 	log.Printf("[%s][%d] %s\n", m.logPrefix, m.NodeId, s)
 }
 
+// TODO(#164): Remove this once we have a proper logging system.
 func (m *ConsensusModule) nodeLogError(s string, err error) {
 	log.Printf("[ERROR][%s][%d] %s: %v\n", m.logPrefix, m.NodeId, s, err)
 }
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index a22ece366..8b157e21b 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -71,7 +71,7 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusM
 	m.Step = Prepare
 	m.MessagePool[NewRound] = nil
 
-	prepareProposeMessage, err := CreateProposeMessage(m, Prepare, highPrepareQC)
+	prepareProposeMessage, err := CreateProposeMessage(m.Height, m.Round, Prepare, m.Block, highPrepareQC)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateProposeMessage(Prepare).Error(), err)
 		m.paceMaker.InterruptRound()
@@ -80,7 +80,7 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusM
 	m.broadcastToNodes(prepareProposeMessage)
 
 	// Leader also acts like a replica
-	prepareVoteMessage, err := CreateVoteMessage(m, Prepare, m.Block)
+	prepareVoteMessage, err := CreateVoteMessage(m.Height, m.Round, Prepare, m.Block, m.privateKey)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(Prepare).Error(), err)
 		return
@@ -116,7 +116,7 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrepareMessage(m *ConsensusMo
 	m.HighPrepareQC = prepareQC
 	m.MessagePool[Prepare] = nil
 
-	precommitProposeMessages, err := CreateProposeMessage(m, PreCommit, prepareQC)
+	precommitProposeMessages, err := CreateProposeMessage(m.Height, m.Round, PreCommit, m.Block, prepareQC)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateProposeMessage(PreCommit).Error(), err)
 		m.paceMaker.InterruptRound()
@@ -125,7 +125,7 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrepareMessage(m *ConsensusMo
 	m.broadcastToNodes(precommitProposeMessages)
 
 	// Leader also acts like a replica
-	precommitVoteMessage, err := CreateVoteMessage(m, PreCommit, m.Block)
+	precommitVoteMessage, err := CreateVoteMessage(m.Height, m.Round, PreCommit, m.Block, m.privateKey)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(PreCommit).Error(), err)
 		return
@@ -160,7 +160,7 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrecommitMessage(m *Consensus
 	m.LockedQC = preCommitQC
 	m.MessagePool[PreCommit] = nil
 
-	commitProposeMessage, err := CreateProposeMessage(m, Commit, preCommitQC)
+	commitProposeMessage, err := CreateProposeMessage(m.Height, m.Round, Commit, m.Block, preCommitQC)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateProposeMessage(Commit).Error(), err)
 		m.paceMaker.InterruptRound()
@@ -169,7 +169,7 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrecommitMessage(m *Consensus
 	m.broadcastToNodes(commitProposeMessage)
 
 	// Leader also acts like a replica
-	commitVoteMessage, err := CreateVoteMessage(m, Commit, m.Block)
+	commitVoteMessage, err := CreateVoteMessage(m.Height, m.Round, Commit, m.Block, m.privateKey)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(Commit).Error(), err)
 		return // TODO(olshansky): Should we interrupt the round here?
@@ -203,7 +203,7 @@ func (handler *HotstuffLeaderMessageHandler) HandleCommitMessage(m *ConsensusMod
 	m.Step = Decide
 	m.MessagePool[Commit] = nil
 
-	decideProposeMessage, err := CreateProposeMessage(m, Decide, commitQC)
+	decideProposeMessage, err := CreateProposeMessage(m.Height, m.Round, Decide, m.Block, commitQC)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateProposeMessage(Decide).Error(), err)
 		m.paceMaker.InterruptRound()
@@ -270,12 +270,12 @@ func (handler *HotstuffLeaderMessageHandler) validateBasic(m *ConsensusModule, m
 }
 
 func (m *ConsensusModule) validatePartialSignature(msg *typesCons.HotstuffMessage) error {
-	if msg.Step == NewRound {
+	if msg.GetStep() == NewRound {
 		m.nodeLog(typesCons.ErrUnnecessaryPartialSigForNewRound.Error())
 		return nil
 	}
 
-	if msg.Type == Propose {
+	if msg.GetType() == Propose {
 		m.nodeLog(typesCons.ErrUnnecessaryPartialSigForLeaderProposal.Error())
 		return nil
 	}
@@ -283,18 +283,19 @@ func (m *ConsensusModule) validatePartialSignature(msg *typesCons.HotstuffMessag
 	if msg.GetPartialSignature() == nil {
 		return typesCons.ErrNilPartialSig
 	}
+	partialSig := msg.GetPartialSignature()
 
-	if msg.GetPartialSignature().Signature == nil || len(msg.GetPartialSignature().Address) == 0 {
+	if partialSig.Signature == nil || len(partialSig.GetAddress()) == 0 {
 		return typesCons.ErrNilPartialSigOrSourceNotSpecified
 	}
 
-	address := msg.GetPartialSignature().Address
+	address := partialSig.GetAddress()
 	validator, ok := m.validatorMap[address]
 	if !ok {
 		return typesCons.ErrMissingValidator(address, m.ValAddrToIdMap[address])
 	}
 	pubKey := validator.GetPublicKey()
-	if isSignatureValid(msg, pubKey, msg.GetPartialSignature().Signature) {
+	if isSignatureValid(msg, pubKey, partialSig.GetSignature()) {
 		return nil
 	}
 
diff --git a/consensus/hotstuff_replica.go b/consensus/hotstuff_replica.go
index 1e814ed41..cb333af70 100644
--- a/consensus/hotstuff_replica.go
+++ b/consensus/hotstuff_replica.go
@@ -69,7 +69,7 @@ func (handler *HotstuffReplicaMessageHandler) HandlePrepareMessage(m *ConsensusM
 
 	m.Step = PreCommit
 
-	prepareVoteMessage, err := CreateVoteMessage(m, Prepare, block)
+	prepareVoteMessage, err := CreateVoteMessage(m.Height, m.Round, Prepare, m.Block, m.privateKey)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(Prepare).Error(), err)
 		return
@@ -98,7 +98,7 @@ func (handler *HotstuffReplicaMessageHandler) HandlePrecommitMessage(m *Consensu
 	m.Step = Commit
 	m.HighPrepareQC = quorumCert // INVESTIGATE: Why are we never using this for validation?
 
-	preCommitVoteMessage, err := CreateVoteMessage(m, PreCommit, msg.Block)
+	preCommitVoteMessage, err := CreateVoteMessage(m.Height, m.Round, PreCommit, m.Block, m.privateKey)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(PreCommit).Error(), err)
 		return
@@ -127,7 +127,7 @@ func (handler *HotstuffReplicaMessageHandler) HandleCommitMessage(m *ConsensusMo
 	m.Step = Decide
 	m.LockedQC = quorumCert // DISCUSS: How does the replica recover if it's locked? Replica `formally` agrees on the QC while the rest of the network `verbally` agrees on the QC.
 
-	commitVoteMessage, err := CreateVoteMessage(m, Commit, msg.Block)
+	commitVoteMessage, err := CreateVoteMessage(m.Height, m.Round, Commit, m.Block, m.privateKey)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(Commit).Error(), err)
 		return
@@ -153,7 +153,7 @@ func (handler *HotstuffReplicaMessageHandler) HandleDecideMessage(m *ConsensusMo
 		return
 	}
 
-	if err := m.commitBlock(msg.Block); err != nil {
+	if err := m.commitBlock(m.Block); err != nil {
 		m.nodeLogError("Could not commit block", err)
 		m.paceMaker.InterruptRound()
 		return
@@ -186,21 +186,21 @@ func (m *ConsensusModule) validateProposal(msg *typesCons.HotstuffMessage) error
 		return typesCons.ErrProposalNotValidInPrepare
 	}
 
-	if err := m.validateBlock(msg.Block); err != nil {
+	if err := m.validateBlock(msg.GetBlock()); err != nil {
 		return err
 	}
 
 	// TODO(discuss): A nil QC implies a successful CommitQC or TimeoutQC, which have been omitted intentionally since
 	// they are not needed for consensus validity. However, if a QC is specified, it must be valid.
-	quorumCert :=
-	if msg.GetQuorumCertificate() != nil {
-		if err := m.validateQuorumCertificate(msg.GetQuorumCertificate()); err != nil {
+	quorumCert := msg.GetQuorumCertificate()
+	if quorumCert != nil {
+		if err := m.validateQuorumCertificate(quorumCert); err != nil {
 			return err
 		}
 	}
 
 	lockedQC := m.LockedQC
-	justifyQC := msg.GetQuorumCertificate()
+	justifyQC := quorumCert
 
 	// Safety: not locked
 	if lockedQC == nil {
@@ -210,7 +210,7 @@ func (m *ConsensusModule) validateProposal(msg *typesCons.HotstuffMessage) error
 
 	// Safety: check the hash of the locked QC
 	// TODO(olshansky): Extend implementation to adopt `ExtendsFrom` as described in the Hotstuff whitepaper.
-	if protoHash(lockedQC.Block) == protoHash(justifyQC.Block) { // && lockedQC.Block.ExtendsFrom(justifyQC.Block)
+	if protoHash(lockedQC.GetBlock()) == protoHash(justifyQC.Block) { // && lockedQC.Block.ExtendsFrom(justifyQC.Block)
 		m.nodeLog(typesCons.ProposalBlockExtends)
 		return nil
 	}
diff --git a/consensus/messages.go b/consensus/messages.go
index 4fd09cea5..9a577e996 100644
--- a/consensus/messages.go
+++ b/consensus/messages.go
@@ -9,30 +9,29 @@ import (
 )
 
 func CreateProposeMessage(
-	m *ConsensusModule,
-	step typesCons.HotstuffStep, // step can be taken from `m` but is specified explicitly via interface to avoid ambiguity
+	height uint64,
+	round uint64,
+	step typesCons.HotstuffStep,
+	block *typesCons.Block,
 	qc *typesCons.QuorumCertificate,
 ) (*typesCons.HotstuffMessage, error) {
-	if m.Block == nil {
-		return nil, typesCons.ErrNilBlockProposal
-	}
-
 	msg := &typesCons.HotstuffMessage{
 		Type:          Propose,
-		Height:        m.Height,
+		Height:        height,
 		Step:          step,
-		Round:         m.Round,
-		Block:         m.Block,
+		Round:         round,
+		Block:         block,
 		Justification: nil, // QC is set below if it is non-nil
 	}
 
-	// TODO(olshansky): Add unit tests for this
+	// TODO: Add unit tests for this
 	if qc == nil && step != Prepare {
 		return nil, typesCons.ErrNilQCProposal
 	}
 
-	// TODO(olshansky): Add unit tests for this
-	if qc != nil { // QC may optionally be nil for NEWROUND steps when everything is progressing smoothly
+	// TODO: Add unit tests for this
+	// QC may be nil during NEWROUND if following happy hotstuff path
+	if qc != nil {
 		msg.Justification = &typesCons.HotstuffMessage_QuorumCertificate{
 			QuorumCertificate: qc,
 		}
@@ -42,9 +41,11 @@ func CreateProposeMessage(
 }
 
 func CreateVoteMessage(
-	m *ConsensusModule,
-	step typesCons.HotstuffStep, // step can be taken from `m` but is specified explicitly via interface to avoid ambiguity
+	height uint64,
+	round uint64,
+	step typesCons.HotstuffStep,
 	block *typesCons.Block,
+	privKey crypto.PrivateKey, // used to sign the vote
 ) (*typesCons.HotstuffMessage, error) {
 	if block == nil {
 		return nil, typesCons.ErrNilBlockVote
@@ -52,44 +53,46 @@ func CreateVoteMessage(
 
 	msg := &typesCons.HotstuffMessage{
 		Type:          Vote,
-		Height:        m.Height,
+		Height:        height,
 		Step:          step,
-		Round:         m.Round,
+		Round:         round,
 		Block:         block,
 		Justification: nil, // signature is computed below
 	}
 
 	msg.Justification = &typesCons.HotstuffMessage_PartialSignature{
 		PartialSignature: &typesCons.PartialSignature{
-			Signature: getMessageSignature(msg, m.privateKey),
-			Address:   m.privateKey.PublicKey().Address().String(),
+			Signature: getMessageSignature(msg, privKey),
+			Address:   privKey.PublicKey().Address().String(),
 		},
 	}
 
 	return msg, nil
 }
 
-// Returns a "partial" signature of the hotstuff message from one of the validators
-func getMessageSignature(m *typesCons.HotstuffMessage, privKey crypto.PrivateKey) []byte {
-	bytesToSign, err := getSignableBytes(m)
+// Returns "partial" signature of the hotstuff message from one of the validators
+func getMessageSignature(msg *typesCons.HotstuffMessage, privKey crypto.PrivateKey) []byte {
+	bytesToSign, err := getSignableBytes(msg)
 	if err != nil {
 		return nil
 	}
+
 	signature, err := privKey.Sign(bytesToSign)
 	if err != nil {
 		log.Fatalf("Error signing message: %v", err)
 		return nil
 	}
+
 	return signature
 }
 
-// Signature should only be over a subset of the fields in a HotstuffMessage
-func getSignableBytes(m *typesCons.HotstuffMessage) ([]byte, error) {
+// Signature only over subset of fields in HotstuffMessage
+func getSignableBytes(msg *typesCons.HotstuffMessage) ([]byte, error) {
 	msgToSign := &typesCons.HotstuffMessage{
-		Height: m.Height,
-		Step:   m.Step,
-		Round:  m.Round,
-		Block:  m.Block,
+		Height: msg.Height,
+		Step:   msg.Step,
+		Round:  msg.Round,
+		Block:  msg.Block,
 	}
 	return proto.Marshal(msgToSign)
 }
diff --git a/consensus/module.go b/consensus/module.go
index 7095c7a4f..42c7354ae 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -257,7 +257,7 @@ func (m *ConsensusModule) loadPersistedState() error {
 
 	latestHeight, err := persistenceContext.GetLatestBlockHeight()
 	if err != nil || latestHeight == 0 {
-		m.nodeLog("TODO: State sync not implement")
+		m.nodeLog("TODO: State sync not implemented yet")
 		return nil
 	}
 

From e1016e6b01d0e3ea41ae742de2269d04b8be8b6b Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Fri, 23 Sep 2022 15:52:15 -0700
Subject: [PATCH 012/227] Using proper getters when accessing hotstuff

---
 consensus/helpers.go          |  2 +-
 consensus/hotstuff_handler.go |  7 ++++---
 consensus/hotstuff_leader.go  |  3 ++-
 consensus/messages.go         |  8 ++++----
 consensus/types/errors.go     | 14 +++++++-------
 5 files changed, 18 insertions(+), 16 deletions(-)

diff --git a/consensus/helpers.go b/consensus/helpers.go
index dd90c9b66..34c36e054 100644
--- a/consensus/helpers.go
+++ b/consensus/helpers.go
@@ -46,7 +46,7 @@ func (m *ConsensusModule) getQuorumCertificate(height uint64, step typesCons.Hot
 			continue
 		}
 		// TODO(olshansky): Add tests for this
-		if msg.Height != height || msg.Step != step || msg.Round != round {
+		if msg.GetHeight() != height || msg.GetStep() != step || msg.GetRound() != round {
 			m.nodeLog(typesCons.WarnUnexpectedMessageInPool(msg, height, step, round))
 			continue
 		}
diff --git a/consensus/hotstuff_handler.go b/consensus/hotstuff_handler.go
index a2127cc61..9b5ae3287 100644
--- a/consensus/hotstuff_handler.go
+++ b/consensus/hotstuff_handler.go
@@ -31,12 +31,13 @@ type HotstuffMessageHandler interface {
 func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage) {
 	m.nodeLog(typesCons.DebugHandlingHotstuffMessage(msg))
 
+	step := msg.GetStep()
 	// Liveness & safety checks
 	if err := m.paceMaker.ValidateMessage(msg); err != nil {
 		// If a replica is not a leader for this round, but has already determined a leader,
 		// and continues to receive NewRound messages, we avoid logging the "message discard"
 		// because it creates unnecessary spam.
-		if !(m.LeaderId != nil && !m.isLeader() && msg.Step == NewRound) {
+		if !(m.LeaderId != nil && !m.isLeader() && step == NewRound) {
 			m.nodeLog(typesCons.WarnDiscardHotstuffMessage(msg, err.Error()))
 		}
 		return
@@ -48,10 +49,10 @@ func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage)
 	}
 
 	if m.isReplica() {
-		replicaHandlers[msg.Step](m, msg)
+		replicaHandlers[step](m, msg)
 		return
 	}
 
 	// Note that the leader also acts as a replica, but this logic is implemented in the underlying code.
-	leaderHandlers[msg.Step](m, msg)
+	leaderHandlers[step](m, msg)
 }
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 8b157e21b..144da8e07 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -313,7 +313,8 @@ func (m *ConsensusModule) aggregateMessage(msg *typesCons.HotstuffMessage) {
 	}
 
 	// Only the leader needs to aggregate consensus related messages.
-	m.MessagePool[msg.Step] = append(m.MessagePool[msg.Step], msg)
+	step := msg.GetStep()
+	m.MessagePool[step] = append(m.MessagePool[step], msg)
 }
 
 // This is a helper function intended to be called by a leader/validator during a view change
diff --git a/consensus/messages.go b/consensus/messages.go
index 9a577e996..8020ec068 100644
--- a/consensus/messages.go
+++ b/consensus/messages.go
@@ -89,10 +89,10 @@ func getMessageSignature(msg *typesCons.HotstuffMessage, privKey crypto.PrivateK
 // Signature only over subset of fields in HotstuffMessage
 func getSignableBytes(msg *typesCons.HotstuffMessage) ([]byte, error) {
 	msgToSign := &typesCons.HotstuffMessage{
-		Height: msg.Height,
-		Step:   msg.Step,
-		Round:  msg.Round,
-		Block:  msg.Block,
+		Height: msg.GetHeight(),
+		Step:   msg.GetStep(),
+		Round:  msg.GetRound(),
+		Block:  msg.GetBlock(),
 	}
 	return proto.Marshal(msgToSign)
 }
diff --git a/consensus/types/errors.go b/consensus/types/errors.go
index 1556295c4..d90d85151 100644
--- a/consensus/types/errors.go
+++ b/consensus/types/errors.go
@@ -71,11 +71,11 @@ func ElectedSelfAsNewLeader(address string, nodeId NodeId, height, round uint64)
 }
 
 func SendingMessage(msg *HotstuffMessage, nodeId NodeId) string {
-	return fmt.Sprintf("Sending %s message to %d", StepToString[msg.Step], nodeId)
+	return fmt.Sprintf("Sending %s message to %d", StepToString[msg.GetStep()], nodeId)
 }
 
 func BroadcastingMessage(msg *HotstuffMessage) string {
-	return fmt.Sprintf("Broadcasting message for %s step", StepToString[msg.Step])
+	return fmt.Sprintf("Broadcasting message for %s step", StepToString[msg.GetStep()])
 }
 
 func WarnInvalidPartialSigInQC(address string, nodeId NodeId) string {
@@ -83,7 +83,7 @@ func WarnInvalidPartialSigInQC(address string, nodeId NodeId) string {
 }
 
 func WarnMissingPartialSig(msg *HotstuffMessage) string {
-	return fmt.Sprintf("[WARN] No partial signature found for step %s which should not happen...", StepToString[msg.Step])
+	return fmt.Sprintf("[WARN] No partial signature found for step %s which should not happen...", StepToString[msg.GetStep()])
 }
 
 func WarnDiscardHotstuffMessage(_ *HotstuffMessage, reason string) string {
@@ -95,7 +95,7 @@ func WarnUnexpectedMessageInPool(_ *HotstuffMessage, height uint64, step Hotstuf
 }
 
 func WarnIncompletePartialSig(ps *PartialSignature, msg *HotstuffMessage) string {
-	return fmt.Sprintf("[WARN] Partial signature is incomplete for step %s which should not happen...", StepToString[msg.Step])
+	return fmt.Sprintf("[WARN] Partial signature is incomplete for step %s which should not happen...", StepToString[msg.GetStep()])
 }
 
 func DebugTogglePacemakerManualMode(mode string) string {
@@ -108,7 +108,7 @@ func DebugNodeState(state ConsensusNodeState) string {
 
 func DebugHandlingHotstuffMessage(msg *HotstuffMessage) string {
 	// TODO(olshansky): Add source and destination NodeId of message here
-	return fmt.Sprintf("[DEBUG] Handling message w/ Height: %d; Type: %s; Round: %d.", msg.Height, StepToString[msg.Step], msg.Round)
+	return fmt.Sprintf("[DEBUG] Handling message w/ Height: %d; Type: %s; Round: %d.", msg.Height, StepToString[msg.GetStep()], msg.Round)
 }
 
 // Errors
@@ -201,7 +201,7 @@ func ErrMissingValidator(address string, nodeId NodeId) error {
 
 func ErrValidatingPartialSig(senderAddr string, senderNodeId NodeId, msg *HotstuffMessage, pubKey string) error {
 	return fmt.Errorf("%s: Sender: %s (%d); Height: %d; Step: %s; Round: %d; SigHash: %s; BlockHash: %s; PubKey: %s",
-		invalidPartialSignatureError, senderAddr, senderNodeId, msg.Height, StepToString[msg.Step], msg.Round, string(msg.GetPartialSignature().Signature), protoHash(msg.Block), pubKey)
+		invalidPartialSignatureError, senderAddr, senderNodeId, msg.Height, StepToString[msg.GetStep()], msg.Round, string(msg.GetPartialSignature().Signature), protoHash(msg.Block), pubKey)
 }
 
 func ErrPacemakerUnexpectedMessageHeight(err error, heightCurrent, heightMessage uint64) error {
@@ -209,7 +209,7 @@ func ErrPacemakerUnexpectedMessageHeight(err error, heightCurrent, heightMessage
 }
 
 func ErrPacemakerUnexpectedMessageStepRound(err error, step HotstuffStep, round uint64, msg *HotstuffMessage) error {
-	return fmt.Errorf("%s: Current (step, round): (%s, %d); Message (step, round): (%s, %d)", err, StepToString[step], round, StepToString[msg.Step], msg.Round)
+	return fmt.Errorf("%s: Current (step, round): (%s, %d); Message (step, round): (%s, %d)", err, StepToString[step], round, StepToString[msg.GetStep()], msg.Round)
 }
 
 func ErrUnknownConsensusMessageType(msg interface{}) error {

From a58926d09b9629c275b93353fc2d0c387ebaa0f1 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Fri, 23 Sep 2022 17:22:22 -0700
Subject: [PATCH 013/227] make develop_test passed

---
 consensus/block.go                          | 23 ++++---
 consensus/consensus_tests/config.json       |  9 ---
 consensus/consensus_tests/genesis.json      | 56 -----------------
 consensus/consensus_tests/pacemaker_test.go |  7 +++
 consensus/debugging.go                      |  3 +-
 consensus/helpers.go                        |  6 +-
 consensus/hotstuff_handler.go               | 35 ++++-------
 consensus/hotstuff_leader.go                | 16 ++---
 consensus/hotstuff_replica.go               | 70 +++++++++++----------
 consensus/messages.go                       |  6 +-
 consensus/module.go                         |  8 ++-
 11 files changed, 93 insertions(+), 146 deletions(-)
 delete mode 100755 consensus/consensus_tests/config.json
 delete mode 100755 consensus/consensus_tests/genesis.json

diff --git a/consensus/block.go b/consensus/block.go
index 4ff0a9307..ce123c1d7 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -1,14 +1,21 @@
 package consensus
 
 import (
+	"unsafe"
+
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
 
-// TODO(olshansky): Sync with Andrew on the type of validation we need here.
+// TODO: Add additional basic block metadata validation w/ unit tests
 func (m *ConsensusModule) validateBlock(block *typesCons.Block) error {
 	if block == nil {
 		return typesCons.ErrNilBlock
 	}
+
+	if unsafe.Sizeof(*block) > uintptr(m.MaxBlockBytes) {
+		return typesCons.ErrInvalidBlockSize(uint64(unsafe.Sizeof(*block)), m.MaxBlockBytes)
+	}
+
 	return nil
 }
 
@@ -17,10 +24,10 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 	// This is a catch-all to release the previous utility context if it wasn't cleaned up
 	// in the proper lifecycle (e.g. catch up, error, network partition, etc...). Ideally, this
 	// should not be called.
-	if m.utilityContext != nil {
+	if m.UtilityContext != nil {
 		m.nodeLog(typesCons.NilUtilityContextWarning)
-		m.utilityContext.ReleaseContext()
-		m.utilityContext = nil
+		m.UtilityContext.ReleaseContext()
+		m.UtilityContext = nil
 	}
 
 	utilityContext, err := m.GetBus().GetUtilityModule().NewContext(int64(m.Height))
@@ -28,7 +35,7 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 		return err
 	}
 
-	m.utilityContext = utilityContext
+	m.UtilityContext = utilityContext
 	return nil
 }
 
@@ -43,12 +50,12 @@ func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 	// }
 
 	// Commit and release the context
-	if err := m.utilityContext.CommitPersistenceContext(); err != nil {
+	if err := m.UtilityContext.CommitPersistenceContext(); err != nil {
 		return err
 	}
 
-	m.utilityContext.ReleaseContext()
-	m.utilityContext = nil
+	m.UtilityContext.ReleaseContext()
+	m.UtilityContext = nil
 
 	m.lastAppHash = block.BlockHeader.Hash
 
diff --git a/consensus/consensus_tests/config.json b/consensus/consensus_tests/config.json
deleted file mode 100755
index 688a66b27..000000000
--- a/consensus/consensus_tests/config.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-    "consensus": {
-        "private_key": "e8561cc9a8cb6396ceeae0747e8365029fb7772f40ee7e82df906fbd6b329a5a8ae7e70016d48453e3fe173d1457a7426c0479623c6ca5ba042d5303ebb0814b",
-        "max_mempool_bytes": 500000000,
-        "pacemaker_config": {
-            "timeout_msec": 5000
-        }
-    }
-}
\ No newline at end of file
diff --git a/consensus/consensus_tests/genesis.json b/consensus/consensus_tests/genesis.json
deleted file mode 100755
index 88156506b..000000000
--- a/consensus/consensus_tests/genesis.json
+++ /dev/null
@@ -1,56 +0,0 @@
-{
-    "consensus_genesis_state": {
-        "genesis_time": {
-            "seconds": 1663973128,
-            "nanos": 273119000
-        },
-        "chain_id": "testnet",
-        "max_block_bytes": 4000000,
-        "validators": [
-            {
-                "address": "27ce0b388a1a3b2c663f755d78206e96eea4362a",
-                "public_key": "bb6329890486544b0101e23f26fd5a74f0355843d6b63e48ca95954c6fea6ee2",
-                "chains": null,
-                "generic_param": "node1.consensus:8080",
-                "staked_amount": "1000000000000",
-                "paused_height": -1,
-                "unstaking_height": -1,
-                "output": "27ce0b388a1a3b2c663f755d78206e96eea4362a",
-                "actor_type": 3
-            },
-            {
-                "address": "210658c6938dd7b02fad44774c06b8d33067c283",
-                "public_key": "26b785bddc4f48911dcb7c99ad7657f4cce39f3af659ef17ccec26f44aeb4dee",
-                "chains": null,
-                "generic_param": "node2.consensus:8080",
-                "staked_amount": "1000000000000",
-                "paused_height": -1,
-                "unstaking_height": -1,
-                "output": "210658c6938dd7b02fad44774c06b8d33067c283",
-                "actor_type": 3
-            },
-            {
-                "address": "9c17a6256e9fddf888608d7573f403f35b57a5ce",
-                "public_key": "92e1f441b5002f110e3321ed122ac3e2dba1a800a7477ffcae0dfb5ccfcde95c",
-                "chains": null,
-                "generic_param": "node3.consensus:8080",
-                "staked_amount": "1000000000000",
-                "paused_height": -1,
-                "unstaking_height": -1,
-                "output": "9c17a6256e9fddf888608d7573f403f35b57a5ce",
-                "actor_type": 3
-            },
-            {
-                "address": "e4aa8d7cebb13f1832fe91695818ce09fb1c444b",
-                "public_key": "8ae7e70016d48453e3fe173d1457a7426c0479623c6ca5ba042d5303ebb0814b",
-                "chains": null,
-                "generic_param": "node4.consensus:8080",
-                "staked_amount": "1000000000000",
-                "paused_height": -1,
-                "unstaking_height": -1,
-                "output": "e4aa8d7cebb13f1832fe91695818ce09fb1c444b",
-                "actor_type": 3
-            }
-        ]
-    }
-}
\ No newline at end of file
diff --git a/consensus/consensus_tests/pacemaker_test.go b/consensus/consensus_tests/pacemaker_test.go
index 25553aa01..fb2d151ac 100644
--- a/consensus/consensus_tests/pacemaker_test.go
+++ b/consensus/consensus_tests/pacemaker_test.go
@@ -2,6 +2,7 @@ package consensus_tests
 
 import (
 	"encoding/hex"
+	"fmt"
 	"log"
 	"reflect"
 	"testing"
@@ -146,10 +147,16 @@ func TestPacemakerCatchupSameStepDifferentRounds(t *testing.T) {
 
 	// Set all nodes to the same STEP and HEIGHT BUT different ROUNDS
 	for _, pocketNode := range pocketNodes {
+		// utilityContext is only set on new rounds, which is skipped in this test
+		utilityContext, err := pocketNode.GetBus().GetUtilityModule().NewContext(int64(testHeight))
+		require.NoError(t, err)
+		fmt.Println("OLSH", utilityContext)
+
 		consensusModImpl := GetConsensusModImplementation(pocketNode)
 		consensusModImpl.FieldByName("Height").SetUint(testHeight)
 		consensusModImpl.FieldByName("Step").SetInt(testStep)
 		consensusModImpl.FieldByName("LeaderId").Set(reflect.Zero(reflect.TypeOf(&leaderId))) // This is re-elected during paceMaker catchup
+		consensusModImpl.FieldByName("UtilityContext").Set(reflect.ValueOf(utilityContext))
 	}
 
 	// Set the leader to be in the highest round.
diff --git a/consensus/debugging.go b/consensus/debugging.go
index 5e111095e..0419575ba 100644
--- a/consensus/debugging.go
+++ b/consensus/debugging.go
@@ -1,10 +1,11 @@
 package consensus
 
 import (
-	"github.com/pokt-network/pocket/shared/debug"
 	"log"
 	"time"
 
+	"github.com/pokt-network/pocket/shared/debug"
+
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
 
diff --git a/consensus/helpers.go b/consensus/helpers.go
index 34c36e054..63270826f 100644
--- a/consensus/helpers.go
+++ b/consensus/helpers.go
@@ -190,12 +190,12 @@ func (m *ConsensusModule) clearLeader() {
 	m.LeaderId = nil
 }
 
-func (m *ConsensusModule) electNextLeader(message *typesCons.HotstuffMessage) {
+func (m *ConsensusModule) electNextLeader(message *typesCons.HotstuffMessage) error {
 	leaderId, err := m.leaderElectionMod.ElectNextLeader(message)
 	if err != nil || leaderId == 0 {
 		m.nodeLogError(typesCons.ErrLeaderElection(message).Error(), err)
 		m.clearLeader()
-		return
+		return err
 	}
 
 	m.LeaderId = &leaderId
@@ -207,6 +207,8 @@ func (m *ConsensusModule) electNextLeader(message *typesCons.HotstuffMessage) {
 		m.logPrefix = "REPLICA"
 		m.nodeLog(typesCons.ElectedNewLeader(m.IdToValAddrMap[*m.LeaderId], *m.LeaderId, m.Height, m.Round))
 	}
+
+	return nil
 }
 
 /*** General Infrastructure Helpers ***/
diff --git a/consensus/hotstuff_handler.go b/consensus/hotstuff_handler.go
index 9b5ae3287..aa72b3a26 100644
--- a/consensus/hotstuff_handler.go
+++ b/consensus/hotstuff_handler.go
@@ -1,25 +1,10 @@
 package consensus
 
-import typesCons "github.com/pokt-network/pocket/consensus/types"
-
-// TODO(discuss): Low priority design: think of a way to make `hotstuff_*` files be a sub-package under consensus.
-// This is currently not possible because functions tied to the `ConsensusModule`
-// struct (implementing the ConsensusModule module), which spans multiple files.
-/*
-TODO(discuss): The reason we do not assign both the leader and the replica handlers
-to the leader (which should also act as a replica when it is a leader) is because it
-can create a weird inconsistent state (e.g. both the replica and leader try to restart
-the Pacemaker timeout). This requires additional "replica-like" logic in the leader
-handler which has both pros and cons:
-	Pros:
-		* The leader can short-circuit and optimize replica related logic
-		* Avoids additional code flowing through the P2P pipeline
-		* Allows for micro-optimizations
-	Cons:
-		* The leader's "replica related logic" requires an additional code path
-		* Code is less "generalizable" and therefore potentially more error prone
-*/
+import (
+	typesCons "github.com/pokt-network/pocket/consensus/types"
+)
 
+// DISCUSS: Should these functions return an error?
 type HotstuffMessageHandler interface {
 	HandleNewRoundMessage(*ConsensusModule, *typesCons.HotstuffMessage)
 	HandlePrepareMessage(*ConsensusModule, *typesCons.HotstuffMessage)
@@ -28,7 +13,7 @@ type HotstuffMessageHandler interface {
 	HandleDecideMessage(*ConsensusModule, *typesCons.HotstuffMessage)
 }
 
-func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage) {
+func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage) error {
 	m.nodeLog(typesCons.DebugHandlingHotstuffMessage(msg))
 
 	step := msg.GetStep()
@@ -40,19 +25,21 @@ func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage)
 		if !(m.LeaderId != nil && !m.isLeader() && step == NewRound) {
 			m.nodeLog(typesCons.WarnDiscardHotstuffMessage(msg, err.Error()))
 		}
-		return
+		return err
 	}
 
 	// Need to execute leader election if there is no leader and we are in a new round.
 	if m.Step == NewRound && m.LeaderId == nil {
-		m.electNextLeader(msg)
+		if err := m.electNextLeader(msg); err != nil {
+			return err
+		}
 	}
 
 	if m.isReplica() {
 		replicaHandlers[step](m, msg)
-		return
 	}
-
 	// Note that the leader also acts as a replica, but this logic is implemented in the underlying code.
 	leaderHandlers[step](m, msg)
+
+	return nil
 }
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 144da8e07..423ac9a87 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -59,6 +59,7 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusM
 		}
 		m.Block = block
 	} else {
+		// DISCUSS: Do we need to call `validateProposal` here?
 		// Leader acts like a replica if `highPrepareQC` is not `nil`
 		if err := m.applyBlock(highPrepareQC.Block); err != nil {
 			m.nodeLogError(typesCons.ErrApplyBlock.Error(), err)
@@ -105,7 +106,6 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrepareMessage(m *ConsensusMo
 	}
 	m.nodeLog(typesCons.OptimisticVoteCountPassed(Prepare))
 
-	// DISCUSS: What prevents leader from swapping out the block here?
 	prepareQC, err := m.getQuorumCertificate(m.Height, Prepare, m.Round)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrQCInvalid(Prepare).Error(), err)
@@ -116,13 +116,13 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrepareMessage(m *ConsensusMo
 	m.HighPrepareQC = prepareQC
 	m.MessagePool[Prepare] = nil
 
-	precommitProposeMessages, err := CreateProposeMessage(m.Height, m.Round, PreCommit, m.Block, prepareQC)
+	preCommitProposeMessage, err := CreateProposeMessage(m.Height, m.Round, PreCommit, m.Block, prepareQC)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateProposeMessage(PreCommit).Error(), err)
 		m.paceMaker.InterruptRound()
 		return
 	}
-	m.broadcastToNodes(precommitProposeMessages)
+	m.broadcastToNodes(preCommitProposeMessage)
 
 	// Leader also acts like a replica
 	precommitVoteMessage, err := CreateVoteMessage(m.Height, m.Round, PreCommit, m.Block, m.privateKey)
@@ -172,7 +172,7 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrecommitMessage(m *Consensus
 	commitVoteMessage, err := CreateVoteMessage(m.Height, m.Round, Commit, m.Block, m.privateKey)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(Commit).Error(), err)
-		return // TODO(olshansky): Should we interrupt the round here?
+		return
 	}
 	m.sendToNode(commitVoteMessage)
 }
@@ -217,7 +217,7 @@ func (handler *HotstuffLeaderMessageHandler) HandleCommitMessage(m *ConsensusMod
 		return
 	}
 
-	// There is no "replica behavior" to imitate here
+	// There is no "replica behavior" to imitate here because the leader already committed the block proposal.
 
 	m.paceMaker.NewHeight()
 	m.GetBus().
@@ -262,6 +262,8 @@ func (handler *HotstuffLeaderMessageHandler) emitTelemetryEvent(m *ConsensusModu
 
 // ValidateBasic general validation checks that apply to every HotstuffLeaderMessage
 func (handler *HotstuffLeaderMessageHandler) validateBasic(m *ConsensusModule, msg *typesCons.HotstuffMessage) error {
+	// DISCUSS: What prevents leader from swapping out the block here?
+
 	// Discard messages with invalid partial signatures before storing it in the leader's consensus mempool
 	if err := m.validatePartialSignature(msg); err != nil {
 		return err
@@ -331,13 +333,13 @@ func (m *ConsensusModule) prepareAndApplyBlock() (*typesCons.Block, error) {
 	lastByzValidators := make([][]byte, 0)
 
 	// Reap the mempool for transactions to be applied in this block
-	txs, err := m.utilityContext.GetProposalTransactions(m.privateKey.Address(), maxTxBytes, lastByzValidators)
+	txs, err := m.UtilityContext.GetProposalTransactions(m.privateKey.Address(), maxTxBytes, lastByzValidators)
 	if err != nil {
 		return nil, err
 	}
 
 	// Apply all the transactions in the block
-	appHash, err := m.utilityContext.ApplyBlock(int64(m.Height), m.privateKey.Address(), txs, lastByzValidators)
+	appHash, err := m.UtilityContext.ApplyBlock(int64(m.Height), m.privateKey.Address(), txs, lastByzValidators)
 	if err != nil {
 		return nil, err
 	}
diff --git a/consensus/hotstuff_replica.go b/consensus/hotstuff_replica.go
index cb333af70..06792bfb7 100644
--- a/consensus/hotstuff_replica.go
+++ b/consensus/hotstuff_replica.go
@@ -4,7 +4,6 @@ import (
 	"encoding/hex"
 	"fmt"
 	"log"
-	"unsafe"
 
 	consensusTelemetry "github.com/pokt-network/pocket/consensus/telemetry"
 	typesCons "github.com/pokt-network/pocket/consensus/types"
@@ -72,7 +71,7 @@ func (handler *HotstuffReplicaMessageHandler) HandlePrepareMessage(m *ConsensusM
 	prepareVoteMessage, err := CreateVoteMessage(m.Height, m.Round, Prepare, m.Block, m.privateKey)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(Prepare).Error(), err)
-		return
+		return // Not interrupting the round because liveness could continue with one failed vote
 	}
 	m.sendToNode(prepareVoteMessage)
 }
@@ -101,7 +100,7 @@ func (handler *HotstuffReplicaMessageHandler) HandlePrecommitMessage(m *Consensu
 	preCommitVoteMessage, err := CreateVoteMessage(m.Height, m.Round, PreCommit, m.Block, m.privateKey)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(PreCommit).Error(), err)
-		return
+		return // Not interrupting the round because liveness could continue with one failed vote
 	}
 	m.sendToNode(preCommitVoteMessage)
 }
@@ -130,7 +129,7 @@ func (handler *HotstuffReplicaMessageHandler) HandleCommitMessage(m *ConsensusMo
 	commitVoteMessage, err := CreateVoteMessage(m.Height, m.Round, Commit, m.Block, m.privateKey)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(Commit).Error(), err)
-		return
+		return // Not interrupting the round because liveness could continue with one failed vote
 	}
 	m.sendToNode(commitVoteMessage)
 }
@@ -182,17 +181,19 @@ func (handler *HotstuffReplicaMessageHandler) emitTelemetryEvent(m *ConsensusMod
 }
 
 func (m *ConsensusModule) validateProposal(msg *typesCons.HotstuffMessage) error {
+	// Check if node should be accepting proposals
 	if !(msg.GetType() == Propose && msg.GetStep() == Prepare) {
 		return typesCons.ErrProposalNotValidInPrepare
 	}
 
+	// Basic block metadata validation
 	if err := m.validateBlock(msg.GetBlock()); err != nil {
 		return err
 	}
 
-	// TODO(discuss): A nil QC implies a successful CommitQC or TimeoutQC, which have been omitted intentionally since
-	// they are not needed for consensus validity. However, if a QC is specified, it must be valid.
 	quorumCert := msg.GetQuorumCertificate()
+	// A nil QC implies a successful CommitQC or TimeoutQC, which have been omitted intentionally
+	// since they are not needed for consensus validity. However, if a QC is specified, it must be valid.
 	if quorumCert != nil {
 		if err := m.validateQuorumCertificate(quorumCert); err != nil {
 			return err
@@ -209,13 +210,14 @@ func (m *ConsensusModule) validateProposal(msg *typesCons.HotstuffMessage) error
 	}
 
 	// Safety: check the hash of the locked QC
-	// TODO(olshansky): Extend implementation to adopt `ExtendsFrom` as described in the Hotstuff whitepaper.
-	if protoHash(lockedQC.GetBlock()) == protoHash(justifyQC.Block) { // && lockedQC.Block.ExtendsFrom(justifyQC.Block)
+	// The equivalent of `lockedQC.Block.ExtendsFrom(justifyQC.Block)` in the hotstuff whitepaper is done in `applyBlock` below.
+	if protoHash(lockedQC.GetBlock()) == protoHash(justifyQC.Block) {
 		m.nodeLog(typesCons.ProposalBlockExtends)
 		return nil
 	}
 
-	// Liveness: node is locked on a QC from the past. [TODO]: Do we want to set `m.LockedQC = nil` here or something else?
+	// Liveness: node is locked on a QC from the past.
+	// DISCUSS: Where should additional logic be added to unlock the node?
 	if justifyQC.Height > lockedQC.Height || (justifyQC.Height == lockedQC.Height && justifyQC.Round > lockedQC.Round) {
 		return typesCons.ErrNodeIsLockedOnPastQC
 	}
@@ -223,6 +225,29 @@ func (m *ConsensusModule) validateProposal(msg *typesCons.HotstuffMessage) error
 	return typesCons.ErrUnhandledProposalCase
 }
 
+// This helper applies the block metadata to the utility & persistence layers
+func (m *ConsensusModule) applyBlock(block *typesCons.Block) error {
+	// TECHDEBT: Retrieve this from persistence
+	lastByzValidators := make([][]byte, 0)
+
+	// Apply all the transactions in the block and get the appHash
+	fmt.Println("OLSH", m.UtilityContext, block, block.BlockHeader.ProposerAddress == nil, block.Transactions == nil)
+	tx := make([][]byte, 0)
+	byteArr := []byte("A")
+	tx = append(tx, byteArr)
+	appHash, err := m.UtilityContext.ApplyBlock(int64(m.Height), []byte("A"), tx, lastByzValidators)
+	if err != nil {
+		return err
+	}
+
+	// CONSOLIDATE: Terminology of `blockHash`, `appHash` and `stateHash`
+	if block.BlockHeader.Hash != hex.EncodeToString(appHash) {
+		return typesCons.ErrInvalidAppHash(block.BlockHeader.Hash, hex.EncodeToString(appHash))
+	}
+
+	return nil
+}
+
 func (m *ConsensusModule) validateQuorumCertificate(qc *typesCons.QuorumCertificate) error {
 	if qc == nil {
 		return typesCons.ErrNilQC
@@ -238,6 +263,8 @@ func (m *ConsensusModule) validateQuorumCertificate(qc *typesCons.QuorumCertific
 
 	msgToJustify := qcToHotstuffMessage(qc)
 	numValid := 0
+
+	// TODO(#109): Aggregate signatures once BLS or DKG is implemented
 	for _, partialSig := range qc.ThresholdSignature.Signatures {
 		validator, ok := m.validatorMap[partialSig.Address]
 		if !ok {
@@ -252,7 +279,6 @@ func (m *ConsensusModule) validateQuorumCertificate(qc *typesCons.QuorumCertific
 		}
 		numValid++
 	}
-
 	if err := m.isOptimisticThresholdMet(numValid); err != nil {
 		return err
 	}
@@ -260,30 +286,6 @@ func (m *ConsensusModule) validateQuorumCertificate(qc *typesCons.QuorumCertific
 	return nil
 }
 
-// This is a helper function intended to be called by a replica/voter during a view change
-func (m *ConsensusModule) applyBlock(block *typesCons.Block) error {
-	// TODO: Add unit tests to verify this.
-	if unsafe.Sizeof(*block) > uintptr(m.MaxBlockBytes) {
-		return typesCons.ErrInvalidBlockSize(uint64(unsafe.Sizeof(*block)), m.MaxBlockBytes)
-	}
-
-	// TECHDEBT: Retrieve this from persistence
-	lastByzValidators := make([][]byte, 0)
-
-	// Apply all the transactions in the block and get the appHash
-	appHash, err := m.utilityContext.ApplyBlock(int64(m.Height), block.BlockHeader.ProposerAddress, block.Transactions, lastByzValidators)
-	if err != nil {
-		return err
-	}
-
-	// CONSOLIDATE: Terminology of `blockHash`, `appHash` and `stateHash`
-	if block.BlockHeader.Hash != hex.EncodeToString(appHash) {
-		return typesCons.ErrInvalidAppHash(block.BlockHeader.Hash, hex.EncodeToString(appHash))
-	}
-
-	return nil
-}
-
 func qcToHotstuffMessage(qc *typesCons.QuorumCertificate) *typesCons.HotstuffMessage {
 	return &typesCons.HotstuffMessage{
 		Height: qc.Height,
diff --git a/consensus/messages.go b/consensus/messages.go
index 8020ec068..eb2801275 100644
--- a/consensus/messages.go
+++ b/consensus/messages.go
@@ -70,16 +70,18 @@ func CreateVoteMessage(
 	return msg, nil
 }
 
-// Returns "partial" signature of the hotstuff message from one of the validators
+// Returns "partial" signature of the hotstuff message from one of the validators.
+// If there is an error signing the bytes, nil is returned instead.
 func getMessageSignature(msg *typesCons.HotstuffMessage, privKey crypto.PrivateKey) []byte {
 	bytesToSign, err := getSignableBytes(msg)
 	if err != nil {
+		log.Printf("[WARN] error getting bytes to sign: %v\n", err)
 		return nil
 	}
 
 	signature, err := privKey.Sign(bytesToSign)
 	if err != nil {
-		log.Fatalf("Error signing message: %v", err)
+		log.Printf("[WARN] error signing message: %v\n", err)
 		return nil
 	}
 
diff --git a/consensus/module.go b/consensus/module.go
index 42c7354ae..68e3874cc 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -53,7 +53,7 @@ type ConsensusModule struct {
 	validatorMap typesCons.ValidatorMap
 
 	// Module Dependencies
-	utilityContext    modules.UtilityContext
+	UtilityContext    modules.UtilityContext
 	paceMaker         Pacemaker
 	leaderElectionMod leader_election.LeaderElectionModule
 
@@ -125,7 +125,7 @@ func Create(configPath, genesisPath string, useRandomPK bool) (modules.Consensus
 		lastAppHash:  "",
 		validatorMap: valMap,
 
-		utilityContext:    nil,
+		UtilityContext:    nil,
 		paceMaker:         paceMaker,
 		leaderElectionMod: leaderElectionMod,
 
@@ -225,7 +225,9 @@ func (m *ConsensusModule) HandleMessage(message *anypb.Any) error {
 		if err := anypb.UnmarshalTo(message, &hotstuffMessage, proto.UnmarshalOptions{}); err != nil {
 			return err
 		}
-		m.handleHotstuffMessage(&hotstuffMessage)
+		if err := m.handleHotstuffMessage(&hotstuffMessage); err != nil {
+			return err
+		}
 	case UtilityMessage:
 		panic("[WARN] UtilityMessage handling is not implemented by consensus yet...")
 	default:

From fc904a0986b840b70aaee7469f0f26d955c1bc2e Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Fri, 23 Sep 2022 17:24:30 -0700
Subject: [PATCH 014/227] Remove OLSH logs

---
 consensus/consensus_tests/pacemaker_test.go |  2 --
 consensus/consensus_tests/utils_test.go     | 32 ++++++++++++++-------
 consensus/hotstuff_replica.go               |  6 +---
 3 files changed, 22 insertions(+), 18 deletions(-)

diff --git a/consensus/consensus_tests/pacemaker_test.go b/consensus/consensus_tests/pacemaker_test.go
index fb2d151ac..23466e7a3 100644
--- a/consensus/consensus_tests/pacemaker_test.go
+++ b/consensus/consensus_tests/pacemaker_test.go
@@ -2,7 +2,6 @@ package consensus_tests
 
 import (
 	"encoding/hex"
-	"fmt"
 	"log"
 	"reflect"
 	"testing"
@@ -150,7 +149,6 @@ func TestPacemakerCatchupSameStepDifferentRounds(t *testing.T) {
 		// utilityContext is only set on new rounds, which is skipped in this test
 		utilityContext, err := pocketNode.GetBus().GetUtilityModule().NewContext(int64(testHeight))
 		require.NoError(t, err)
-		fmt.Println("OLSH", utilityContext)
 
 		consensusModImpl := GetConsensusModImplementation(pocketNode)
 		consensusModImpl.FieldByName("Height").SetUint(testHeight)
diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index dd687953b..2d4bb01ae 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -343,8 +343,7 @@ func baseP2PMock(t *testing.T, testChannel modules.EventsChannel) *modulesMock.M
 func baseUtilityMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockUtilityModule {
 	ctrl := gomock.NewController(t)
 	utilityMock := modulesMock.NewMockUtilityModule(ctrl)
-	utilityContextMock := modulesMock.NewMockUtilityContext(ctrl)
-	persistenceContextMock := modulesMock.NewMockPersistenceRWContext(ctrl)
+	utilityContextMock := baseUtilityContextMock(t)
 
 	utilityMock.EXPECT().Start().Return(nil).AnyTimes()
 	utilityMock.EXPECT().SetBus(gomock.Any()).Do(func(modules.Bus) {}).AnyTimes()
@@ -353,6 +352,14 @@ func baseUtilityMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockUti
 		Return(utilityContextMock, nil).
 		MaxTimes(4)
 
+	return utilityMock
+}
+
+func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
+	ctrl := gomock.NewController(t)
+	utilityContextMock := modulesMock.NewMockUtilityContext(ctrl)
+	persistenceContextMock := basePersistenceContextMock(t)
+
 	utilityContextMock.EXPECT().GetPersistenceContext().Return(persistenceContextMock).AnyTimes()
 	utilityContextMock.EXPECT().CommitPersistenceContext().Return(nil).AnyTimes()
 	utilityContextMock.EXPECT().ReleaseContext().Return().AnyTimes()
@@ -365,9 +372,14 @@ func baseUtilityMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockUti
 		Return(appHash, nil).
 		AnyTimes()
 
-	persistenceContextMock.EXPECT().Commit().Return(nil).AnyTimes()
+	return utilityContextMock
+}
 
-	return utilityMock
+func basePersistenceContextMock(t *testing.T) *modulesMock.MockPersistenceRWContext {
+	ctrl := gomock.NewController(t)
+	persistenceContextMock := modulesMock.NewMockPersistenceRWContext(ctrl)
+	persistenceContextMock.EXPECT().Commit().Return(nil).AnyTimes()
+	return persistenceContextMock
 }
 
 func baseTelemetryMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockTelemetryModule {
@@ -378,25 +390,23 @@ func baseTelemetryMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockT
 
 	telemetryMock.EXPECT().Start().Do(func() {}).AnyTimes()
 	telemetryMock.EXPECT().SetBus(gomock.Any()).Do(func(modules.Bus) {}).AnyTimes()
-
 	telemetryMock.EXPECT().GetTimeSeriesAgent().Return(timeSeriesAgentMock).AnyTimes()
-	timeSeriesAgentMock.EXPECT().CounterRegister(gomock.Any(), gomock.Any()).MaxTimes(1)
-	timeSeriesAgentMock.EXPECT().CounterIncrement(gomock.Any()).AnyTimes()
-
 	telemetryMock.EXPECT().GetEventMetricsAgent().Return(eventMetricsAgentMock).AnyTimes()
-	eventMetricsAgentMock.EXPECT().EmitEvent(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
 
 	return telemetryMock
 }
 
 func baseTelemetryTimeSeriesAgentMock(t *testing.T) *modulesMock.MockTimeSeriesAgent {
 	ctrl := gomock.NewController(t)
-	timeseriesAgentMock := modulesMock.NewMockTimeSeriesAgent(ctrl)
-	return timeseriesAgentMock
+	timeSeriesAgentMock := modulesMock.NewMockTimeSeriesAgent(ctrl)
+	timeSeriesAgentMock.EXPECT().CounterRegister(gomock.Any(), gomock.Any()).MaxTimes(1)
+	timeSeriesAgentMock.EXPECT().CounterIncrement(gomock.Any()).AnyTimes()
+	return timeSeriesAgentMock
 }
 
 func baseTelemetryEventMetricsAgentMock(t *testing.T) *modulesMock.MockEventMetricsAgent {
 	ctrl := gomock.NewController(t)
 	eventMetricsAgentMock := modulesMock.NewMockEventMetricsAgent(ctrl)
+	eventMetricsAgentMock.EXPECT().EmitEvent(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
 	return eventMetricsAgentMock
 }
diff --git a/consensus/hotstuff_replica.go b/consensus/hotstuff_replica.go
index 06792bfb7..c7765de2f 100644
--- a/consensus/hotstuff_replica.go
+++ b/consensus/hotstuff_replica.go
@@ -231,11 +231,7 @@ func (m *ConsensusModule) applyBlock(block *typesCons.Block) error {
 	lastByzValidators := make([][]byte, 0)
 
 	// Apply all the transactions in the block and get the appHash
-	fmt.Println("OLSH", m.UtilityContext, block, block.BlockHeader.ProposerAddress == nil, block.Transactions == nil)
-	tx := make([][]byte, 0)
-	byteArr := []byte("A")
-	tx = append(tx, byteArr)
-	appHash, err := m.UtilityContext.ApplyBlock(int64(m.Height), []byte("A"), tx, lastByzValidators)
+	appHash, err := m.UtilityContext.ApplyBlock(int64(m.Height), block.BlockHeader.ProposerAddress, block.Transactions, lastByzValidators)
 	if err != nil {
 		return err
 	}

From 213892c896970a731a5b2827698e42a5ab6641f3 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sat, 24 Sep 2022 10:23:33 -0700
Subject: [PATCH 015/227] /s/aggregateMessage/m.aggregateMessage

---
 consensus/hotstuff_leader.go | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 423ac9a87..54674186f 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -243,7 +243,7 @@ func (handler *HotstuffLeaderMessageHandler) anteHandle(m *ConsensusModule, msg
 	if err := handler.validateBasic(m, msg); err != nil {
 		return err
 	}
-	m.aggregateMessage(msg)
+	m.tempIndexHotstuffMessage(msg)
 	return nil
 }
 
@@ -262,8 +262,6 @@ func (handler *HotstuffLeaderMessageHandler) emitTelemetryEvent(m *ConsensusModu
 
 // ValidateBasic general validation checks that apply to every HotstuffLeaderMessage
 func (handler *HotstuffLeaderMessageHandler) validateBasic(m *ConsensusModule, msg *typesCons.HotstuffMessage) error {
-	// DISCUSS: What prevents leader from swapping out the block here?
-
 	// Discard messages with invalid partial signatures before storing it in the leader's consensus mempool
 	if err := m.validatePartialSignature(msg); err != nil {
 		return err
@@ -305,10 +303,11 @@ func (m *ConsensusModule) validatePartialSignature(msg *typesCons.HotstuffMessag
 		address, m.ValAddrToIdMap[address], msg, pubKey)
 }
 
-func (m *ConsensusModule) aggregateMessage(msg *typesCons.HotstuffMessage) {
-	// TODO(olshansky): Add proper tests for this when we figure out where the mempool should live.
-	// NOTE: This is just a placeholder at the moment. It doesn't actually work because SizeOf returns
-	// the size of the map pointer, and does not recursively determine the size of all the underlying elements.
+// TODO: This is just a placeholder at the moment. It doesn't actually work because SizeOf returns
+//       the size of the map pointer, and does not recursively determine the size of all the
+//       underlying elements
+//       Add proper tests and implementation once the mempool is implemented.
+func (m *ConsensusModule) tempIndexHotstuffMessage(msg *typesCons.HotstuffMessage) {
 	if m.consCfg.GetMaxMempoolBytes() < uint64(unsafe.Sizeof(m.MessagePool)) {
 		m.nodeLogError(typesCons.DisregardHotstuffMessage, typesCons.ErrConsensusMempoolFull)
 		return

From 686c2ca5c7528e0c3f100e9b9f584bc194205ecc Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sat, 24 Sep 2022 10:38:57 -0700
Subject: [PATCH 016/227] Updated validateBlockBasic

---
 consensus/block.go            | 13 ++++++++++++-
 consensus/hotstuff_leader.go  | 25 ++++++++++++-------------
 consensus/hotstuff_replica.go | 12 +++++-------
 3 files changed, 29 insertions(+), 21 deletions(-)

diff --git a/consensus/block.go b/consensus/block.go
index ce123c1d7..a35e4f100 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -1,13 +1,14 @@
 package consensus
 
 import (
+	"log"
 	"unsafe"
 
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
 
 // TODO: Add additional basic block metadata validation w/ unit tests
-func (m *ConsensusModule) validateBlock(block *typesCons.Block) error {
+func (m *ConsensusModule) validateBlockBasic(block *typesCons.Block) error {
 	if block == nil {
 		return typesCons.ErrNilBlock
 	}
@@ -16,6 +17,16 @@ func (m *ConsensusModule) validateBlock(block *typesCons.Block) error {
 		return typesCons.ErrInvalidBlockSize(uint64(unsafe.Sizeof(*block)), m.MaxBlockBytes)
 	}
 
+	// If the current block being processed (i.e. voted on) by consensus is non nil, we need to make
+	// sure that the data (height, round, step, txs, etc) is the same before we start validating the signatures
+	if m.Block != nil {
+		// DISCUSS: The only difference between blocks from one step to another is the QC, so we need
+		// to determine where/how to validate this
+		if protoHash(m.Block) != protoHash(block) {
+			log.Println("[TECHDEBT][ERROR] The block being processed is not the same as that received by the consensus module ")
+		}
+	}
+
 	return nil
 }
 
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 54674186f..9c75148cc 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -240,9 +240,17 @@ func (handler *HotstuffLeaderMessageHandler) HandleDecideMessage(m *ConsensusMod
 
 // anteHandle is the general handler called for every before every specific HotstuffLeaderMessageHandler handler
 func (handler *HotstuffLeaderMessageHandler) anteHandle(m *ConsensusModule, msg *typesCons.HotstuffMessage) error {
-	if err := handler.validateBasic(m, msg); err != nil {
+	// Basic block metadata validation
+	if err := m.validateBlockBasic(msg.GetBlock()); err != nil {
 		return err
 	}
+
+	// Discard messages with invalid partial signatures before storing it in the leader's consensus mempool
+	if err := m.validatePartialSignature(msg); err != nil {
+		return err
+	}
+
+	// TECHDEBT: Until we integrate with the real mempool, this is a makeshift solution
 	m.tempIndexHotstuffMessage(msg)
 	return nil
 }
@@ -260,15 +268,6 @@ func (handler *HotstuffLeaderMessageHandler) emitTelemetryEvent(m *ConsensusModu
 		)
 }
 
-// ValidateBasic general validation checks that apply to every HotstuffLeaderMessage
-func (handler *HotstuffLeaderMessageHandler) validateBasic(m *ConsensusModule, msg *typesCons.HotstuffMessage) error {
-	// Discard messages with invalid partial signatures before storing it in the leader's consensus mempool
-	if err := m.validatePartialSignature(msg); err != nil {
-		return err
-	}
-	return nil
-}
-
 func (m *ConsensusModule) validatePartialSignature(msg *typesCons.HotstuffMessage) error {
 	if msg.GetStep() == NewRound {
 		m.nodeLog(typesCons.ErrUnnecessaryPartialSigForNewRound.Error())
@@ -303,9 +302,9 @@ func (m *ConsensusModule) validatePartialSignature(msg *typesCons.HotstuffMessag
 		address, m.ValAddrToIdMap[address], msg, pubKey)
 }
 
-// TODO: This is just a placeholder at the moment. It doesn't actually work because SizeOf returns
-//       the size of the map pointer, and does not recursively determine the size of all the
-//       underlying elements
+// TODO: This is just a placeholder at the moment for indexing hotstuff messages ONLY.
+//       It doesn't actually work because SizeOf returns the size of the map pointer,
+//       and does not recursively determine the size of all the underlying elements
 //       Add proper tests and implementation once the mempool is implemented.
 func (m *ConsensusModule) tempIndexHotstuffMessage(msg *typesCons.HotstuffMessage) {
 	if m.consCfg.GetMaxMempoolBytes() < uint64(unsafe.Sizeof(m.MessagePool)) {
diff --git a/consensus/hotstuff_replica.go b/consensus/hotstuff_replica.go
index c7765de2f..a4eda9951 100644
--- a/consensus/hotstuff_replica.go
+++ b/consensus/hotstuff_replica.go
@@ -3,7 +3,6 @@ package consensus
 import (
 	"encoding/hex"
 	"fmt"
-	"log"
 
 	consensusTelemetry "github.com/pokt-network/pocket/consensus/telemetry"
 	typesCons "github.com/pokt-network/pocket/consensus/types"
@@ -163,7 +162,11 @@ func (handler *HotstuffReplicaMessageHandler) HandleDecideMessage(m *ConsensusMo
 
 // anteHandle is the handler called on every replica message before specific handler
 func (handler *HotstuffReplicaMessageHandler) anteHandle(m *ConsensusModule, msg *typesCons.HotstuffMessage) error {
-	log.Println("TODO: Hotstuff replica ante handle not implemented yet")
+	// Basic block metadata validation
+	if err := m.validateBlockBasic(msg.GetBlock()); err != nil {
+		return err
+	}
+
 	return nil
 }
 
@@ -186,11 +189,6 @@ func (m *ConsensusModule) validateProposal(msg *typesCons.HotstuffMessage) error
 		return typesCons.ErrProposalNotValidInPrepare
 	}
 
-	// Basic block metadata validation
-	if err := m.validateBlock(msg.GetBlock()); err != nil {
-		return err
-	}
-
 	quorumCert := msg.GetQuorumCertificate()
 	// A nil QC implies a successful CommitQC or TimeoutQC, which have been omitted intentionally
 	// since they are not needed for consensus validity. However, if a QC is specified, it must be valid.

From 78ed1d8adfffe4aaae682771bf37286bffd00fae Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sat, 24 Sep 2022 12:04:22 -0700
Subject: [PATCH 017/227] Removed PersistenceContext exposure from utility
 context interface

---
 consensus/consensus_tests/utils_test.go |  6 +++---
 consensus/hotstuff_leader.go            |  2 +-
 consensus/types/proto/block.proto       |  2 +-
 shared/modules/persistence_module.go    | 12 ++++--------
 shared/modules/utility_module.go        |  6 ++++--
 utility/block.go                        |  2 +-
 utility/context.go                      | 11 +++++------
 7 files changed, 19 insertions(+), 22 deletions(-)

diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 2d4bb01ae..f7711d03f 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -358,10 +358,10 @@ func baseUtilityMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockUti
 func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 	ctrl := gomock.NewController(t)
 	utilityContextMock := modulesMock.NewMockUtilityContext(ctrl)
-	persistenceContextMock := basePersistenceContextMock(t)
+	// persistenceContextMock := basePersistenceContextMock(t)
 
-	utilityContextMock.EXPECT().GetPersistenceContext().Return(persistenceContextMock).AnyTimes()
-	utilityContextMock.EXPECT().CommitPersistenceContext().Return(nil).AnyTimes()
+	// utilityContextMock.EXPECT().GetPersistenceContext().Return(persistenceContextMock).AnyTimes()
+	utilityContextMock.EXPECT().CommitContext().Return(nil).AnyTimes()
 	utilityContextMock.EXPECT().ReleaseContext().Return().AnyTimes()
 	utilityContextMock.EXPECT().
 		GetProposalTransactions(gomock.Any(), maxTxBytes, gomock.AssignableToTypeOf(emptyByzValidators)).
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 9c75148cc..89541c999 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -336,7 +336,7 @@ func (m *ConsensusModule) prepareAndApplyBlock() (*typesCons.Block, error) {
 		return nil, err
 	}
 
-	// Apply all the transactions in the block
+	// Apply all the transactions in the block - 
 	appHash, err := m.UtilityContext.ApplyBlock(int64(m.Height), m.privateKey.Address(), txs, lastByzValidators)
 	if err != nil {
 		return nil, err
diff --git a/consensus/types/proto/block.proto b/consensus/types/proto/block.proto
index 6024bcea4..b18d8dfa7 100644
--- a/consensus/types/proto/block.proto
+++ b/consensus/types/proto/block.proto
@@ -5,7 +5,7 @@ option go_package = "github.com/pokt-network/pocket/consensus/types";
 
 import "google/protobuf/timestamp.proto";
 
-// TODO (Team) Discuss all tendermint legacy
+// TECHDEBT: Re-evaluate some tendermint legacy fields
 message BlockHeader {
   int64 height = 1;
   string hash = 2;
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index 3d74d137d..9f93c5d35 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -49,8 +49,9 @@ type PersistenceWriteContext interface {
 	NewSavePoint([]byte) error
 	RollbackToSavePoint([]byte) error
 
-	Reset() error
 	Commit() error
+	// DISCUSS: Can we consolidate `Reset` and `Release`
+	Reset() error
 	Release() error
 
 	// Question:
@@ -61,13 +62,8 @@ type PersistenceWriteContext interface {
 	// Block Operations
 
 	// Indexer Operations
-	StoreTransaction(transactionProtoBytes []byte) error
-
-	// Block Operations
-	// TODO_TEMPORARY: Including two functions for the SQL and KV Store as an interim solution
-	//                 until we include the schema as part of the SQL Store because persistence
-	//                 currently has no access to the protobuf schema which is the source of truth.
-	InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error // Writes the block in the SQL database
+	StoreTransaction(transactionProtoBytes []byte) error                                         // Stores a transaction
+	CommitTransactions(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error // Writes the block in the SQL database
 
 	// Pool Operations
 	AddPoolAmount(name string, amount string) error
diff --git a/shared/modules/utility_module.go b/shared/modules/utility_module.go
index edfbc94ee..8472e4582 100644
--- a/shared/modules/utility_module.go
+++ b/shared/modules/utility_module.go
@@ -14,13 +14,15 @@ type UtilityModule interface {
 // operations.
 type UtilityContext interface {
 	// Block operations
+
+	// Reaps the mempool for transactions that are ready to be proposed in a new block
 	GetProposalTransactions(proposer []byte, maxTransactionBytes int, lastBlockByzantineValidators [][]byte) (transactions [][]byte, err error)
+	// Applies the transactions to an ephemeral state in the utility & underlying persistence context;similar to `SafeNode` in the Hotstuff whitepaper.
 	ApplyBlock(height int64, proposer []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) (appHash []byte, err error)
 
 	// Context operations
 	ReleaseContext()
-	GetPersistenceContext() PersistenceRWContext
-	CommitPersistenceContext() error
+	CommitContext() error
 
 	// Validation operations
 	CheckTransaction(tx []byte) error
diff --git a/utility/block.go b/utility/block.go
index c762b35a7..ef2ab2894 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -51,7 +51,7 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 		if err := u.ApplyTransaction(tx); err != nil {
 			return nil, err
 		}
-		if err := u.GetPersistenceContext().StoreTransaction(transactionProtoBytes); err != nil {
+		if err := u.Context.PersistenceRWContext.StoreTransaction(transactionProtoBytes); err != nil {
 			return nil, err
 		}
 
diff --git a/utility/context.go b/utility/context.go
index 460b7cfa1..37f26d637 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -2,6 +2,7 @@ package utility
 
 import (
 	"encoding/hex"
+
 	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/modules"
 	typesUtil "github.com/pokt-network/pocket/utility/types"
@@ -39,12 +40,10 @@ func (u *UtilityContext) Store() *Context {
 	return u.Context
 }
 
-func (u *UtilityContext) GetPersistenceContext() modules.PersistenceRWContext {
-	return u.Context.PersistenceRWContext
-}
-
-func (u *UtilityContext) CommitPersistenceContext() error {
-	return u.Context.PersistenceRWContext.Commit()
+func (u *UtilityContext) CommitContext() error {
+	err := u.Context.PersistenceRWContext.Commit()
+	u.Context = nil
+	return err
 }
 
 func (u *UtilityContext) ReleaseContext() {

From 113343830ab95cbd563bad80a1e1e07c4f1eedb9 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sat, 24 Sep 2022 13:02:07 -0700
Subject: [PATCH 018/227] Tests passing - commit before creating a new block
 type

---
 consensus/block.go                      | 21 +++++++--------
 consensus/consensus_tests/utils_test.go | 17 ++++++------
 consensus/hotstuff_leader.go            |  3 ++-
 consensus/types/errors.go               |  2 ++
 persistence/block.go                    |  6 ++++-
 persistence/context.go                  | 15 +++--------
 persistence/db.go                       |  2 +-
 persistence/debug.go                    |  2 +-
 persistence/genesis.go                  |  2 +-
 persistence/state.go                    | 21 ++++++++-------
 persistence/test/module_test.go         |  3 ++-
 shared/modules/persistence_module.go    | 23 +++++++---------
 shared/modules/utility_module.go        |  4 +--
 utility/block.go                        | 35 +++++++------------------
 utility/context.go                      | 18 ++++++++-----
 utility/test/block_test.go              | 18 +++----------
 16 files changed, 82 insertions(+), 110 deletions(-)

diff --git a/consensus/block.go b/consensus/block.go
index a35e4f100..48c452b2e 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -9,10 +9,14 @@ import (
 
 // TODO: Add additional basic block metadata validation w/ unit tests
 func (m *ConsensusModule) validateBlockBasic(block *typesCons.Block) error {
-	if block == nil {
+	if block == nil && m.Step != NewRound {
 		return typesCons.ErrNilBlock
 	}
 
+	if block != nil && m.Step == NewRound {
+		return typesCons.ErrBlockExists
+	}
+
 	if unsafe.Sizeof(*block) > uintptr(m.MaxBlockBytes) {
 		return typesCons.ErrInvalidBlockSize(uint64(unsafe.Sizeof(*block)), m.MaxBlockBytes)
 	}
@@ -37,7 +41,10 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 	// should not be called.
 	if m.UtilityContext != nil {
 		m.nodeLog(typesCons.NilUtilityContextWarning)
-		m.UtilityContext.ReleaseContext()
+		if err := m.UtilityContext.ReleaseContext(); err != nil {
+			// Logging an error but allowing the consensus lifecycle to continue
+			m.nodeLogError("cannot release existing utility context", err)
+		}
 		m.UtilityContext = nil
 	}
 
@@ -53,18 +60,10 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
 
-	// Store the block in the KV store
-	// codec := codec.GetCodec()
-	// blockProtoBytes, err := codec.Marshal(block)
-	// if err != nil {
-	// 	return err
-	// }
-
 	// Commit and release the context
-	if err := m.UtilityContext.CommitPersistenceContext(); err != nil {
+	if err := m.UtilityContext.CommitContext(block.BlockHeader.QuorumCertificate); err != nil {
 		return err
 	}
-
 	m.UtilityContext.ReleaseContext()
 	m.UtilityContext = nil
 
diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index f7711d03f..7f12277a2 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -360,9 +360,6 @@ func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 	utilityContextMock := modulesMock.NewMockUtilityContext(ctrl)
 	// persistenceContextMock := basePersistenceContextMock(t)
 
-	// utilityContextMock.EXPECT().GetPersistenceContext().Return(persistenceContextMock).AnyTimes()
-	utilityContextMock.EXPECT().CommitContext().Return(nil).AnyTimes()
-	utilityContextMock.EXPECT().ReleaseContext().Return().AnyTimes()
 	utilityContextMock.EXPECT().
 		GetProposalTransactions(gomock.Any(), maxTxBytes, gomock.AssignableToTypeOf(emptyByzValidators)).
 		Return(make([][]byte, 0), nil).
@@ -371,16 +368,18 @@ func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 		ApplyBlock(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
 		Return(appHash, nil).
 		AnyTimes()
+	utilityContextMock.EXPECT().CommitContext(gomock.Any()).Return(nil).AnyTimes()
+	utilityContextMock.EXPECT().ReleaseContext().Return(nil).AnyTimes()
 
 	return utilityContextMock
 }
 
-func basePersistenceContextMock(t *testing.T) *modulesMock.MockPersistenceRWContext {
-	ctrl := gomock.NewController(t)
-	persistenceContextMock := modulesMock.NewMockPersistenceRWContext(ctrl)
-	persistenceContextMock.EXPECT().Commit().Return(nil).AnyTimes()
-	return persistenceContextMock
-}
+// func basePersistenceContextMock(t *testing.T) *modulesMock.MockPersistenceRWContext {
+// 	ctrl := gomock.NewController(t)
+// 	persistenceContextMock := modulesMock.NewMockPersistenceRWContext(ctrl)
+// 	persistenceContextMock.EXPECT().Commit(gomock.Any()).Return(nil).AnyTimes()
+// 	return persistenceContextMock
+// }
 
 func baseTelemetryMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockTelemetryModule {
 	ctrl := gomock.NewController(t)
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 89541c999..f87c5f58b 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -241,6 +241,7 @@ func (handler *HotstuffLeaderMessageHandler) HandleDecideMessage(m *ConsensusMod
 // anteHandle is the general handler called for every before every specific HotstuffLeaderMessageHandler handler
 func (handler *HotstuffLeaderMessageHandler) anteHandle(m *ConsensusModule, msg *typesCons.HotstuffMessage) error {
 	// Basic block metadata validation
+
 	if err := m.validateBlockBasic(msg.GetBlock()); err != nil {
 		return err
 	}
@@ -336,7 +337,7 @@ func (m *ConsensusModule) prepareAndApplyBlock() (*typesCons.Block, error) {
 		return nil, err
 	}
 
-	// Apply all the transactions in the block - 
+	// Apply all the transactions in the block -
 	appHash, err := m.UtilityContext.ApplyBlock(int64(m.Height), m.privateKey.Address(), txs, lastByzValidators)
 	if err != nil {
 		return nil, err
diff --git a/consensus/types/errors.go b/consensus/types/errors.go
index d90d85151..fb6dd6df4 100644
--- a/consensus/types/errors.go
+++ b/consensus/types/errors.go
@@ -114,6 +114,7 @@ func DebugHandlingHotstuffMessage(msg *HotstuffMessage) string {
 // Errors
 const (
 	nilBLockError                               = "block is nil"
+	blockExistsError                            = "block exists but should be nil"
 	nilBLockProposalError                       = "block should never be nil when creating a proposal message"
 	nilBLockVoteError                           = "block should never be nil when creating a vote message for a proposal"
 	proposalNotValidInPrepareError              = "proposal is not valid in the PREPARE step"
@@ -152,6 +153,7 @@ const (
 
 var (
 	ErrNilBlock                               = errors.New(nilBLockError)
+	ErrBlockExists                            = errors.New(blockExistsError)
 	ErrNilBlockProposal                       = errors.New(nilBLockProposalError)
 	ErrNilBlockVote                           = errors.New(nilBLockVoteError)
 	ErrProposalNotValidInPrepare              = errors.New(proposalNotValidInPrepareError)
diff --git a/persistence/block.go b/persistence/block.go
index 49de236fc..af9a797da 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -66,6 +66,10 @@ func heightToBytes(height int64) []byte {
 	return heightBytes
 }
 
-func (p PostgresContext) storeBlock(blockProtoBytes []byte) error {
+func (p PostgresContext) commitBlock(blockProtoBytes []byte) error {
+	// get current height
+	// get proposer
+	// get hash
+	// get transaction
 	return p.DB.Blockstore.Put(heightToBytes(p.Height), blockProtoBytes)
 }
diff --git a/persistence/context.go b/persistence/context.go
index 57e15e0ad..35e7ba108 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -16,28 +16,19 @@ func (p PostgresContext) RollbackToSavePoint(bytes []byte) error {
 }
 
 func (p PostgresContext) UpdateAppHash() ([]byte, error) {
-	if _, err := p.updateStateHash(); err != nil {
+	if err := p.updateStateHash(); err != nil {
 		return nil, err
 	}
-	return p.StateHash, nil
-}
-
-func (p PostgresContext) AppHash() ([]byte, error) {
-	return p.StateHash, nil
+	return p.stateHash, nil
 }
 
 func (p PostgresContext) Reset() error {
 	panic("TODO: PostgresContext Reset not implemented")
 }
 
-func (p PostgresContext) Commit() error {
+func (p PostgresContext) Commit(quorumCert []byte) error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
-	// HACK: The data has already been written to the postgres DB, so what should we do here? The idea I have is:
-	// if _, err := p.updateStateHash(); err != nil {
-	// 	return err
-	// }
-
 	ctx := context.TODO()
 	if err := p.DB.Tx.Commit(context.TODO()); err != nil {
 		return err
diff --git a/persistence/db.go b/persistence/db.go
index 060cec041..8d392d7b5 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -45,7 +45,7 @@ type PostgresContext struct {
 	Height int64
 	DB     PostgresDB
 
-	StateHash []byte
+	stateHash []byte
 
 	// IMPROVE: Depending on how the use of `PostgresContext` evolves, we may be able to get
 	// access to these directly via the postgres module.
diff --git a/persistence/debug.go b/persistence/debug.go
index 3fdc583a4..14fc5c704 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -44,7 +44,7 @@ func (m *PersistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 
 func (m *PersistenceModule) clearState(_ *debug.DebugMessage) {
 	context, err := m.NewRWContext(-1)
-	defer context.Commit()
+	defer context.Commit(nil)
 	if err != nil {
 		log.Printf("Error creating new context: %s \n", err)
 		return
diff --git a/persistence/genesis.go b/persistence/genesis.go
index 727fa4f57..329cdbfa4 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -149,7 +149,7 @@ func (m *PersistenceModule) populateGenesisState(state *types.PersistenceGenesis
 		log.Fatalf("an error occurred initializing flags: %s", err.Error())
 	}
 
-	if err = rwContext.Commit(); err != nil {
+	if err = rwContext.Commit(nil); err != nil {
 		log.Fatalf("an error occurred during commit() on genesis state %s ", err.Error())
 	}
 }
diff --git a/persistence/state.go b/persistence/state.go
index f35f3622b..d689410ee 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -52,30 +52,31 @@ func loadMerkleTrees(map[MerkleTree]*smt.SparseMerkleTree, error) {
 }
 
 // Question: Is this the right approach?
-func (p *PostgresContext) updateStateHash() ([]byte, error) {
+func (p *PostgresContext) updateStateHash() error {
 	// Update all the merkle trees
 	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
 		switch treeType {
 		case appMerkleTree:
 			apps, err := p.getApplicationsUpdatedAtHeight(p.Height)
 			if err != nil {
-				return nil, typesUtil.NewError(typesUtil.Code(42), "Couldn't figure out apps updated") // TODO_IN_THIS_COMMIT
+				// TODO_IN_THIS_COMMIT: Update this error
+				return typesUtil.NewError(typesUtil.Code(42), "Couldn't figure out apps updated")
 			}
 			for _, app := range apps {
-				appBytes, err := proto.Marshal(app)
+				appBz, err := proto.Marshal(app)
 				if err != nil {
-					return nil, err
+					return err
 				}
 				// An update results in a create/update that is idempotent
 				addrBz, err := hex.DecodeString(app.Address)
 				if err != nil {
-					return nil, err
+					return err
 				}
-				if _, err := p.MerkleTrees[treeType].Update(addrBz, appBytes); err != nil {
-					return nil, err
+				if _, err := p.MerkleTrees[treeType].Update(addrBz, appBz); err != nil {
+					return err
 				}
-				// TODO_IN_THIS_COMMIT: Add support for `Delete` operations to remove it from the tree
 			}
+		// TODO_IN_THIS_COMMIT: re
 		default:
 			log.Fatalln("Not handled yet in state commitment update", treeType)
 		}
@@ -96,6 +97,6 @@ func (p *PostgresContext) updateStateHash() ([]byte, error) {
 	rootsConcat := bytes.Join(roots, []byte{})
 	stateHash := sha256.Sum256(rootsConcat)
 
-	p.StateHash = stateHash[:]
-	return p.StateHash, nil
+	p.stateHash = stateHash[:]
+	return nil
 }
diff --git a/persistence/test/module_test.go b/persistence/test/module_test.go
index 3bee636c5..f5df476b0 100644
--- a/persistence/test/module_test.go
+++ b/persistence/test/module_test.go
@@ -18,12 +18,13 @@ func TestPersistenceContextParallelReadWrite(t *testing.T) {
 	poolAddress := []byte("address")
 	originalAmount := "15"
 	modifiedAmount := "10"
+	quorumCert := []byte("quorumCert")
 
 	// setup a write context, insert a pool and commit it
 	context, err := testPersistenceMod.NewRWContext(0)
 	require.NoError(t, err)
 	require.NoError(t, context.InsertPool(poolName, poolAddress, originalAmount))
-	require.NoError(t, context.Commit())
+	require.NoError(t, context.Commit(quorumCert))
 
 	// verify the insert in the previously committed context worked
 	contextA, err := testPersistenceMod.NewRWContext(0)
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index 9f93c5d35..4da6fb211 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -38,32 +38,29 @@ type PersistenceRWContext interface {
 	PersistenceWriteContext
 }
 
+// TODO: Simplify the interface (reference - https://dave.cheney.net/practical-go/presentations/gophercon-israel.html#_prefer_single_method_interfaces)
+// - Add general purpose methods such as `ActorOperation(enum_actor_type, ...)` which can be use like so: `Insert(FISHERMAN, ...)`
+// - Use general purpose parameter methods such as `Set(enum_gov_type, ...)` such as `Set(STAKING_ADJUSTMENT, ...)`
+
 // NOTE: There's not really a use case for a write only interface,
 // but it abstracts and contrasts nicely against the read only context
 // TODO (andrew) convert address and public key to string not bytes #149
 type PersistenceWriteContext interface {
-	// TODO: Simplify the interface (reference - https://dave.cheney.net/practical-go/presentations/gophercon-israel.html#_prefer_single_method_interfaces)
-	// - Add general purpose methods such as `ActorOperation(enum_actor_type, ...)` which can be use like so: `Insert(FISHERMAN, ...)`
-	// - Use general purpose parameter methods such as `Set(enum_gov_type, ...)` such as `Set(STAKING_ADJUSTMENT, ...)`
+
 	// Context Operations
 	NewSavePoint([]byte) error
 	RollbackToSavePoint([]byte) error
 
-	Commit() error
 	// DISCUSS: Can we consolidate `Reset` and `Release`
 	Reset() error
 	Release() error
 
-	// Question:
-
+	// Block / indexer operations
 	UpdateAppHash() ([]byte, error)
-	AppHash() ([]byte, error)
-
-	// Block Operations
-
-	// Indexer Operations
-	StoreTransaction(transactionProtoBytes []byte) error                                         // Stores a transaction
-	CommitTransactions(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error // Writes the block in the SQL database
+	// Commits the current context (height, hash, transactions, etc...) to finality.
+	Commit(quorumCert []byte) error
+	// Indexes the transaction
+	StoreTransaction(transactionProtoBytes []byte) error // Stores a transaction
 
 	// Pool Operations
 	AddPoolAmount(name string, amount string) error
diff --git a/shared/modules/utility_module.go b/shared/modules/utility_module.go
index 8472e4582..5dbf9f887 100644
--- a/shared/modules/utility_module.go
+++ b/shared/modules/utility_module.go
@@ -21,8 +21,8 @@ type UtilityContext interface {
 	ApplyBlock(height int64, proposer []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) (appHash []byte, err error)
 
 	// Context operations
-	ReleaseContext()
-	CommitContext() error
+	ReleaseContext() error
+	CommitContext(quorumCert []byte) error
 
 	// Validation operations
 	CheckTransaction(tx []byte) error
diff --git a/utility/block.go b/utility/block.go
index ef2ab2894..324ee78a8 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -34,6 +34,8 @@ var (
 
 func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) ([]byte, error) {
 	u.LatestHeight = latestHeight
+	u.CurrentProposer = proposerAddress
+
 	// begin block lifecycle phase
 	if err := u.BeginBlock(lastBlockByzantineValidators); err != nil {
 		return nil, err
@@ -55,8 +57,8 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 			return nil, err
 		}
 
-		// TODO: if found, remove transaction from mempool
 		// DISCUSS: What if the context is rolled back or cancelled. Do we add it back to the mempool?
+		// TODO: if found, remove transaction from mempool
 		// if err := u.Mempool.DeleteTransaction(transaction); err != nil {
 		// 	return nil, err
 		// }
@@ -67,8 +69,14 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 		return nil, err
 	}
 
+	// TODO: What if everything above succeeded but updating the app hash failed?
+	appHash, err := u.Context.UpdateAppHash()
+	if err != nil {
+		return nil, typesUtil.ErrAppHash(err)
+	}
+
 	// return the app hash; consensus module will get the validator set directly
-	return u.GetAppHash()
+	return appHash, nil
 }
 
 func (u *UtilityContext) BeginBlock(previousBlockByzantineValidators [][]byte) typesUtil.Error {
@@ -91,21 +99,9 @@ func (u *UtilityContext) EndBlock(proposer []byte) typesUtil.Error {
 	if err := u.BeginUnstakingMaxPaused(); err != nil {
 		return err
 	}
-	if _, err := u.Context.UpdateAppHash(); err != nil {
-		return typesUtil.ErrAppHash(err)
-	}
 	return nil
 }
 
-func (u *UtilityContext) GetAppHash() ([]byte, typesUtil.Error) {
-	// Get the root hash of the merkle state tree for state consensus integrity
-	appHash, er := u.Context.AppHash()
-	if er != nil {
-		return nil, typesUtil.ErrAppHash(er)
-	}
-	return appHash, nil
-}
-
 // HandleByzantineValidators handles the validators who either didn't sign at all or disagreed with the 2/3+ majority
 func (u *UtilityContext) HandleByzantineValidators(lastBlockByzantineValidators [][]byte) typesUtil.Error {
 	latestBlockHeight, err := u.GetLatestHeight()
@@ -289,14 +285,3 @@ func (u *UtilityContext) SetValidatorMissedBlocks(address []byte, missedBlocks i
 	}
 	return nil
 }
-
-func (u *UtilityContext) StoreBlock(blockProtoBytes []byte) error {
-	// store := u.Store()
-
-	// Store in KV Store
-	// if err := store.StoreBlock(blockProtoBytes); err != nil {
-	// 	return err
-	// }
-
-	return nil
-}
diff --git a/utility/context.go b/utility/context.go
index 37f26d637..3541bb4e8 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -9,13 +9,16 @@ import (
 )
 
 type UtilityContext struct {
-	LatestHeight int64
-	Mempool      typesUtil.Mempool
-	Context      *Context // IMPROVE: Consider renmaming to PersistenceContext
+	LatestHeight    int64 // IMPROVE: Current height?
+	CurrentProposer []byte
+
+	Mempool typesUtil.Mempool
+	Context *Context // IMPROVE: Consider renaming to `PersistenceContext` or `StoreContext`
 }
 
 type Context struct {
 	modules.PersistenceRWContext
+	// TODO: SavePoints have not been implemented yet
 	SavePointsM map[string]struct{}
 	SavePoints  [][]byte
 }
@@ -40,15 +43,16 @@ func (u *UtilityContext) Store() *Context {
 	return u.Context
 }
 
-func (u *UtilityContext) CommitContext() error {
-	err := u.Context.PersistenceRWContext.Commit()
+func (u *UtilityContext) CommitContext(quorumCert []byte) error {
+	err := u.Context.PersistenceRWContext.Commit(quorumCert)
 	u.Context = nil
 	return err
 }
 
-func (u *UtilityContext) ReleaseContext() {
-	u.Context.Release()
+func (u *UtilityContext) ReleaseContext() error {
+	err := u.Context.Release()
 	u.Context = nil
+	return err
 }
 
 func (u *UtilityContext) GetLatestHeight() (int64, typesUtil.Error) {
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index c1441e405..f4a1420e9 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -3,12 +3,13 @@ package test
 import (
 	"encoding/hex"
 	"fmt"
-	"github.com/pokt-network/pocket/shared/modules"
-	"github.com/pokt-network/pocket/shared/test_artifacts"
 	"math"
 	"math/big"
 	"testing"
 
+	"github.com/pokt-network/pocket/shared/modules"
+	"github.com/pokt-network/pocket/shared/test_artifacts"
+
 	typesUtil "github.com/pokt-network/pocket/utility/types"
 	"github.com/stretchr/testify/require"
 )
@@ -172,19 +173,6 @@ func TestUtilityContext_EndBlock(t *testing.T) {
 	test_artifacts.CleanupTest(ctx)
 }
 
-func TestUtilityContext_GetAppHash(t *testing.T) {
-	ctx := NewTestingUtilityContext(t, 0)
-
-	appHashTest, err := ctx.GetAppHash()
-	require.NoError(t, err)
-
-	appHashSource, er := ctx.Context.AppHash()
-	require.NoError(t, er)
-	require.Equal(t, appHashSource, appHashTest, "unexpected appHash")
-
-	test_artifacts.CleanupTest(ctx)
-}
-
 func TestUtilityContext_UnstakeValidatorsActorsThatAreReady(t *testing.T) {
 	for _, actorType := range typesUtil.ActorTypes {
 		ctx := NewTestingUtilityContext(t, 1)

From 1507de341ddb1a584c895bb3fc69009ad4d59ca1 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sat, 24 Sep 2022 13:35:15 -0700
Subject: [PATCH 019/227] Added a persistence block proto type

---
 persistence/StateHash.md        | 15 +++++++++++++++
 persistence/block.go            | 29 +++++++++++++++++++++++------
 persistence/context.go          |  2 +-
 persistence/proto/block.proto   | 13 +++++++++++++
 persistence/state.go            |  3 +--
 persistence/types/base_actor.go |  1 +
 6 files changed, 54 insertions(+), 9 deletions(-)
 create mode 100644 persistence/proto/block.proto

diff --git a/persistence/StateHash.md b/persistence/StateHash.md
index a930df4fc..bd455f42e 100644
--- a/persistence/StateHash.md
+++ b/persistence/StateHash.md
@@ -1,3 +1,18 @@
+Remaining tasks:
+
+1.  Simplify interfaces in utility & persistence (make it simple and clear)
+2.  How do we revert changes to the merkle trees?
+3.  Draw an end-to-end diagram of everything and the data flow
+
+## References:
+
+- https://github.com/cosmos/cosmos-sdk/discussions/9158
+- https://github.com/cosmos/cosmos-sdk/pull/8012
+- https://github.com/cosmos/cosmos-sdk/discussions/8297
+- https://github.com/cosmos/cosmos-sdk/discussions/8297
+- https://paper.dropbox.com/doc/State-commitments-and-storage-review--BpuF08OSksSkLeErjf66jrOAAg-wKl2RINZWD9I0DUmZIFwQ
+- https://arxiv.org/pdf/1803.05069.pdf
+
 # This discussion is aimed at:
 
 1. Defining how we should compute the state hash
diff --git a/persistence/block.go b/persistence/block.go
index af9a797da..5409597ec 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -5,6 +5,7 @@ import (
 	"encoding/hex"
 	"log"
 
+	"github.com/gogo/protobuf/proto"
 	"github.com/pokt-network/pocket/persistence/types"
 )
 
@@ -66,10 +67,26 @@ func heightToBytes(height int64) []byte {
 	return heightBytes
 }
 
-func (p PostgresContext) commitBlock(blockProtoBytes []byte) error {
-	// get current height
-	// get proposer
-	// get hash
-	// get transaction
-	return p.DB.Blockstore.Put(heightToBytes(p.Height), blockProtoBytes)
+func (p PostgresContext) storeBlock(quorumCert []byte) error {
+	prevHash, err := p.GetBlockHash(p.Height - 1)
+	if err != nil {
+		return err
+	}
+
+	block := types.Block{
+		Height:            uint64(p.Height),
+		Hash:              string(p.stateHash),
+		PrevHash:          string(prevHash),
+		ProposerAddress:   []byte("proposer"), // TODO: How should utility context forward this?
+		QuorumCertificate: quorumCert,
+		Transactions:      nil, // TODO: get this from what was stored via `StoreTransaction`
+
+	}
+
+	blockBz, err := proto.Marshal(&block)
+	if err != nil {
+		return err
+	}
+
+	return p.DB.Blockstore.Put(heightToBytes(p.Height), blockBz)
 }
diff --git a/persistence/context.go b/persistence/context.go
index 35e7ba108..9ca2e7f86 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -30,7 +30,7 @@ func (p PostgresContext) Commit(quorumCert []byte) error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
 	ctx := context.TODO()
-	if err := p.DB.Tx.Commit(context.TODO()); err != nil {
+	if err := p.DB.Tx.Commit(ctx); err != nil {
 		return err
 	}
 	if err := p.DB.conn.Close(ctx); err != nil {
diff --git a/persistence/proto/block.proto b/persistence/proto/block.proto
new file mode 100644
index 000000000..0c314690d
--- /dev/null
+++ b/persistence/proto/block.proto
@@ -0,0 +1,13 @@
+syntax = "proto3";
+package persistence;
+
+option go_package = "github.com/pokt-network/pocket/persistence/types";
+
+message Block {
+    uint64 height = 1;
+    string hash = 2;
+    string prevHash = 3;
+    bytes proposerAddress = 4;
+    bytes quorumCertificate = 5;
+    repeated bytes transactions = 6;
+}
\ No newline at end of file
diff --git a/persistence/state.go b/persistence/state.go
index d689410ee..88a053138 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -51,7 +51,6 @@ func loadMerkleTrees(map[MerkleTree]*smt.SparseMerkleTree, error) {
 	log.Fatalf("loadMerkleTrees not implemented yet")
 }
 
-// Question: Is this the right approach?
 func (p *PostgresContext) updateStateHash() error {
 	// Update all the merkle trees
 	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
@@ -76,7 +75,7 @@ func (p *PostgresContext) updateStateHash() error {
 					return err
 				}
 			}
-		// TODO_IN_THIS_COMMIT: re
+		// TODO_IN_THIS_COMMIT: add support for all the other actors as well
 		default:
 			log.Fatalln("Not handled yet in state commitment update", treeType)
 		}
diff --git a/persistence/types/base_actor.go b/persistence/types/base_actor.go
index 054d10393..1c73da9a7 100644
--- a/persistence/types/base_actor.go
+++ b/persistence/types/base_actor.go
@@ -1,5 +1,6 @@
 package types
 
+// IMPROVE: Move schema related functions to a separate sub-package
 import "github.com/pokt-network/pocket/shared/modules"
 
 // TECHDEBT: Consider moving this to a protobuf. This struct was created to make testing simple of protocol actors that

From f3fe3dfed05304362c5f5b49c4bd67f6a46d9419 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sun, 25 Sep 2022 17:28:19 -0700
Subject: [PATCH 020/227] Rename block persistence proto name

---
 go.mod                                                     | 2 +-
 persistence/proto/{block.proto => block_persistence.proto} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename persistence/proto/{block.proto => block_persistence.proto} (100%)

diff --git a/go.mod b/go.mod
index 6e76ac253..f83ae8336 100644
--- a/go.mod
+++ b/go.mod
@@ -38,7 +38,7 @@ require (
 	github.com/docker/go-connections v0.4.0 // indirect
 	github.com/docker/go-units v0.4.0 // indirect
 	github.com/dustin/go-humanize v1.0.0 // indirect
-	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/gogo/protobuf v1.3.2
 	github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b // indirect
 	github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
diff --git a/persistence/proto/block.proto b/persistence/proto/block_persistence.proto
similarity index 100%
rename from persistence/proto/block.proto
rename to persistence/proto/block_persistence.proto

From 21448113eac5a145369e6fa2e99f65a6eb642f12 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sun, 25 Sep 2022 19:39:17 -0700
Subject: [PATCH 021/227] Rough non-functional completion of merkle tree flow

---
 consensus/consensus_tests/utils_test.go |   8 --
 consensus/hotstuff_handler.go           |   6 +-
 consensus/hotstuff_leader.go            |   3 +-
 persistence/StateHash.md                | 107 ++++++++++++++++++++++++
 persistence/block.go                    |  42 ++++++----
 persistence/context.go                  |  15 +++-
 persistence/debug.go                    |   2 +-
 persistence/genesis.go                  |   2 +-
 persistence/state.go                    |  20 ++++-
 persistence/test/module_test.go         |   3 +-
 shared/modules/consensus_module.go      |   7 +-
 shared/modules/persistence_module.go    |   5 +-
 utility/context.go                      |  13 +--
 13 files changed, 188 insertions(+), 45 deletions(-)

diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 7f12277a2..ff716ce2c 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -358,7 +358,6 @@ func baseUtilityMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockUti
 func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 	ctrl := gomock.NewController(t)
 	utilityContextMock := modulesMock.NewMockUtilityContext(ctrl)
-	// persistenceContextMock := basePersistenceContextMock(t)
 
 	utilityContextMock.EXPECT().
 		GetProposalTransactions(gomock.Any(), maxTxBytes, gomock.AssignableToTypeOf(emptyByzValidators)).
@@ -374,13 +373,6 @@ func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 	return utilityContextMock
 }
 
-// func basePersistenceContextMock(t *testing.T) *modulesMock.MockPersistenceRWContext {
-// 	ctrl := gomock.NewController(t)
-// 	persistenceContextMock := modulesMock.NewMockPersistenceRWContext(ctrl)
-// 	persistenceContextMock.EXPECT().Commit(gomock.Any()).Return(nil).AnyTimes()
-// 	return persistenceContextMock
-// }
-
 func baseTelemetryMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockTelemetryModule {
 	ctrl := gomock.NewController(t)
 	telemetryMock := modulesMock.NewMockTelemetryModule(ctrl)
diff --git a/consensus/hotstuff_handler.go b/consensus/hotstuff_handler.go
index aa72b3a26..90b7b3b29 100644
--- a/consensus/hotstuff_handler.go
+++ b/consensus/hotstuff_handler.go
@@ -17,7 +17,8 @@ func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage)
 	m.nodeLog(typesCons.DebugHandlingHotstuffMessage(msg))
 
 	step := msg.GetStep()
-	// Liveness & safety checks
+
+	// Pacemaker - Liveness & safety checks
 	if err := m.paceMaker.ValidateMessage(msg); err != nil {
 		// If a replica is not a leader for this round, but has already determined a leader,
 		// and continues to receive NewRound messages, we avoid logging the "message discard"
@@ -28,13 +29,14 @@ func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage)
 		return err
 	}
 
-	// Need to execute leader election if there is no leader and we are in a new round.
+	// Leader Election - Need to execute leader election if there is no leader and we are in a new round.
 	if m.Step == NewRound && m.LeaderId == nil {
 		if err := m.electNextLeader(msg); err != nil {
 			return err
 		}
 	}
 
+	// Hotstuff - Handle message
 	if m.isReplica() {
 		replicaHandlers[step](m, msg)
 	}
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index f87c5f58b..7529c5e53 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -337,7 +337,8 @@ func (m *ConsensusModule) prepareAndApplyBlock() (*typesCons.Block, error) {
 		return nil, err
 	}
 
-	// Apply all the transactions in the block -
+	// OPTIMIZE: Determine if we can avoid the `ApplyBlock` call here
+	// Apply all the transactions in the block
 	appHash, err := m.UtilityContext.ApplyBlock(int64(m.Height), m.privateKey.Address(), txs, lastByzValidators)
 	if err != nil {
 		return nil, err
diff --git a/persistence/StateHash.md b/persistence/StateHash.md
index bd455f42e..cfc54af52 100644
--- a/persistence/StateHash.md
+++ b/persistence/StateHash.md
@@ -13,6 +13,11 @@ Remaining tasks:
 - https://paper.dropbox.com/doc/State-commitments-and-storage-review--BpuF08OSksSkLeErjf66jrOAAg-wKl2RINZWD9I0DUmZIFwQ
 - https://arxiv.org/pdf/1803.05069.pdf
 
+## Open questions:
+
+1. Review flows
+2. How do we revert changes to the merkle trees?
+
 # This discussion is aimed at:
 
 1. Defining how we should compute the state hash
@@ -85,3 +90,105 @@ Learnings / Ideas:
 
 - Consolidate `UtilActorType` and `persistence.ActorType`
 - `modules.Actors` interface vs `types.Actor` in persistenceGenesis
+
+### Context Initialization
+
+```mermaid
+sequenceDiagram
+    %% autonumber
+    participant N as Node
+    participant C as Consensus
+    participant U as Utility
+    participant P as Persistence
+    participant PP as Persistence (PostgresDB)
+    participant PM as Persistence (MerkleTree)
+    participant P2P as P2P
+
+    %% Should this be P2P?
+    N-->>C: HandleMessage(anypb.Any)
+    critical NewRound Message
+        C->>+U: NewContext(height)
+        U->>P: NewRWContext(height)
+        P->>U: PersistenceRWContext
+        U->>U: Store persistenceContext
+        U->>-C: UtilityContext
+        C->>C: Store utilityContext
+        Note over C, PM: See 'Block Application'
+    end
+    Note over N, P2P: Hotstuff lifecycle
+    N-->>C: HandleMessage(anypb.Any)
+    critical Decide Message
+        Note over C, PM: See 'Block Commit'
+    end
+```
+
+### Block Application
+
+```mermaid
+sequenceDiagram
+    participant C as Consensus
+    participant U as Utility
+    participant P as Persistence
+    participant PP as Persistence (PostgresDB)
+    participant PM as Persistence (MerkleTree)
+
+    alt as leader
+        C->>+U: GetProposalTransactions(proposer, maxTxBz, [lastVal])
+        U->>U: reap mempool
+        U->>-C: txs
+        Note over C, U: Perform replica behaviour
+    else as replica
+        C->>+U: ApplyBlock(height, proposer, txs, lastVals)
+        loop Update DB: for each operation in tx
+            U->>P: ReadOp | WriteOp
+            P->>PP: ReadOp | WriteOp
+            PP->>P: data | ok
+            P->>U: data | ok
+            U->>U: validate
+            U->>P: StoreTransaction(tx)
+            P->>P: store locally
+            P->>U: ok
+        end
+        U->>+P: UpdateAppHash()
+        loop for each protocol actor type
+            P->>PP: GetActorsUpdate(height)
+            PP->>P: actors
+            loop Update Tree: for each actor
+                P->>PM: Update(addr, serialized(actor))
+                PM->>P: ok
+            end
+            P->>PM: GetRoot()
+            PM->>P: rootHash
+        end
+        P->>P: computeStateHash(rootHashes)
+        P->>-U: stateHash
+        U->>-C: hash
+    end
+```
+
+### Block Commit
+
+```mermaid
+sequenceDiagram
+    %% autonumber
+    participant C as Consensus
+    participant U as Utility
+    participant P as Persistence
+    participant PP as Persistence (PostgresDB)
+    participant PK as Persistence (Key-Value Store)
+
+    C->>U: CommitContext(quorumCert)
+    U->>P: Commit(proposerAddr, quorumCert)
+    P->>P: create typesPer.Block
+    P->>PP: insertBlock(block)
+    PP->>P: ok
+    P->>PK: Put(height, block)
+    PK->>P: ok
+    P->>P: commit tx
+    P->>U: ok
+    U->>P: Release()
+    P->>U: ok
+    C->>U: Release()
+    U->>C: ok
+    C->>C: release utilityContext
+```
diff --git a/persistence/block.go b/persistence/block.go
index 5409597ec..8c035edfb 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -50,43 +50,49 @@ func (p PostgresContext) StoreTransaction(transactionProtoBytes []byte) error {
 	return nil
 }
 
-func (p PostgresContext) InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error {
+func (p PostgresContext) insertBlock(block *types.Block) error {
 	ctx, tx, err := p.DB.GetCtxAndTxn()
 	if err != nil {
 		return err
 	}
 
-	_, err = tx.Exec(ctx, types.InsertBlockQuery(height, hash, proposerAddr, quorumCert))
+	_, err = tx.Exec(ctx, types.InsertBlockQuery(block.Height, block.Hash, block.ProposerAddress, block.QuorumCertificate))
 	return err
 }
 
-// CLEANUP: Should this be moved to a shared directory?
-func heightToBytes(height int64) []byte {
-	heightBytes := make([]byte, 8)
-	binary.LittleEndian.PutUint64(heightBytes, uint64(height))
-	return heightBytes
+func (p PostgresContext) storeBlock(block *types.Block) error {
+	blockBz, err := proto.Marshal(block)
+	if err != nil {
+		return err
+	}
+
+	return p.DB.Blockstore.Put(heightToBytes(p.Height), blockBz)
 }
 
-func (p PostgresContext) storeBlock(quorumCert []byte) error {
+func (p PostgresContext) getBlock(proposerAddr []byte, quorumCert []byte) (*types.Block, error) {
 	prevHash, err := p.GetBlockHash(p.Height - 1)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	block := types.Block{
+	// TODO: get this from the transactions that were store via `StoreTransaction`
+	txs := make([][]byte, 0)
+
+	block := &types.Block{
 		Height:            uint64(p.Height),
 		Hash:              string(p.stateHash),
 		PrevHash:          string(prevHash),
-		ProposerAddress:   []byte("proposer"), // TODO: How should utility context forward this?
+		ProposerAddress:   proposerAddr,
 		QuorumCertificate: quorumCert,
-		Transactions:      nil, // TODO: get this from what was stored via `StoreTransaction`
-
+		Transactions:      txs,
 	}
 
-	blockBz, err := proto.Marshal(&block)
-	if err != nil {
-		return err
-	}
+	return block, nil
+}
 
-	return p.DB.Blockstore.Put(heightToBytes(p.Height), blockBz)
+// CLEANUP: Should this be moved to a shared directory?
+func heightToBytes(height int64) []byte {
+	heightBytes := make([]byte, 8)
+	binary.LittleEndian.PutUint64(heightBytes, uint64(height))
+	return heightBytes
 }
diff --git a/persistence/context.go b/persistence/context.go
index 9ca2e7f86..95a54702e 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -26,9 +26,22 @@ func (p PostgresContext) Reset() error {
 	panic("TODO: PostgresContext Reset not implemented")
 }
 
-func (p PostgresContext) Commit(quorumCert []byte) error {
+func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
+	block, err := p.getBlock(proposerAddr, quorumCert)
+	if err != nil {
+		return err
+	}
+
+	if err := p.insertBlock(block); err != nil {
+		return err
+	}
+
+	if err := p.storeBlock(block); err != nil {
+		return err
+	}
+
 	ctx := context.TODO()
 	if err := p.DB.Tx.Commit(ctx); err != nil {
 		return err
diff --git a/persistence/debug.go b/persistence/debug.go
index 14fc5c704..e0e3b6e5e 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -44,7 +44,7 @@ func (m *PersistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 
 func (m *PersistenceModule) clearState(_ *debug.DebugMessage) {
 	context, err := m.NewRWContext(-1)
-	defer context.Commit(nil)
+	defer context.Commit(nil, nil)
 	if err != nil {
 		log.Printf("Error creating new context: %s \n", err)
 		return
diff --git a/persistence/genesis.go b/persistence/genesis.go
index 329cdbfa4..feb8dc9b5 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -149,7 +149,7 @@ func (m *PersistenceModule) populateGenesisState(state *types.PersistenceGenesis
 		log.Fatalf("an error occurred initializing flags: %s", err.Error())
 	}
 
-	if err = rwContext.Commit(nil); err != nil {
+	if err = rwContext.Commit(nil, nil); err != nil {
 		log.Fatalf("an error occurred during commit() on genesis state %s ", err.Error())
 	}
 }
diff --git a/persistence/state.go b/persistence/state.go
index 88a053138..5c3913140 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"crypto/sha256"
 	"encoding/hex"
+	"fmt"
 	"log"
 	"sort"
 
@@ -75,7 +76,24 @@ func (p *PostgresContext) updateStateHash() error {
 					return err
 				}
 			}
-		// TODO_IN_THIS_COMMIT: add support for all the other actors as well
+		case valMerkleTree:
+			fmt.Println("TODO: valMerkleTree not implemented")
+		case fishMerkleTree:
+			fmt.Println("TODO: fishMerkleTree not implemented")
+		case serviceNodeMerkleTree:
+			fmt.Println("TODO: serviceNodeMerkleTree not implemented")
+		case accountMerkleTree:
+			fmt.Println("TODO: accountMerkleTree not implemented")
+		case poolMerkleTree:
+			fmt.Println("TODO: poolMerkleTree not implemented")
+		case blocksMerkleTree:
+			// VERY VERY IMPORTANT DISCUSSION: What do we do here provided that `Commit`, which stores the block in the DB and tree
+			//                                 requires the quorumCert, which we receive at the very end of hotstuff consensus
+			fmt.Println("TODO: blocksMerkleTree not implemented")
+		case paramsMerkleTree:
+			fmt.Println("TODO: paramsMerkleTree not implemented")
+		case flagsMerkleTree:
+			fmt.Println("TODO: flagsMerkleTree not implemented")
 		default:
 			log.Fatalln("Not handled yet in state commitment update", treeType)
 		}
diff --git a/persistence/test/module_test.go b/persistence/test/module_test.go
index f5df476b0..ccb7bd37f 100644
--- a/persistence/test/module_test.go
+++ b/persistence/test/module_test.go
@@ -18,13 +18,14 @@ func TestPersistenceContextParallelReadWrite(t *testing.T) {
 	poolAddress := []byte("address")
 	originalAmount := "15"
 	modifiedAmount := "10"
+	proposer := []byte("proposer")
 	quorumCert := []byte("quorumCert")
 
 	// setup a write context, insert a pool and commit it
 	context, err := testPersistenceMod.NewRWContext(0)
 	require.NoError(t, err)
 	require.NoError(t, context.InsertPool(poolName, poolAddress, originalAmount))
-	require.NoError(t, context.Commit(quorumCert))
+	require.NoError(t, context.Commit(proposer, quorumCert))
 
 	// verify the insert in the previously committed context worked
 	contextA, err := testPersistenceMod.NewRWContext(0)
diff --git a/shared/modules/consensus_module.go b/shared/modules/consensus_module.go
index cd05f73ec..044b2a3bd 100644
--- a/shared/modules/consensus_module.go
+++ b/shared/modules/consensus_module.go
@@ -7,16 +7,17 @@ import (
 	"google.golang.org/protobuf/types/known/anypb"
 )
 
-type ValidatorMap map[string]Actor // TODO (Drewsky) deprecate Validator map or populate from persistence module
+// TODO(olshansky): deprecate ValidatorMap or populate from persistence module
+type ValidatorMap map[string]Actor
 
 type ConsensusModule interface {
 	Module
 
-	// Consensus Engine
+	// Consensus Engine Handlers
 	HandleMessage(*anypb.Any) error
 	HandleDebugMessage(*debug.DebugMessage) error
 
-	// Consensus State
+	// Consensus State Accessors
 	CurrentHeight() uint64
 	AppHash() string            // DISCUSS: Why not call this a BlockHash or StateHash? Should it be a []byte or string?
 	ValidatorMap() ValidatorMap // TODO: This needs to be dynamically updated during various operations and network changes.
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index 4da6fb211..a4a587bb9 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -9,6 +9,8 @@ import (
 
 type PersistenceModule interface {
 	Module
+
+	// Persistence Context Factory Methods
 	NewRWContext(height int64) (PersistenceRWContext, error)
 	NewReadContext(height int64) (PersistenceReadContext, error)
 
@@ -46,7 +48,6 @@ type PersistenceRWContext interface {
 // but it abstracts and contrasts nicely against the read only context
 // TODO (andrew) convert address and public key to string not bytes #149
 type PersistenceWriteContext interface {
-
 	// Context Operations
 	NewSavePoint([]byte) error
 	RollbackToSavePoint([]byte) error
@@ -58,7 +59,7 @@ type PersistenceWriteContext interface {
 	// Block / indexer operations
 	UpdateAppHash() ([]byte, error)
 	// Commits the current context (height, hash, transactions, etc...) to finality.
-	Commit(quorumCert []byte) error
+	Commit(proposerAddr []byte, quorumCert []byte) error
 	// Indexes the transaction
 	StoreTransaction(transactionProtoBytes []byte) error // Stores a transaction
 
diff --git a/utility/context.go b/utility/context.go
index 3541bb4e8..b0ca4bebc 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -9,16 +9,17 @@ import (
 )
 
 type UtilityContext struct {
-	LatestHeight    int64 // IMPROVE: Current height?
+	LatestHeight    int64 // IMPROVE: Rename to `currentHeight?`
 	CurrentProposer []byte
 
 	Mempool typesUtil.Mempool
-	Context *Context // IMPROVE: Consider renaming to `PersistenceContext` or `StoreContext`
+	Context *Context // IMPROVE: Rename to `persistenceContext` or `storeContext` or `reversibleContext`?
 }
 
-type Context struct {
+type Context struct { // IMPROVE: Rename to `persistenceContext` or `storeContext`?
+	// TODO: Since `Context` embeds `PersistenceRWContext`, we don't need to do `u.Context.PersistenceRWContext`, but can call `u.Context` directly
 	modules.PersistenceRWContext
-	// TODO: SavePoints have not been implemented yet
+	// TODO/DISCUSS: `SavePoints`` have not been implemented yet
 	SavePointsM map[string]struct{}
 	SavePoints  [][]byte
 }
@@ -44,8 +45,8 @@ func (u *UtilityContext) Store() *Context {
 }
 
 func (u *UtilityContext) CommitContext(quorumCert []byte) error {
-	err := u.Context.PersistenceRWContext.Commit(quorumCert)
-	u.Context = nil
+	err := u.Context.PersistenceRWContext.Commit(u.CurrentProposer, quorumCert)
+	u.Context = nil // DISCUSS: Should we release the context if there was an error here?
 	return err
 }
 

From d9a1cf5bd52b107982866096cb901c64d87d9c84 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 26 Sep 2022 13:51:55 -0700
Subject: [PATCH 022/227] Remove test_persistence_state_hash

---
 Makefile | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/Makefile b/Makefile
index 887652723..b174229b8 100644
--- a/Makefile
+++ b/Makefile
@@ -302,11 +302,6 @@ test_sortition:
 test_persistence:
 	go test ${VERBOSE_TEST} -p=1 -count=1 ./persistence/...
 
-.PHONY: test_persistence_state_hash
-## Run all go unit tests in the Persistence module
-test_persistence_state_hash:
-	go test -run StateHash ${VERBOSE_TEST} -p=1 ./persistence/...
-
 .PHONY: test_p2p_types
 ## Run p2p subcomponents' tests
 test_p2p_types:

From 798ea1f6904eb1148d05fdab47013b46a6b3b395 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 26 Sep 2022 14:04:48 -0700
Subject: [PATCH 023/227] Removed explicit MaxBlockBytes variable

---
 consensus/block.go                 | 37 +++++++++++++++---------------
 consensus/module.go                | 19 ++++++++-------
 shared/test_artifacts/generator.go |  5 ++--
 3 files changed, 31 insertions(+), 30 deletions(-)

diff --git a/consensus/block.go b/consensus/block.go
index 48c452b2e..0f43a47e5 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -7,7 +7,23 @@ import (
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
 
-// TODO: Add additional basic block metadata validation w/ unit tests
+func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
+	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
+
+	// Commit the utility context
+	if err := m.UtilityContext.CommitContext(block.BlockHeader.QuorumCertificate); err != nil {
+		return err
+	}
+	// Release the utility context
+	m.UtilityContext.ReleaseContext()
+	m.UtilityContext = nil
+	// Update the last app hash
+	m.lastAppHash = block.BlockHeader.Hash
+
+	return nil
+}
+
+// TODO: Add unit tests specific to block validation
 func (m *ConsensusModule) validateBlockBasic(block *typesCons.Block) error {
 	if block == nil && m.Step != NewRound {
 		return typesCons.ErrNilBlock
@@ -17,8 +33,8 @@ func (m *ConsensusModule) validateBlockBasic(block *typesCons.Block) error {
 		return typesCons.ErrBlockExists
 	}
 
-	if unsafe.Sizeof(*block) > uintptr(m.MaxBlockBytes) {
-		return typesCons.ErrInvalidBlockSize(uint64(unsafe.Sizeof(*block)), m.MaxBlockBytes)
+	if unsafe.Sizeof(*block) > uintptr(m.consGenesis.MaxBlockBytes) {
+		return typesCons.ErrInvalidBlockSize(uint64(unsafe.Sizeof(*block)), m.consGenesis.MaxBlockBytes)
 	}
 
 	// If the current block being processed (i.e. voted on) by consensus is non nil, we need to make
@@ -56,18 +72,3 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 	m.UtilityContext = utilityContext
 	return nil
 }
-
-func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
-	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
-
-	// Commit and release the context
-	if err := m.UtilityContext.CommitContext(block.BlockHeader.QuorumCertificate); err != nil {
-		return err
-	}
-	m.UtilityContext.ReleaseContext()
-	m.UtilityContext = nil
-
-	m.lastAppHash = block.BlockHeader.Hash
-
-	return nil
-}
diff --git a/consensus/module.go b/consensus/module.go
index 68e3874cc..f49e4a97e 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -31,7 +31,9 @@ var _ modules.ConsensusModule = &ConsensusModule{}
 type ConsensusModule struct {
 	bus        modules.Bus
 	privateKey cryptoPocket.Ed25519PrivateKey
-	consCfg    modules.ConsensusConfig
+
+	consCfg     *typesCons.ConsensusConfig
+	consGenesis *typesCons.ConsensusGenesisState
 
 	// Hotstuff
 	Height uint64
@@ -49,7 +51,7 @@ type ConsensusModule struct {
 	IdToValAddrMap typesCons.IdToValAddrMap // TODO: This needs to be updated every time the ValMap is modified
 
 	// Consensus State
-	lastAppHash  string // TODO: Need to make sure this is populated and updated correctly
+	lastAppHash  string // TODO: Always retrieve this variable from the persistence module and simplify this struct
 	validatorMap typesCons.ValidatorMap
 
 	// Module Dependencies
@@ -62,9 +64,6 @@ type ConsensusModule struct {
 
 	// TECHDEBT: Move this over to use the txIndexer
 	MessagePool map[typesCons.HotstuffStep][]*typesCons.HotstuffMessage
-
-	// CLEANUP: Access this value from the configs
-	MaxBlockBytes uint64
 }
 
 func Create(configPath, genesisPath string, useRandomPK bool) (modules.ConsensusModule, error) {
@@ -106,8 +105,9 @@ func Create(configPath, genesisPath string, useRandomPK bool) (modules.Consensus
 	m := &ConsensusModule{
 		bus: nil,
 
-		privateKey: privateKey.(cryptoPocket.Ed25519PrivateKey),
-		consCfg:    cfg,
+		privateKey:  privateKey.(cryptoPocket.Ed25519PrivateKey),
+		consCfg:     cfg,
+		consGenesis: genesis,
 
 		Height: 0,
 		Round:  0,
@@ -129,9 +129,8 @@ func Create(configPath, genesisPath string, useRandomPK bool) (modules.Consensus
 		paceMaker:         paceMaker,
 		leaderElectionMod: leaderElectionMod,
 
-		logPrefix:     DefaultLogPrefix,
-		MessagePool:   make(map[typesCons.HotstuffStep][]*typesCons.HotstuffMessage),
-		MaxBlockBytes: genesis.GetMaxBlockBytes(),
+		logPrefix:   DefaultLogPrefix,
+		MessagePool: make(map[typesCons.HotstuffStep][]*typesCons.HotstuffMessage),
 	}
 
 	// TODO(olshansky): Look for a way to avoid doing this.
diff --git a/shared/test_artifacts/generator.go b/shared/test_artifacts/generator.go
index 912e9fe2b..f89c68188 100644
--- a/shared/test_artifacts/generator.go
+++ b/shared/test_artifacts/generator.go
@@ -2,11 +2,12 @@ package test_artifacts
 
 import (
 	"fmt"
+	"math/big"
+	"strconv"
+
 	typesPersistence "github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 	"github.com/pokt-network/pocket/utility/types"
-	"math/big"
-	"strconv"
 
 	"github.com/pokt-network/pocket/shared/crypto"
 	"google.golang.org/protobuf/types/known/timestamppb"

From 7cdc00838fa50ff12da7f6636288d8e391fb6c09 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 26 Sep 2022 14:07:19 -0700
Subject: [PATCH 024/227] Update block.go

---
 consensus/block.go | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/consensus/block.go b/consensus/block.go
index 0f43a47e5..0ce2851e6 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -33,7 +33,7 @@ func (m *ConsensusModule) validateBlockBasic(block *typesCons.Block) error {
 		return typesCons.ErrBlockExists
 	}
 
-	if unsafe.Sizeof(*block) > uintptr(m.consGenesis.MaxBlockBytes) {
+	if block != nil && unsafe.Sizeof(*block) > uintptr(m.consGenesis.MaxBlockBytes) {
 		return typesCons.ErrInvalidBlockSize(uint64(unsafe.Sizeof(*block)), m.consGenesis.MaxBlockBytes)
 	}
 
@@ -41,7 +41,7 @@ func (m *ConsensusModule) validateBlockBasic(block *typesCons.Block) error {
 	// sure that the data (height, round, step, txs, etc) is the same before we start validating the signatures
 	if m.Block != nil {
 		// DISCUSS: The only difference between blocks from one step to another is the QC, so we need
-		// to determine where/how to validate this
+		//          to determine where/how to validate this
 		if protoHash(m.Block) != protoHash(block) {
 			log.Println("[TECHDEBT][ERROR] The block being processed is not the same as that received by the consensus module ")
 		}
@@ -52,9 +52,8 @@ func (m *ConsensusModule) validateBlockBasic(block *typesCons.Block) error {
 
 // Creates a new Utility context and clears/nullifies any previous contexts if they exist
 func (m *ConsensusModule) refreshUtilityContext() error {
-	// This is a catch-all to release the previous utility context if it wasn't cleaned up
-	// in the proper lifecycle (e.g. catch up, error, network partition, etc...). Ideally, this
-	// should not be called.
+	// Catch-all structure to release the previous utility context if it wasn't properly cleaned up.
+	// Ideally, this should not be called.
 	if m.UtilityContext != nil {
 		m.nodeLog(typesCons.NilUtilityContextWarning)
 		if err := m.UtilityContext.ReleaseContext(); err != nil {
@@ -68,7 +67,7 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 	if err != nil {
 		return err
 	}
-
 	m.UtilityContext = utilityContext
+
 	return nil
 }

From e4a63a8879c2af61d4deedadfbefe94a8b32bcea Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 26 Sep 2022 14:10:48 -0700
Subject: [PATCH 025/227] Fix typo in consensus proto

---
 consensus/helpers.go                       | 2 +-
 consensus/types/proto/hotstuff_types.proto | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/consensus/helpers.go b/consensus/helpers.go
index 63270826f..eab022ec4 100644
--- a/consensus/helpers.go
+++ b/consensus/helpers.go
@@ -26,7 +26,7 @@ const (
 	ByzantineThreshold = float64(2) / float64(3)
 	HotstuffMessage    = "consensus.HotstuffMessage"
 	UtilityMessage     = "consensus.UtilityMessage"
-	Propose            = typesCons.HotstuffMessageType_HOTSTUFF_MESAGE_PROPOSE
+	Propose            = typesCons.HotstuffMessageType_HOTSTUFF_MESSAGE_PROPOSE
 	Vote               = typesCons.HotstuffMessageType_HOTSTUFF_MESSAGE_VOTE
 )
 
diff --git a/consensus/types/proto/hotstuff_types.proto b/consensus/types/proto/hotstuff_types.proto
index b1f7c9b4d..c289694c8 100644
--- a/consensus/types/proto/hotstuff_types.proto
+++ b/consensus/types/proto/hotstuff_types.proto
@@ -18,7 +18,7 @@ enum HotstuffStep {
 
 enum HotstuffMessageType {
     HOTSTUFF_MESSAGE_UNKNOWN = 0;
-    HOTSTUFF_MESAGE_PROPOSE = 1;
+    HOTSTUFF_MESSAGE_PROPOSE = 1;
     HOTSTUFF_MESSAGE_VOTE = 2;
 }
 

From b2194685c6b0a220b04ee798d4e2980bbede7d6d Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 26 Sep 2022 14:16:29 -0700
Subject: [PATCH 026/227] Updated interface to findHighQC

---
 consensus/helpers.go         | 26 +++++++++++++-------------
 consensus/hotstuff_leader.go |  3 ++-
 2 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/consensus/helpers.go b/consensus/helpers.go
index eab022ec4..54a2491c6 100644
--- a/consensus/helpers.go
+++ b/consensus/helpers.go
@@ -1,5 +1,6 @@
 package consensus
 
+// TODO: Split this file into multiple helpers (e.g. signatures.go, hotstuff_helpers.go, etc...)
 import (
 	"encoding/base64"
 	"log"
@@ -15,7 +16,6 @@ import (
 
 // These constants and variables are wrappers around the autogenerated protobuf types and were
 // added to simply make the code in the `consensus` module more readable.
-
 const (
 	NewRound  = typesCons.HotstuffStep_HOTSTUFF_STEP_NEWROUND
 	Prepare   = typesCons.HotstuffStep_HOTSTUFF_STEP_PREPARE
@@ -23,11 +23,13 @@ const (
 	Commit    = typesCons.HotstuffStep_HOTSTUFF_STEP_COMMIT
 	Decide    = typesCons.HotstuffStep_HOTSTUFF_STEP_DECIDE
 
+	Propose = typesCons.HotstuffMessageType_HOTSTUFF_MESSAGE_PROPOSE
+	Vote    = typesCons.HotstuffMessageType_HOTSTUFF_MESSAGE_VOTE
+
 	ByzantineThreshold = float64(2) / float64(3)
-	HotstuffMessage    = "consensus.HotstuffMessage"
-	UtilityMessage     = "consensus.UtilityMessage"
-	Propose            = typesCons.HotstuffMessageType_HOTSTUFF_MESSAGE_PROPOSE
-	Vote               = typesCons.HotstuffMessageType_HOTSTUFF_MESSAGE_VOTE
+
+	HotstuffMessage = "consensus.HotstuffMessage"
+	UtilityMessage  = "consensus.UtilityMessage"
 )
 
 var (
@@ -36,22 +38,21 @@ var (
 
 // ** Hotstuff Helpers ** //
 
-// TODO: Make this method functional (i.e. not have the ConsensusModule receiver)
+// IMPROVE: Avoid having the `ConsensusModule` be a receiver of this; making it more functional.
+// TODO: Add unit tests for quorumCert creation & validation.
 func (m *ConsensusModule) getQuorumCertificate(height uint64, step typesCons.HotstuffStep, round uint64) (*typesCons.QuorumCertificate, error) {
 	var pss []*typesCons.PartialSignature
 	for _, msg := range m.MessagePool[step] {
-		// TODO(olshansky): Add tests for this
 		if msg.GetPartialSignature() == nil {
 			m.nodeLog(typesCons.WarnMissingPartialSig(msg))
 			continue
 		}
-		// TODO(olshansky): Add tests for this
 		if msg.GetHeight() != height || msg.GetStep() != step || msg.GetRound() != round {
 			m.nodeLog(typesCons.WarnUnexpectedMessageInPool(msg, height, step, round))
 			continue
 		}
-		ps := msg.GetPartialSignature()
 
+		ps := msg.GetPartialSignature()
 		if ps.Signature == nil || len(ps.Address) == 0 {
 			m.nodeLog(typesCons.WarnIncompletePartialSig(ps, msg))
 			continue
@@ -77,8 +78,8 @@ func (m *ConsensusModule) getQuorumCertificate(height uint64, step typesCons.Hot
 	}, nil
 }
 
-func (m *ConsensusModule) findHighQC(step typesCons.HotstuffStep) (qc *typesCons.QuorumCertificate) {
-	for _, m := range m.MessagePool[step] {
+func (m *ConsensusModule) findHighQC(msgs []*typesCons.HotstuffMessage) (qc *typesCons.QuorumCertificate) {
+	for _, m := range msgs {
 		if m.GetQuorumCertificate() == nil {
 			continue
 		}
@@ -89,8 +90,7 @@ func (m *ConsensusModule) findHighQC(step typesCons.HotstuffStep) (qc *typesCons
 	return
 }
 
-func getThresholdSignature(
-	partialSigs []*typesCons.PartialSignature) (*typesCons.ThresholdSignature, error) {
+func getThresholdSignature(partialSigs []*typesCons.PartialSignature) (*typesCons.ThresholdSignature, error) {
 	thresholdSig := new(typesCons.ThresholdSignature)
 	thresholdSig.Signatures = make([]*typesCons.PartialSignature, len(partialSigs))
 	copy(thresholdSig.Signatures, partialSigs)
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 7529c5e53..4aba0298b 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -46,7 +46,8 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusM
 	}
 
 	// Likely to be `nil` if blockchain is progressing well.
-	highPrepareQC := m.findHighQC(NewRound) // TECHDEBT: How do we validate `highPrepareQC` here?
+	// TECHDEBT: How do we properly validate `highPrepareQC` here?
+	highPrepareQC := m.findHighQC(m.MessagePool[NewRound])
 
 	// TODO: Add more unit tests for these checks...
 	if highPrepareQC == nil || highPrepareQC.Height < m.Height || highPrepareQC.Round < m.Round {

From fa3a051046f895c8fd09752d0111f39ddd4f5323 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 26 Sep 2022 14:20:24 -0700
Subject: [PATCH 027/227] Reverted changes to the utility module to simplify
 the PR

---
 utility/block.go           | 53 +++++++++++++++++++++++++++-----------
 utility/context.go         | 28 +++++++++-----------
 utility/test/block_test.go | 18 ++++++++++---
 3 files changed, 65 insertions(+), 34 deletions(-)

diff --git a/utility/block.go b/utility/block.go
index 324ee78a8..6c09cd8cf 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -3,7 +3,7 @@ package utility
 import (
 	"math/big"
 
-	// TODO (andrew) importing consensus and persistence in this file?
+	typesCons "github.com/pokt-network/pocket/consensus/types" // TODO (andrew) importing consensus and persistence in this file?
 	typesGenesis "github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 
@@ -34,8 +34,6 @@ var (
 
 func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) ([]byte, error) {
 	u.LatestHeight = latestHeight
-	u.CurrentProposer = proposerAddress
-
 	// begin block lifecycle phase
 	if err := u.BeginBlock(lastBlockByzantineValidators); err != nil {
 		return nil, err
@@ -53,30 +51,22 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 		if err := u.ApplyTransaction(tx); err != nil {
 			return nil, err
 		}
-		if err := u.Context.PersistenceRWContext.StoreTransaction(transactionProtoBytes); err != nil {
+		if err := u.GetPersistenceContext().StoreTransaction(transactionProtoBytes); err != nil {
 			return nil, err
 		}
 
-		// DISCUSS: What if the context is rolled back or cancelled. Do we add it back to the mempool?
 		// TODO: if found, remove transaction from mempool
+		// DISCUSS: What if the context is rolled back or cancelled. Do we add it back to the mempool?
 		// if err := u.Mempool.DeleteTransaction(transaction); err != nil {
 		// 	return nil, err
 		// }
 	}
-
 	// end block lifecycle phase
 	if err := u.EndBlock(proposerAddress); err != nil {
 		return nil, err
 	}
-
-	// TODO: What if everything above succeeded but updating the app hash failed?
-	appHash, err := u.Context.UpdateAppHash()
-	if err != nil {
-		return nil, typesUtil.ErrAppHash(err)
-	}
-
-	// return the app hash; consensus module will get the validator set directly
-	return appHash, nil
+	// return the app hash (consensus module will get the validator set directly
+	return u.GetAppHash()
 }
 
 func (u *UtilityContext) BeginBlock(previousBlockByzantineValidators [][]byte) typesUtil.Error {
@@ -102,6 +92,15 @@ func (u *UtilityContext) EndBlock(proposer []byte) typesUtil.Error {
 	return nil
 }
 
+func (u *UtilityContext) GetAppHash() ([]byte, typesUtil.Error) {
+	// Get the root hash of the merkle state tree for state consensus integrity
+	appHash, er := u.Context.AppHash()
+	if er != nil {
+		return nil, typesUtil.ErrAppHash(er)
+	}
+	return appHash, nil
+}
+
 // HandleByzantineValidators handles the validators who either didn't sign at all or disagreed with the 2/3+ majority
 func (u *UtilityContext) HandleByzantineValidators(lastBlockByzantineValidators [][]byte) typesUtil.Error {
 	latestBlockHeight, err := u.GetLatestHeight()
@@ -285,3 +284,27 @@ func (u *UtilityContext) SetValidatorMissedBlocks(address []byte, missedBlocks i
 	}
 	return nil
 }
+
+func (u *UtilityContext) StoreBlock(blockProtoBytes []byte) error {
+	store := u.Store()
+
+	// Store in KV Store
+	if err := store.StoreBlock(blockProtoBytes); err != nil {
+		return err
+	}
+
+	// Store in SQL Store
+	// OPTIMIZE: Ideally we'd pass in the block proto struct to utility so we don't
+	//           have to unmarshal it here, but that's a major design decision for the interfaces.
+	codec := u.Codec()
+	block := &typesCons.Block{}
+	if err := codec.Unmarshal(blockProtoBytes, block); err != nil {
+		return typesUtil.ErrProtoUnmarshal(err)
+	}
+	header := block.BlockHeader
+	if err := store.InsertBlock(uint64(header.Height), header.Hash, header.ProposerAddress, header.QuorumCertificate); err != nil {
+		return err
+	}
+
+	return nil
+}
diff --git a/utility/context.go b/utility/context.go
index b0ca4bebc..460b7cfa1 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -2,24 +2,19 @@ package utility
 
 import (
 	"encoding/hex"
-
 	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/modules"
 	typesUtil "github.com/pokt-network/pocket/utility/types"
 )
 
 type UtilityContext struct {
-	LatestHeight    int64 // IMPROVE: Rename to `currentHeight?`
-	CurrentProposer []byte
-
-	Mempool typesUtil.Mempool
-	Context *Context // IMPROVE: Rename to `persistenceContext` or `storeContext` or `reversibleContext`?
+	LatestHeight int64
+	Mempool      typesUtil.Mempool
+	Context      *Context // IMPROVE: Consider renmaming to PersistenceContext
 }
 
-type Context struct { // IMPROVE: Rename to `persistenceContext` or `storeContext`?
-	// TODO: Since `Context` embeds `PersistenceRWContext`, we don't need to do `u.Context.PersistenceRWContext`, but can call `u.Context` directly
+type Context struct {
 	modules.PersistenceRWContext
-	// TODO/DISCUSS: `SavePoints`` have not been implemented yet
 	SavePointsM map[string]struct{}
 	SavePoints  [][]byte
 }
@@ -44,16 +39,17 @@ func (u *UtilityContext) Store() *Context {
 	return u.Context
 }
 
-func (u *UtilityContext) CommitContext(quorumCert []byte) error {
-	err := u.Context.PersistenceRWContext.Commit(u.CurrentProposer, quorumCert)
-	u.Context = nil // DISCUSS: Should we release the context if there was an error here?
-	return err
+func (u *UtilityContext) GetPersistenceContext() modules.PersistenceRWContext {
+	return u.Context.PersistenceRWContext
+}
+
+func (u *UtilityContext) CommitPersistenceContext() error {
+	return u.Context.PersistenceRWContext.Commit()
 }
 
-func (u *UtilityContext) ReleaseContext() error {
-	err := u.Context.Release()
+func (u *UtilityContext) ReleaseContext() {
+	u.Context.Release()
 	u.Context = nil
-	return err
 }
 
 func (u *UtilityContext) GetLatestHeight() (int64, typesUtil.Error) {
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index f4a1420e9..c1441e405 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -3,13 +3,12 @@ package test
 import (
 	"encoding/hex"
 	"fmt"
+	"github.com/pokt-network/pocket/shared/modules"
+	"github.com/pokt-network/pocket/shared/test_artifacts"
 	"math"
 	"math/big"
 	"testing"
 
-	"github.com/pokt-network/pocket/shared/modules"
-	"github.com/pokt-network/pocket/shared/test_artifacts"
-
 	typesUtil "github.com/pokt-network/pocket/utility/types"
 	"github.com/stretchr/testify/require"
 )
@@ -173,6 +172,19 @@ func TestUtilityContext_EndBlock(t *testing.T) {
 	test_artifacts.CleanupTest(ctx)
 }
 
+func TestUtilityContext_GetAppHash(t *testing.T) {
+	ctx := NewTestingUtilityContext(t, 0)
+
+	appHashTest, err := ctx.GetAppHash()
+	require.NoError(t, err)
+
+	appHashSource, er := ctx.Context.AppHash()
+	require.NoError(t, er)
+	require.Equal(t, appHashSource, appHashTest, "unexpected appHash")
+
+	test_artifacts.CleanupTest(ctx)
+}
+
 func TestUtilityContext_UnstakeValidatorsActorsThatAreReady(t *testing.T) {
 	for _, actorType := range typesUtil.ActorTypes {
 		ctx := NewTestingUtilityContext(t, 1)

From 752992b15c7b13b01a6f79831b09cb329457ce76 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 26 Sep 2022 14:49:56 -0700
Subject: [PATCH 028/227] Reverted changes to the utility module interface

---
 shared/modules/utility_module.go  |  9 +++---
 shared/types/genesis/validator.go | 49 -------------------------------
 2 files changed, 4 insertions(+), 54 deletions(-)
 delete mode 100644 shared/types/genesis/validator.go

diff --git a/shared/modules/utility_module.go b/shared/modules/utility_module.go
index 5dbf9f887..67617399a 100644
--- a/shared/modules/utility_module.go
+++ b/shared/modules/utility_module.go
@@ -14,15 +14,14 @@ type UtilityModule interface {
 // operations.
 type UtilityContext interface {
 	// Block operations
-
-	// Reaps the mempool for transactions that are ready to be proposed in a new block
 	GetProposalTransactions(proposer []byte, maxTransactionBytes int, lastBlockByzantineValidators [][]byte) (transactions [][]byte, err error)
-	// Applies the transactions to an ephemeral state in the utility & underlying persistence context;similar to `SafeNode` in the Hotstuff whitepaper.
 	ApplyBlock(height int64, proposer []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) (appHash []byte, err error)
+	StoreBlock(blockProtoBytes []byte) error
 
 	// Context operations
-	ReleaseContext() error
-	CommitContext(quorumCert []byte) error
+	ReleaseContext()
+	GetPersistenceContext() PersistenceRWContext
+	CommitPersistenceContext() error
 
 	// Validation operations
 	CheckTransaction(tx []byte) error
diff --git a/shared/types/genesis/validator.go b/shared/types/genesis/validator.go
deleted file mode 100644
index 17c2af5fd..000000000
--- a/shared/types/genesis/validator.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package genesis
-
-// import (
-// 	"encoding/hex"
-// 	"encoding/json"
-
-// 	"google.golang.org/protobuf/encoding/protojson"
-// )
-
-// // TODO_IN_THIS_COMMIT: See https://github.com/pokt-network/pocket/pull/139/files to remove this shit
-
-// // HACK: Since the protocol actor protobufs (e.g. validator, fisherman, etc) use `bytes` for some
-// // fields (e.g. `address`, `output`, `publicKey`), we need to use a helper struct to unmarshal the
-// // the types when they are defined via json (e.g. genesis file, testing configurations, etc...).
-// // Alternative solutions could include whole wrapper structs (i.e. duplication of schema definition),
-// // using strings instead of bytes (i.e. major change with downstream effects) or avoid defining these
-// // types in json altogether (i.e. limitation of usability).
-// type JsonBytesLoaderHelper struct {
-// 	Address   HexData `json:"address,omitempty"`
-// 	PublicKey HexData `json:"public_key,omitempty"`
-// 	Output    HexData `json:"output,omitempty"`
-// }
-
-// type HexData []byte
-
-// func (h *HexData) UnmarshalJSON(data []byte) error {
-// 	var s string
-// 	if err := json.Unmarshal(data, &s); err != nil {
-// 		return err
-// 	}
-// 	decoded, err := hex.DecodeString(s)
-// 	if err != nil {
-// 		return err
-// 	}
-// 	*h = HexData(decoded)
-// 	return nil
-// }
-
-// func (v *Validator) UnmarshalJSON(data []byte) error {
-// 	var jh JsonBytesLoaderHelper
-// 	json.Unmarshal(data, &jh)
-
-// 	protojson.Unmarshal(data, v)
-// 	v.Address = jh.Address
-// 	v.PublicKey = jh.PublicKey
-// 	v.Output = jh.Output
-
-// 	return nil
-// }

From 844688f7c010d9e41cbc267142efa19ff0a50010 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 26 Sep 2022 14:50:15 -0700
Subject: [PATCH 029/227] Reverted changes to the persistence module interface

---
 shared/modules/persistence_module.go | 79 +++++++---------------------
 1 file changed, 18 insertions(+), 61 deletions(-)

diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index a4a587bb9..edc0e30cc 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -3,14 +3,12 @@ package modules
 //go:generate mockgen -source=$GOFILE -destination=./mocks/persistence_module_mock.go -aux_files=github.com/pokt-network/pocket/shared/modules=module.go
 
 import (
-	"github.com/pokt-network/pocket/persistence/kvstore" // Should be moved to shared
+	"github.com/pokt-network/pocket/persistence/kvstore"
 	"github.com/pokt-network/pocket/shared/debug"
 )
 
 type PersistenceModule interface {
 	Module
-
-	// Persistence Context Factory Methods
 	NewRWContext(height int64) (PersistenceRWContext, error)
 	NewReadContext(height int64) (PersistenceReadContext, error)
 
@@ -40,28 +38,34 @@ type PersistenceRWContext interface {
 	PersistenceWriteContext
 }
 
-// TODO: Simplify the interface (reference - https://dave.cheney.net/practical-go/presentations/gophercon-israel.html#_prefer_single_method_interfaces)
-// - Add general purpose methods such as `ActorOperation(enum_actor_type, ...)` which can be use like so: `Insert(FISHERMAN, ...)`
-// - Use general purpose parameter methods such as `Set(enum_gov_type, ...)` such as `Set(STAKING_ADJUSTMENT, ...)`
-
 // NOTE: There's not really a use case for a write only interface,
 // but it abstracts and contrasts nicely against the read only context
 // TODO (andrew) convert address and public key to string not bytes #149
 type PersistenceWriteContext interface {
+	// TODO: Simplify the interface (reference - https://dave.cheney.net/practical-go/presentations/gophercon-israel.html#_prefer_single_method_interfaces)
+	// - Add general purpose methods such as `ActorOperation(enum_actor_type, ...)` which can be use like so: `Insert(FISHERMAN, ...)`
+	// - Use general purpose parameter methods such as `Set(enum_gov_type, ...)` such as `Set(STAKING_ADJUSTMENT, ...)`
 	// Context Operations
 	NewSavePoint([]byte) error
 	RollbackToSavePoint([]byte) error
 
-	// DISCUSS: Can we consolidate `Reset` and `Release`
 	Reset() error
+	Commit() error
 	Release() error
 
-	// Block / indexer operations
-	UpdateAppHash() ([]byte, error)
-	// Commits the current context (height, hash, transactions, etc...) to finality.
-	Commit(proposerAddr []byte, quorumCert []byte) error
-	// Indexes the transaction
-	StoreTransaction(transactionProtoBytes []byte) error // Stores a transaction
+	AppHash() ([]byte, error)
+
+	// Block Operations
+
+	// Indexer Operations
+	StoreTransaction(transactionProtoBytes []byte) error
+
+	// Block Operations
+	// TODO_TEMPORARY: Including two functions for the SQL and KV Store as an interim solution
+	//                 until we include the schema as part of the SQL Store because persistence
+	//                 currently has no access to the protobuf schema which is the source of truth.
+	StoreBlock(blockProtoBytes []byte) error                                              // Store the block in the KV Store
+	InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error // Writes the block in the SQL database
 
 	// Pool Operations
 	AddPoolAmount(name string, amount string) error
@@ -122,29 +126,6 @@ type PersistenceWriteContext interface {
 	// Flag Operations
 	InitFlags() error
 	SetFlag(paramName string, value interface{}, enabled bool) error
-
-	// Tree Operations
-
-	// # Option 1:
-
-	UpdateApplicationsTree([]Actor) error
-	// UpdateValidatorsTree([]Actor) error
-	// UpdateServiceNodesTree([]Actor) error
-	// UpdateFishermanTree([]Actor) error
-	// Update<FutureActors>Tree([]Actor) error
-	// Update<Other>Tree([]Other) error
-
-	// # Option 2:
-	// UpdateActorTree(types.ProtocolActorSchema, []Actor) error
-	// Update<Other>Tree([]Other) error
-
-	// # Option 3:
-	// UpdateApplicationsTree([]Application) error
-	// UpdateValidatorsTree([]Validator) error
-	// UpdateServiceNodesTree([]ServiceNode) error
-	// UpdateFishermanTree([]Fisherman) error
-	// Update<FutureActors>Tree([]FutureActor) error
-	// Update<Other>Tree([]Other) error
 }
 
 type PersistenceReadContext interface {
@@ -223,28 +204,4 @@ type PersistenceReadContext interface {
 	GetIntFlag(paramName string, height int64) (int, bool, error)
 	GetStringFlag(paramName string, height int64) (string, bool, error)
 	GetBytesFlag(paramName string, height int64) ([]byte, bool, error)
-
-	// Tree Operations
-
-	// # Option 1:
-
-	// GetApplicationsUpdatedAtHeight(height int64) ([]Actor, error)
-	// GetValidatorsUpdatedAtHeight(height int64) ([]Actor, error)
-	// GetServiceNodesUpdatedAtHeight(height int64) ([]Actor, error)
-	// GetFishermanUpdatedAtHeight(height int64) ([]Actor, error)
-	// Get<FutureActor>UpdatedAtHeight(height int64) ([]Actor, error)
-	// Get<Other>UpdatedAtHeight(height int64) ([]Actor, error)
-	// Update<Other>Tree(height int64) ([]Actor, error)
-
-	// # Option 2:
-	// Get<FutureActor>UpdatedAtHeight(types.ProtocolActorSchema, height int64) ([]Actor, error)
-	// Get<Other>UpdatedAtHeight(height int64) ([]Other, error)
-
-	// # Option 3:
-	// GetApplicationsUpdatedAtHeight(height int64) ([]Application, error)
-	// GetValidatorsUpdatedAtHeight(height int64) ([]Validator, error)
-	// GetServiceNodesUpdatedAtHeight(height int64) ([]ServiceNode, error)
-	// GetFishermanUpdatedAtHeight(height int64) ([]Fisherman, error)
-	// Get<FutureActor>UpdatedAtHeight(height int64) ([]FutureActor, error)
-	// Get<Other>UpdatedAtHeight(height int64) ([]Other, error)
 }

From d5a8a1f2c43437ca72d1183101dcd9d6cf8aaf4d Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 26 Sep 2022 14:51:48 -0700
Subject: [PATCH 030/227] Reverted changes to the persistence module files

---
 persistence/application.go          | 51 -----------------------------
 persistence/block.go                | 42 +++++-------------------
 persistence/context.go              | 26 ++++-----------
 persistence/db.go                   |  8 -----
 persistence/debug.go                |  2 +-
 persistence/genesis.go              |  4 +--
 persistence/kvstore/kvstore.go      | 35 +++-----------------
 persistence/module.go               | 31 +++---------------
 persistence/shared_sql.go           | 40 ++--------------------
 persistence/test/module_test.go     |  4 +--
 persistence/types/base_actor.go     |  7 +---
 persistence/types/protocol_actor.go |  3 --
 persistence/types/shared_sql.go     |  5 ---
 shared/indexer/indexer.go           |  3 +-
 14 files changed, 32 insertions(+), 229 deletions(-)

diff --git a/persistence/application.go b/persistence/application.go
index 0bd6750bd..0f2b88512 100644
--- a/persistence/application.go
+++ b/persistence/application.go
@@ -5,66 +5,15 @@ import (
 	"log"
 
 	"github.com/pokt-network/pocket/persistence/types"
-	"google.golang.org/protobuf/proto"
-
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
-func (p PostgresContext) UpdateApplicationsTree(apps []modules.Actor) error {
-	for _, app := range apps {
-		bzAddr, err := hex.DecodeString(app.GetAddress())
-		if err != nil {
-			return err
-		}
-
-		appBz, err := proto.Marshal(app.(*types.Actor))
-		if err != nil {
-			return err
-		}
-
-		// OPTIMIZE: This is the only line unique to `Application`
-		if _, err := p.MerkleTrees[appMerkleTree].Update(bzAddr, appBz); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (p PostgresContext) getApplicationsUpdatedAtHeight(height int64) (apps []*types.Actor, err error) {
-	// OPTIMIZE: This is the only line unique to `Application`
-	actors, err := p.GetActorsUpdated(types.ApplicationActor, height)
-	if err != nil {
-		return nil, err
-	}
-
-	apps = make([]*types.Actor, len(actors))
-	for _, actor := range actors {
-		app := &types.Actor{
-			ActorType:       types.ActorType_App,
-			Address:         actor.Address,
-			PublicKey:       actor.PublicKey,
-			Chains:          actor.Chains,
-			GenericParam:    actor.ActorSpecificParam,
-			StakedAmount:    actor.StakedTokens,
-			PausedHeight:    actor.PausedHeight,
-			UnstakingHeight: actor.UnstakingHeight,
-			Output:          actor.OutputAddress,
-		}
-		apps = append(apps, app)
-	}
-	return
-}
-
 func (p PostgresContext) GetAppExists(address []byte, height int64) (exists bool, err error) {
 	return p.GetExists(types.ApplicationActor, address, height)
 }
 
 func (p PostgresContext) GetApp(address []byte, height int64) (operator, publicKey, stakedTokens, maxRelays, outputAddress string, pauseHeight, unstakingHeight int64, chains []string, err error) {
 	actor, err := p.GetActor(types.ApplicationActor, address, height)
-	if err != nil {
-		return
-	}
 	operator = actor.Address
 	publicKey = actor.PublicKey
 	stakedTokens = actor.StakedTokens
diff --git a/persistence/block.go b/persistence/block.go
index 5efa1b71e..aaee96364 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -5,7 +5,6 @@ import (
 	"encoding/hex"
 	"log"
 
-	"github.com/gogo/protobuf/proto"
 	"github.com/pokt-network/pocket/persistence/types"
 )
 
@@ -50,44 +49,21 @@ func (p PostgresContext) StoreTransaction(transactionProtoBytes []byte) error {
 	return nil
 }
 
-func (p PostgresContext) insertBlock(block *types.Block) error {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return err
-	}
-
-	_, err = tx.Exec(ctx, types.InsertBlockQuery(block.Height, block.Hash, block.ProposerAddress, block.QuorumCertificate))
-	return err
+func (p PostgresContext) StoreBlock(blockProtoBytes []byte) error {
+	// INVESTIGATE: Note that we are writing this directly to the blockStore. Depending on how
+	// the use of the PostgresContext evolves, we may need to write this to `ContextStore` and copy
+	// over to `BlockStore` when the block is committed.
+	return p.blockstore.Put(heightToBytes(p.Height), blockProtoBytes)
 }
 
-func (p PostgresContext) storeBlock(block *types.Block) error {
-	blockBz, err := proto.Marshal(block)
+func (p PostgresContext) InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error {
+	ctx, tx, err := p.GetCtxAndTx()
 	if err != nil {
 		return err
 	}
 
-	return p.blockstore.Put(heightToBytes(p.Height), blockBz)
-}
-
-func (p PostgresContext) getBlock(proposerAddr []byte, quorumCert []byte) (*types.Block, error) {
-	prevHash, err := p.GetBlockHash(p.Height - 1)
-	if err != nil {
-		return nil, err
-	}
-
-	// TODO: get this from the transactions that were store via `StoreTransaction`
-	txs := make([][]byte, 0)
-
-	block := &types.Block{
-		Height:            uint64(p.Height),
-		Hash:              string(p.stateHash),
-		PrevHash:          string(prevHash),
-		ProposerAddress:   proposerAddr,
-		QuorumCertificate: quorumCert,
-		Transactions:      txs,
-	}
-
-	return block, nil
+	_, err = tx.Exec(ctx, types.InsertBlockQuery(height, hash, proposerAddr, quorumCert))
+	return err
 }
 
 // CLEANUP: Should this be moved to a shared directory?
diff --git a/persistence/context.go b/persistence/context.go
index 8224a229a..fd44e3af1 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -15,39 +15,25 @@ func (p PostgresContext) RollbackToSavePoint(bytes []byte) error {
 	return p.GetTx().Rollback(context.TODO())
 }
 
-func (p PostgresContext) UpdateAppHash() ([]byte, error) {
-	if err := p.updateStateHash(); err != nil {
-		return nil, err
-	}
-	return p.stateHash, nil
+func (p PostgresContext) AppHash() ([]byte, error) {
+	log.Println("TODO: AppHash not implemented")
+	return []byte("A real app hash, I am not"), nil
 }
 
 func (p PostgresContext) Reset() error {
 	panic("TODO: PostgresContext Reset not implemented")
 }
 
-func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
+func (p PostgresContext) Commit() error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
-	block, err := p.getBlock(proposerAddr, quorumCert)
-	if err != nil {
-		return err
-	}
-
-	if err := p.insertBlock(block); err != nil {
-		return err
-	}
-
-	if err := p.storeBlock(block); err != nil {
-		return err
-	}
-
 	ctx := context.TODO()
-	if err := p.GetTx().Commit(ctx); err != nil {
+	if err := p.GetTx().Commit(context.TODO()); err != nil {
 		return err
 	}
 	if err := p.conn.Close(ctx); err != nil {
 		log.Println("[TODO][ERROR] Implement connection pooling. Error when closing DB connecting...", err)
+
 	}
 	return nil
 }
diff --git a/persistence/db.go b/persistence/db.go
index b8a974939..3a495596c 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -7,7 +7,6 @@ import (
 
 	"github.com/pokt-network/pocket/persistence/types"
 
-	"github.com/celestiaorg/smt"
 	"github.com/jackc/pgconn"
 	"github.com/jackc/pgx/v4"
 	"github.com/pokt-network/pocket/persistence/kvstore"
@@ -41,13 +40,6 @@ type PostgresContext struct {
 	conn       *pgx.Conn
 	tx         pgx.Tx
 	blockstore kvstore.KVStore
-
-	stateHash []byte
-	// IMPROVE: Depending on how the use of `PostgresContext` evolves, we may be able to get
-	// access to these directly via the postgres module.
-	PostgresDB  *pgx.Conn
-	BlockStore  kvstore.KVStore                      // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context)
-	MerkleTrees map[MerkleTree]*smt.SparseMerkleTree // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context)
 }
 
 func (pg *PostgresContext) GetCtxAndTx() (context.Context, pgx.Tx, error) {
diff --git a/persistence/debug.go b/persistence/debug.go
index e0e3b6e5e..3fdc583a4 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -44,7 +44,7 @@ func (m *PersistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 
 func (m *PersistenceModule) clearState(_ *debug.DebugMessage) {
 	context, err := m.NewRWContext(-1)
-	defer context.Commit(nil, nil)
+	defer context.Commit()
 	if err != nil {
 		log.Printf("Error creating new context: %s \n", err)
 		return
diff --git a/persistence/genesis.go b/persistence/genesis.go
index a6eefaa90..1c7e82f14 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -149,7 +149,7 @@ func (m *PersistenceModule) populateGenesisState(state *types.PersistenceGenesis
 		log.Fatalf("an error occurred initializing flags: %s", err.Error())
 	}
 
-	if err = rwContext.Commit(nil, nil); err != nil {
+	if err = rwContext.Commit(); err != nil {
 		log.Fatalf("an error occurred during commit() on genesis state %s ", err.Error())
 	}
 }
@@ -316,7 +316,7 @@ func (p PostgresContext) GetAllFishermen(height int64) (f []modules.Actor, err e
 	return
 }
 
-// CONSOLIDATE: Consolidate `types.BaseActor` with `types.Actor`
+// TODO (Team) deprecate with interface #163 <Bumped to #149> as #163 is getting large
 func (p PostgresContext) BaseActorToActor(ba types.BaseActor, actorType types.ActorType) *types.Actor {
 	actor := new(types.Actor)
 	actor.ActorType = actorType
diff --git a/persistence/kvstore/kvstore.go b/persistence/kvstore/kvstore.go
index 8636e4519..24613afc9 100644
--- a/persistence/kvstore/kvstore.go
+++ b/persistence/kvstore/kvstore.go
@@ -1,47 +1,33 @@
 package kvstore
 
 import (
-	"errors"
 	"log"
 
-	"github.com/celestiaorg/smt"
 	badger "github.com/dgraph-io/badger/v3"
 )
 
+// CLEANUP: move this structure to a shared module
 type KVStore interface {
 	// Lifecycle methods
 	Stop() error
 
 	// Accessors
 	// TODO: Add a proper iterator interface
+	Put(key []byte, value []byte) error
+	Get(key []byte) ([]byte, error)
 	// TODO: Add pagination for `GetAll`
 	GetAll(prefixKey []byte, descending bool) ([][]byte, error)
-
 	Exists(key []byte) (bool, error)
 	ClearAll() error
-
-	// Same interface as in `smt.MapStore``
-	Put(key, value []byte) error
-	Get(key []byte) ([]byte, error)
-	Delete(key []byte) error
 }
 
 var _ KVStore = &badgerKVStore{}
-var _ smt.MapStore = &badgerKVStore{}
-
-var (
-	ErrKVStoreExists    = errors.New("kvstore already exists")
-	ErrKVStoreNotExists = errors.New("kvstore does not exist")
-)
 
 type badgerKVStore struct {
 	db *badger.DB
 }
 
-// REFACTOR: Loads or creates a badgerDb at `path`. This may potentially need to be refactored
-// into `NewKVStore` and `LoadKVStore` depending on how state sync evolves by leveraging `os.Stat`
-// on the file path.
-func OpenKVStore(path string) (KVStore, error) {
+func NewKVStore(path string) (KVStore, error) {
 	db, err := badger.Open(badger.DefaultOptions(path))
 	if err != nil {
 		return nil, err
@@ -57,7 +43,7 @@ func NewMemKVStore() KVStore {
 	return badgerKVStore{db: db}
 }
 
-func (store badgerKVStore) Put(key, value []byte) error {
+func (store badgerKVStore) Put(key []byte, value []byte) error {
 	tx := store.db.NewTransaction(true)
 	defer tx.Discard()
 
@@ -69,12 +55,6 @@ func (store badgerKVStore) Put(key, value []byte) error {
 	return tx.Commit()
 }
 
-// CONSOLIDATE: We might be able to remove the `KVStore` interface altogether if we end up using `smt.MapStore`
-// A wrapper around `Put` to conform to the `smt.MapStore` interface
-func (store *badgerKVStore) Set(key, value []byte) error {
-	return store.Put(key, value)
-}
-
 func (store badgerKVStore) Get(key []byte) ([]byte, error) {
 	tx := store.db.NewTransaction(false)
 	defer tx.Discard()
@@ -96,11 +76,6 @@ func (store badgerKVStore) Get(key []byte) ([]byte, error) {
 	return value, nil
 }
 
-func (store badgerKVStore) Delete(key []byte) error {
-	log.Fatalf("badgerKVStore.Delete not implemented yet")
-	return nil
-}
-
 func (store badgerKVStore) GetAll(prefix []byte, descending bool) (values [][]byte, err error) {
 	// INVESTIGATE: research `badger.views` for further improvements and optimizations
 	txn := store.db.NewTransaction(false)
diff --git a/persistence/module.go b/persistence/module.go
index 6761bb22b..33bd827bd 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -7,10 +7,10 @@ import (
 	"io/ioutil"
 	"log"
 
-	"github.com/celestiaorg/smt"
+	"github.com/pokt-network/pocket/persistence/types"
+
 	"github.com/jackc/pgx/v4"
 	"github.com/pokt-network/pocket/persistence/kvstore"
-	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 	"github.com/pokt-network/pocket/shared/test_artifacts"
 )
@@ -26,19 +26,10 @@ type PersistenceModule struct {
 	postgresURL string
 	nodeSchema  string
 	genesisPath string
+	blockStore  kvstore.KVStore // INVESTIGATE: We may need to create a custom `BlockStore` package in the future
 
 	// TECHDEBT: Need to implement context pooling (for writes), timeouts (for read & writes), etc...
 	writeContext *PostgresContext // only one write context is allowed at a time
-
-	// The connection to the PostgreSQL database
-	postgresConn *pgx.Conn
-	// A reference to the block key-value store
-	// INVESTIGATE: We may need to create a custom `BlockStore` package in the future.
-	blockStore kvstore.KVStore
-	// A mapping of context IDs to persistence contexts
-	// contexts map[contextId]modules.PersistenceRWContext
-	// Merkle trees
-	trees map[MerkleTree]*smt.SparseMerkleTree
 }
 
 const (
@@ -51,10 +42,8 @@ func Create(configPath, genesisPath string) (modules.PersistenceModule, error) {
 	if err != nil {
 		return nil, err
 	}
-
 	cfg := c.(*types.PersistenceConfig)
 	g, err := m.InitGenesis(genesisPath)
-
 	if err != nil {
 		return nil, err
 	}
@@ -80,20 +69,8 @@ func Create(configPath, genesisPath string) (modules.PersistenceModule, error) {
 		genesisPath:  genesisPath,
 		blockStore:   blockStore,
 		writeContext: nil,
-		// contexts:     make(map[contextId]modules.PersistenceContext),
-		trees: make(map[MerkleTree]*smt.SparseMerkleTree),
 	}
 
-	// DISCUSS_IN_THIS_COMMIT: We've been using the module function pattern, but this making `initializeTrees`
-	// be able to create and/or load trees outside the scope of the persistence module makes it easier to test.
-	trees, err := newMerkleTrees()
-	if err != nil {
-		return nil, err
-	}
-
-	// TODO_IN_THIS_COMMIT: load trees from state
-	persistenceMod.trees = trees
-
 	// Determine if we should hydrate the genesis db or use the current state of the DB attached
 	if shouldHydrateGenesis, err := persistenceMod.shouldHydrateGenesisDb(); err != nil {
 		return nil, err
@@ -237,7 +214,7 @@ func initializeBlockStore(blockStorePath string) (kvstore.KVStore, error) {
 	if blockStorePath == "" {
 		return kvstore.NewMemKVStore(), nil
 	}
-	return kvstore.OpenKVStore(blockStorePath)
+	return kvstore.NewKVStore(blockStorePath)
 }
 
 // TODO(drewsky): Simplify and externalize the logic for whether genesis should be populated and
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
index 8eac77562..9f2c19a00 100644
--- a/persistence/shared_sql.go
+++ b/persistence/shared_sql.go
@@ -44,36 +44,6 @@ func (p *PostgresContext) GetExists(actorSchema types.ProtocolActorSchema, addre
 	return
 }
 
-func (p *PostgresContext) GetActorsUpdated(actorSchema types.ProtocolActorSchema, height int64) (actors []types.BaseActor, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return
-	}
-
-	rows, err := tx.Query(ctx, actorSchema.GetUpdatedAtHeightQuery(height))
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	// OPTIMIZE: Consolidate logic with `GetActor` to reduce code footprint
-	var addr string
-	for rows.Next() {
-		if err = rows.Scan(&addr); err != nil {
-			return
-		}
-
-		actor, err := p.GetActor(actorSchema, []byte(addr), height)
-		if err != nil {
-			return nil, err
-		}
-
-		actors = append(actors, actor)
-	}
-
-	return
-}
-
 func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, address []byte, height int64) (actor types.BaseActor, err error) {
 	ctx, tx, err := p.GetCtxAndTx()
 	if err != nil {
@@ -87,16 +57,10 @@ func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, addres
 	return p.GetChainsForActor(ctx, tx, actorSchema, actor, height)
 }
 
-// IMPORTANT: Need to consolidate `persistence/types.BaseActor` with `persistence/genesisTypes.Actor`
 func (p *PostgresContext) GetActorFromRow(row pgx.Row) (actor types.BaseActor, height int64, err error) {
 	err = row.Scan(
-		&actor.Address,
-		&actor.PublicKey,
-		&actor.StakedTokens,
-		&actor.ActorSpecificParam,
-		&actor.OutputAddress,
-		&actor.PausedHeight,
-		&actor.UnstakingHeight,
+		&actor.Address, &actor.PublicKey, &actor.StakedTokens, &actor.ActorSpecificParam,
+		&actor.OutputAddress, &actor.PausedHeight, &actor.UnstakingHeight,
 		&height)
 	return
 }
diff --git a/persistence/test/module_test.go b/persistence/test/module_test.go
index ccb7bd37f..3bee636c5 100644
--- a/persistence/test/module_test.go
+++ b/persistence/test/module_test.go
@@ -18,14 +18,12 @@ func TestPersistenceContextParallelReadWrite(t *testing.T) {
 	poolAddress := []byte("address")
 	originalAmount := "15"
 	modifiedAmount := "10"
-	proposer := []byte("proposer")
-	quorumCert := []byte("quorumCert")
 
 	// setup a write context, insert a pool and commit it
 	context, err := testPersistenceMod.NewRWContext(0)
 	require.NoError(t, err)
 	require.NoError(t, context.InsertPool(poolName, poolAddress, originalAmount))
-	require.NoError(t, context.Commit(proposer, quorumCert))
+	require.NoError(t, context.Commit())
 
 	// verify the insert in the previously committed context worked
 	contextA, err := testPersistenceMod.NewRWContext(0)
diff --git a/persistence/types/base_actor.go b/persistence/types/base_actor.go
index 1c73da9a7..9514b15eb 100644
--- a/persistence/types/base_actor.go
+++ b/persistence/types/base_actor.go
@@ -1,6 +1,5 @@
 package types
 
-// IMPROVE: Move schema related functions to a separate sub-package
 import "github.com/pokt-network/pocket/shared/modules"
 
 // TECHDEBT: Consider moving this to a protobuf. This struct was created to make testing simple of protocol actors that
@@ -61,10 +60,6 @@ func (actor *BaseProtocolActorSchema) GetChainsTableSchema() string {
 	return ProtocolActorChainsTableSchema(actor.chainsHeightConstraintName)
 }
 
-func (actor *BaseProtocolActorSchema) GetUpdatedAtHeightQuery(height int64) string {
-	return SelectAtHeight(AddressCol, height, actor.tableName)
-}
-
 func (actor *BaseProtocolActorSchema) GetQuery(address string, height int64) string {
 	return Select(AllColsSelector, address, height, actor.tableName)
 }
@@ -155,5 +150,5 @@ func (x *Actor) GetActorTyp() modules.ActorType {
 	if x != nil {
 		return x.GetActorType()
 	}
-	return ActorType_App // HACK: Is this a hack?
+	return ActorType_App
 }
diff --git a/persistence/types/protocol_actor.go b/persistence/types/protocol_actor.go
index cb1e23fbf..4b57e8e40 100644
--- a/persistence/types/protocol_actor.go
+++ b/persistence/types/protocol_actor.go
@@ -15,9 +15,6 @@ type ProtocolActorSchema interface {
 	GetActorSpecificColName() string
 
 	/*** Read/Get Queries ***/
-
-	// Returns a query to retrieve the addresses of all the Actors updated at that specific height
-	GetUpdatedAtHeightQuery(height int64) string
 	// Returns a query to retrieve all of a single Actor's attributes.
 	GetQuery(address string, height int64) string
 	// Returns all actors at that height
diff --git a/persistence/types/shared_sql.go b/persistence/types/shared_sql.go
index 6c053b6de..5502c03d3 100644
--- a/persistence/types/shared_sql.go
+++ b/persistence/types/shared_sql.go
@@ -69,11 +69,6 @@ func ProtocolActorChainsTableSchema(constraintName string) string {
 		)`, AddressCol, ChainIDCol, HeightCol, DefaultBigInt, constraintName, AddressCol, ChainIDCol, HeightCol)
 }
 
-func SelectAtHeight(selector string, height int64, tableName string) string {
-	return fmt.Sprintf(`SELECT %s FROM %s WHERE height=%d`,
-		selector, tableName, height)
-}
-
 func Select(selector, address string, height int64, tableName string) string {
 	return fmt.Sprintf(`SELECT %s FROM %s WHERE address='%s' AND height<=%d ORDER BY height DESC LIMIT 1`,
 		selector, tableName, address, height)
diff --git a/shared/indexer/indexer.go b/shared/indexer/indexer.go
index 59355787f..559ca1f6e 100644
--- a/shared/indexer/indexer.go
+++ b/shared/indexer/indexer.go
@@ -5,7 +5,6 @@ package indexer
 import (
 	"encoding/hex"
 	"fmt"
-
 	"github.com/pokt-network/pocket/shared/codec"
 
 	"github.com/jordanorelli/lexnum"
@@ -112,7 +111,7 @@ type txIndexer struct {
 }
 
 func NewTxIndexer(databasePath string) (TxIndexer, error) {
-	db, err := kvstore.OpenKVStore(databasePath)
+	db, err := kvstore.NewKVStore(databasePath)
 	return &txIndexer{
 		db: db,
 	}, err

From 6245080abbffcd6a6c18c61b062ed3e686e14543 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 26 Sep 2022 15:11:54 -0700
Subject: [PATCH 031/227] Using GetCodec().Marshal() where appropriate

---
 consensus/block.go        |   7 +--
 consensus/helpers.go      |   6 +-
 consensus/messages.go     |   4 +-
 consensus/types/block.go  |  14 -----
 consensus/types/errors.go |   3 +-
 go.mod                    |   2 +-
 persistence/state.go      | 119 --------------------------------------
 7 files changed, 10 insertions(+), 145 deletions(-)
 delete mode 100644 consensus/types/block.go
 delete mode 100644 persistence/state.go

diff --git a/consensus/block.go b/consensus/block.go
index 0ce2851e6..df5d82268 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -11,7 +11,7 @@ func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
 
 	// Commit the utility context
-	if err := m.UtilityContext.CommitContext(block.BlockHeader.QuorumCertificate); err != nil {
+	if err := m.UtilityContext.CommitPersistenceContext(); err != nil {
 		return err
 	}
 	// Release the utility context
@@ -56,10 +56,7 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 	// Ideally, this should not be called.
 	if m.UtilityContext != nil {
 		m.nodeLog(typesCons.NilUtilityContextWarning)
-		if err := m.UtilityContext.ReleaseContext(); err != nil {
-			// Logging an error but allowing the consensus lifecycle to continue
-			m.nodeLogError("cannot release existing utility context", err)
-		}
+		m.UtilityContext.ReleaseContext()
 		m.UtilityContext = nil
 	}
 
diff --git a/consensus/helpers.go b/consensus/helpers.go
index 54a2491c6..b59ac6397 100644
--- a/consensus/helpers.go
+++ b/consensus/helpers.go
@@ -5,6 +5,7 @@ import (
 	"encoding/base64"
 	"log"
 
+	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/debug"
 
 	"google.golang.org/protobuf/proto"
@@ -124,7 +125,7 @@ func (m *ConsensusModule) isOptimisticThresholdMet(n int) error {
 }
 
 func protoHash(m proto.Message) string {
-	b, err := proto.Marshal(m)
+	b, err := codec.GetCodec().Marshal(m)
 	if err != nil {
 		log.Fatalf("Could not marshal proto message: %v", err)
 	}
@@ -146,7 +147,6 @@ func (m *ConsensusModule) sendToNode(msg *typesCons.HotstuffMessage) {
 		m.nodeLogError(typesCons.ErrCreateConsensusMessage.Error(), err)
 		return
 	}
-
 	if err := m.GetBus().GetP2PModule().Send(cryptoPocket.AddressFromString(m.IdToValAddrMap[*m.LeaderId]), anyConsensusMessage, debug.PocketTopic_CONSENSUS_MESSAGE_TOPIC); err != nil {
 		m.nodeLogError(typesCons.ErrSendMessage.Error(), err)
 		return
@@ -160,7 +160,6 @@ func (m *ConsensusModule) broadcastToNodes(msg *typesCons.HotstuffMessage) {
 		m.nodeLogError(typesCons.ErrCreateConsensusMessage.Error(), err)
 		return
 	}
-
 	if err := m.GetBus().GetP2PModule().Broadcast(anyConsensusMessage, debug.PocketTopic_CONSENSUS_MESSAGE_TOPIC); err != nil {
 		m.nodeLogError(typesCons.ErrBroadcastMessage.Error(), err)
 		return
@@ -169,6 +168,7 @@ func (m *ConsensusModule) broadcastToNodes(msg *typesCons.HotstuffMessage) {
 
 /*** Persistence Helpers ***/
 
+// TECHDEBT: Integrate this with the `persistence` module or a real mempool.
 func (m *ConsensusModule) clearMessagesPool() {
 	for _, step := range HotstuffSteps {
 		m.MessagePool[step] = make([]*typesCons.HotstuffMessage, 0)
diff --git a/consensus/messages.go b/consensus/messages.go
index eb2801275..66fb8d836 100644
--- a/consensus/messages.go
+++ b/consensus/messages.go
@@ -4,8 +4,8 @@ import (
 	"log"
 
 	typesCons "github.com/pokt-network/pocket/consensus/types"
+	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/crypto"
-	"google.golang.org/protobuf/proto"
 )
 
 func CreateProposeMessage(
@@ -96,5 +96,5 @@ func getSignableBytes(msg *typesCons.HotstuffMessage) ([]byte, error) {
 		Round:  msg.GetRound(),
 		Block:  msg.GetBlock(),
 	}
-	return proto.Marshal(msgToSign)
+	return codec.GetCodec().Marshal(msgToSign)
 }
diff --git a/consensus/types/block.go b/consensus/types/block.go
deleted file mode 100644
index f6091b6b3..000000000
--- a/consensus/types/block.go
+++ /dev/null
@@ -1,14 +0,0 @@
-package types
-
-import (
-	"github.com/pokt-network/pocket/shared/codec"
-)
-
-func (b *Block) Bytes() ([]byte, error) {
-	codec := codec.GetCodec()
-	blockProtoBz, err := codec.Marshal(b)
-	if err != nil {
-		return nil, err
-	}
-	return blockProtoBz, nil
-}
diff --git a/consensus/types/errors.go b/consensus/types/errors.go
index fb6dd6df4..faf9d7002 100644
--- a/consensus/types/errors.go
+++ b/consensus/types/errors.go
@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"log"
 
+	"github.com/pokt-network/pocket/shared/codec"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -235,7 +236,7 @@ func ErrLeaderElection(msg *HotstuffMessage) error {
 }
 
 func protoHash(m proto.Message) string {
-	b, err := proto.Marshal(m)
+	b, err := codec.GetCodec().Marshal(m)
 	if err != nil {
 		log.Fatalf("Could not marshal proto message: %v", err)
 	}
diff --git a/go.mod b/go.mod
index f83ae8336..6e76ac253 100644
--- a/go.mod
+++ b/go.mod
@@ -38,7 +38,7 @@ require (
 	github.com/docker/go-connections v0.4.0 // indirect
 	github.com/docker/go-units v0.4.0 // indirect
 	github.com/dustin/go-humanize v1.0.0 // indirect
-	github.com/gogo/protobuf v1.3.2
+	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b // indirect
 	github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
diff --git a/persistence/state.go b/persistence/state.go
deleted file mode 100644
index 5c3913140..000000000
--- a/persistence/state.go
+++ /dev/null
@@ -1,119 +0,0 @@
-package persistence
-
-import (
-	"bytes"
-	"crypto/sha256"
-	"encoding/hex"
-	"fmt"
-	"log"
-	"sort"
-
-	"github.com/celestiaorg/smt"
-	typesUtil "github.com/pokt-network/pocket/utility/types"
-	"google.golang.org/protobuf/proto"
-)
-
-type MerkleTree float64
-
-// A work-in-progress list of all the trees we need to update to maintain the overall state
-const (
-	// Actor  Merkle Trees
-	appMerkleTree MerkleTree = iota
-	valMerkleTree
-	fishMerkleTree
-	serviceNodeMerkleTree
-	accountMerkleTree
-	poolMerkleTree
-
-	// Data / State Merkle Trees
-	blocksMerkleTree
-	paramsMerkleTree
-	flagsMerkleTree
-
-	// Used for iteration purposes only - see https://stackoverflow.com/a/64178235/768439
-	lastMerkleTree
-)
-
-func newMerkleTrees() (map[MerkleTree]*smt.SparseMerkleTree, error) {
-	// We need a separate Merkle tree for each type of actor or storage
-	trees := make(map[MerkleTree]*smt.SparseMerkleTree, int(lastMerkleTree))
-
-	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
-		// TODO_IN_THIS_COMMIT: Rather than using `NewSimpleMap`, use a disk based key-value store
-		nodeStore := smt.NewSimpleMap()
-		valueStore := smt.NewSimpleMap()
-
-		trees[treeType] = smt.NewSparseMerkleTree(nodeStore, valueStore, sha256.New())
-	}
-	return trees, nil
-}
-
-func loadMerkleTrees(map[MerkleTree]*smt.SparseMerkleTree, error) {
-	log.Fatalf("loadMerkleTrees not implemented yet")
-}
-
-func (p *PostgresContext) updateStateHash() error {
-	// Update all the merkle trees
-	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
-		switch treeType {
-		case appMerkleTree:
-			apps, err := p.getApplicationsUpdatedAtHeight(p.Height)
-			if err != nil {
-				// TODO_IN_THIS_COMMIT: Update this error
-				return typesUtil.NewError(typesUtil.Code(42), "Couldn't figure out apps updated")
-			}
-			for _, app := range apps {
-				appBz, err := proto.Marshal(app)
-				if err != nil {
-					return err
-				}
-				// An update results in a create/update that is idempotent
-				addrBz, err := hex.DecodeString(app.Address)
-				if err != nil {
-					return err
-				}
-				if _, err := p.MerkleTrees[treeType].Update(addrBz, appBz); err != nil {
-					return err
-				}
-			}
-		case valMerkleTree:
-			fmt.Println("TODO: valMerkleTree not implemented")
-		case fishMerkleTree:
-			fmt.Println("TODO: fishMerkleTree not implemented")
-		case serviceNodeMerkleTree:
-			fmt.Println("TODO: serviceNodeMerkleTree not implemented")
-		case accountMerkleTree:
-			fmt.Println("TODO: accountMerkleTree not implemented")
-		case poolMerkleTree:
-			fmt.Println("TODO: poolMerkleTree not implemented")
-		case blocksMerkleTree:
-			// VERY VERY IMPORTANT DISCUSSION: What do we do here provided that `Commit`, which stores the block in the DB and tree
-			//                                 requires the quorumCert, which we receive at the very end of hotstuff consensus
-			fmt.Println("TODO: blocksMerkleTree not implemented")
-		case paramsMerkleTree:
-			fmt.Println("TODO: paramsMerkleTree not implemented")
-		case flagsMerkleTree:
-			fmt.Println("TODO: flagsMerkleTree not implemented")
-		default:
-			log.Fatalln("Not handled yet in state commitment update", treeType)
-		}
-	}
-
-	// Get the root of each Merkle Tree
-	roots := make([][]byte, 0)
-	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
-		roots = append(roots, p.MerkleTrees[treeType].Root())
-	}
-
-	// Sort the merkle roots lexicographically
-	sort.Slice(roots, func(r1, r2 int) bool {
-		return bytes.Compare(roots[r1], roots[r2]) < 0
-	})
-
-	// Get the state hash
-	rootsConcat := bytes.Join(roots, []byte{})
-	stateHash := sha256.Sum256(rootsConcat)
-
-	p.stateHash = stateHash[:]
-	return nil
-}

From 4672e650207ef9dbdcd02b84c1f3fa2bac8ce902 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 26 Sep 2022 15:21:47 -0700
Subject: [PATCH 032/227] Removed additional persistence related code

---
 persistence/StateHash.md                  | 194 ----------------------
 persistence/proto/block_persistence.proto |  13 --
 persistence/state_test.go                 |  15 --
 3 files changed, 222 deletions(-)
 delete mode 100644 persistence/StateHash.md
 delete mode 100644 persistence/proto/block_persistence.proto
 delete mode 100644 persistence/state_test.go

diff --git a/persistence/StateHash.md b/persistence/StateHash.md
deleted file mode 100644
index cfc54af52..000000000
--- a/persistence/StateHash.md
+++ /dev/null
@@ -1,194 +0,0 @@
-Remaining tasks:
-
-1.  Simplify interfaces in utility & persistence (make it simple and clear)
-2.  How do we revert changes to the merkle trees?
-3.  Draw an end-to-end diagram of everything and the data flow
-
-## References:
-
-- https://github.com/cosmos/cosmos-sdk/discussions/9158
-- https://github.com/cosmos/cosmos-sdk/pull/8012
-- https://github.com/cosmos/cosmos-sdk/discussions/8297
-- https://github.com/cosmos/cosmos-sdk/discussions/8297
-- https://paper.dropbox.com/doc/State-commitments-and-storage-review--BpuF08OSksSkLeErjf66jrOAAg-wKl2RINZWD9I0DUmZIFwQ
-- https://arxiv.org/pdf/1803.05069.pdf
-
-## Open questions:
-
-1. Review flows
-2. How do we revert changes to the merkle trees?
-
-# This discussion is aimed at:
-
-1. Defining how we should compute the state hash
-2. Identify potential changes needed in the current codebase
-3. Propose next steps and actionable on implementation
-
-## Goals:
-
-- Define how the state hash will be computed
-- Propose the necessary changes in separate tasks
-- Implement each of the necessary pieces
-
-## Non-goals:
-
-- Choice/decision of Merkle Tree Design & Implementation
-- Selection of a key-value store engine
-
-## Primitives / non-negotiables:
-
-- We will be using Merkle Trees (and Merkle Proofs) for this design (i.e. not vector commitments)
-- We will be using a SQL engine for this (i.e. specifically PostgresSQL)
-- We will be using Protobufs (not Flatbuffers, json, yaml or other) for the schema
-
-## Necessary technical context:
-
-### DB Engines
-
-Insert table from here: [Merkle Tree Design & Implementation](https://tikv.org/deep-dive/key-value-engine/b-tree-vs-lsm/#summary)
-
-- Most **Key-Value Store DB** Engines use **LSM-trees** -> good for writes
-- Most **SQL DB** Engines use **B-Trees** -> good for reads
-
-_Basically all but there can be exceptions_
-
-### Addressable Merkle Trees
-
-State is stored use an Account Based (non UTXO) based Modle
-
-Insert image from: https://www.horizen.io/blockchain-academy/technology/expert/utxo-vs-account-model/#:~:text=The%20UTXO%20model%20is%20a,constructions%2C%20as%20well%20a%20sharding.
-
----
-
-### Data Flow
-
-## Basics:
-
-1. Get each actor (flag, param, etc...) updated at a certain height (the context's height)
-2. Compute the protobuf (the deterministic schema we use as source of truth)
-3. Serialize the data struct
-4. Update the corresponding merkle tree
-5. Compute a state hash from the aggregated roots of all trees as per pokt-network/pocket-network-protocol@main/persistence#562-state-transition-sequence-diagram
-
-## Q&A
-
-Q: Can the SQL Engine be changed?
-A: Yes
-
-Q: Can the SQL Engine be removed altogether?
-A: Yes, but hard
-
-Q: Can the protobuf schema change?
-A: Yes, but out-of-scope
-
-Q: Can protobufs be replaced?
-A: Maybe, but out-of-scope
-
----
-
-Learnings / Ideas:
-
-- Consolidate `UtilActorType` and `persistence.ActorType`
-- `modules.Actors` interface vs `types.Actor` in persistenceGenesis
-
-### Context Initialization
-
-```mermaid
-sequenceDiagram
-    %% autonumber
-    participant N as Node
-    participant C as Consensus
-    participant U as Utility
-    participant P as Persistence
-    participant PP as Persistence (PostgresDB)
-    participant PM as Persistence (MerkleTree)
-    participant P2P as P2P
-
-    %% Should this be P2P?
-    N-->>C: HandleMessage(anypb.Any)
-    critical NewRound Message
-        C->>+U: NewContext(height)
-        U->>P: NewRWContext(height)
-        P->>U: PersistenceRWContext
-        U->>U: Store persistenceContext
-        U->>-C: UtilityContext
-        C->>C: Store utilityContext
-        Note over C, PM: See 'Block Application'
-    end
-    Note over N, P2P: Hotstuff lifecycle
-    N-->>C: HandleMessage(anypb.Any)
-    critical Decide Message
-        Note over C, PM: See 'Block Commit'
-    end
-```
-
-### Block Application
-
-```mermaid
-sequenceDiagram
-    participant C as Consensus
-    participant U as Utility
-    participant P as Persistence
-    participant PP as Persistence (PostgresDB)
-    participant PM as Persistence (MerkleTree)
-
-    alt as leader
-        C->>+U: GetProposalTransactions(proposer, maxTxBz, [lastVal])
-        U->>U: reap mempool
-        U->>-C: txs
-        Note over C, U: Perform replica behaviour
-    else as replica
-        C->>+U: ApplyBlock(height, proposer, txs, lastVals)
-        loop Update DB: for each operation in tx
-            U->>P: ReadOp | WriteOp
-            P->>PP: ReadOp | WriteOp
-            PP->>P: data | ok
-            P->>U: data | ok
-            U->>U: validate
-            U->>P: StoreTransaction(tx)
-            P->>P: store locally
-            P->>U: ok
-        end
-        U->>+P: UpdateAppHash()
-        loop for each protocol actor type
-            P->>PP: GetActorsUpdate(height)
-            PP->>P: actors
-            loop Update Tree: for each actor
-                P->>PM: Update(addr, serialized(actor))
-                PM->>P: ok
-            end
-            P->>PM: GetRoot()
-            PM->>P: rootHash
-        end
-        P->>P: computeStateHash(rootHashes)
-        P->>-U: stateHash
-        U->>-C: hash
-    end
-```
-
-### Block Commit
-
-```mermaid
-sequenceDiagram
-    %% autonumber
-    participant C as Consensus
-    participant U as Utility
-    participant P as Persistence
-    participant PP as Persistence (PostgresDB)
-    participant PK as Persistence (Key-Value Store)
-
-    C->>U: CommitContext(quorumCert)
-    U->>P: Commit(proposerAddr, quorumCert)
-    P->>P: create typesPer.Block
-    P->>PP: insertBlock(block)
-    PP->>P: ok
-    P->>PK: Put(height, block)
-    PK->>P: ok
-    P->>P: commit tx
-    P->>U: ok
-    U->>P: Release()
-    P->>U: ok
-    C->>U: Release()
-    U->>C: ok
-    C->>C: release utilityContext
-```
diff --git a/persistence/proto/block_persistence.proto b/persistence/proto/block_persistence.proto
deleted file mode 100644
index 0c314690d..000000000
--- a/persistence/proto/block_persistence.proto
+++ /dev/null
@@ -1,13 +0,0 @@
-syntax = "proto3";
-package persistence;
-
-option go_package = "github.com/pokt-network/pocket/persistence/types";
-
-message Block {
-    uint64 height = 1;
-    string hash = 2;
-    string prevHash = 3;
-    bytes proposerAddress = 4;
-    bytes quorumCertificate = 5;
-    repeated bytes transactions = 6;
-}
\ No newline at end of file
diff --git a/persistence/state_test.go b/persistence/state_test.go
deleted file mode 100644
index 9570f4c00..000000000
--- a/persistence/state_test.go
+++ /dev/null
@@ -1,15 +0,0 @@
-package persistence
-
-import "testing"
-
-func TestStateHash_InitializeTrees(t *testing.T) {
-
-}
-
-func TestStateHash_LoadTrees(t *testing.T) {
-
-}
-
-func TestStateHash_ComputeStateHash(t *testing.T) {
-
-}

From 5c83fd5b7f8d305fe7a8c9eb79c704b0bff785af Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 26 Sep 2022 15:21:59 -0700
Subject: [PATCH 033/227] Added initialization flow for AppHash

---
 shared/docs/flows/AppHash.md | 36 ++++++++++++++++++++++++++++++++++++
 shared/docs/flows/README.md  |  3 +++
 2 files changed, 39 insertions(+)
 create mode 100644 shared/docs/flows/AppHash.md
 create mode 100644 shared/docs/flows/README.md

diff --git a/shared/docs/flows/AppHash.md b/shared/docs/flows/AppHash.md
new file mode 100644
index 000000000..51a1824b0
--- /dev/null
+++ b/shared/docs/flows/AppHash.md
@@ -0,0 +1,36 @@
+# AppHash
+
+## Context Initialization
+
+```mermaid
+sequenceDiagram
+    %% autonumber
+    participant N as Node
+    participant C as Consensus
+    participant U as Utility
+    participant P as Persistence
+    participant PP as Persistence (PostgresDB)
+    participant PM as Persistence (MerkleTree)
+    participant P2P as P2P
+
+    %% Should this be P2P?
+    N-->>C: HandleMessage(anypb.Any)
+    critical NewRound Message
+        C->>+U: NewContext(height)
+        U->>P: NewRWContext(height)
+        P->>U: PersistenceRWContext
+        U->>U: Store persistenceContext
+        U->>-C: UtilityContext
+        C->>C: Store utilityContext
+        Note over C, PM: See 'Block Application'
+    end
+    Note over N, P2P: Hotstuff lifecycle
+    N-->>C: HandleMessage(anypb.Any)
+    critical Decide Message
+        Note over C, PM: See 'Block Commit'
+    end
+```
+
+## Block Application
+
+## Block Commit
diff --git a/shared/docs/flows/README.md b/shared/docs/flows/README.md
new file mode 100644
index 000000000..cb4e5d663
--- /dev/null
+++ b/shared/docs/flows/README.md
@@ -0,0 +1,3 @@
+# Flows
+
+The purpose of [shared/flows](./) is to document cross-module communication for end-to-end behaviour that has cross-module dependencies and and depends on the interfaces exposed by the interfaces exposed in [shared/modules](../modules).

From 8c6a923eb874814cf8eefe5c7f244d9280193e07 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 26 Sep 2022 16:53:05 -0700
Subject: [PATCH 034/227] make develop_test passed

---
 consensus/CHANGELOG.md                  | 31 +++++++++++++++++++++++++
 consensus/consensus_tests/utils_test.go |  4 ++--
 go.mod                                  |  1 -
 go.sum                                  |  2 --
 4 files changed, 33 insertions(+), 5 deletions(-)

diff --git a/consensus/CHANGELOG.md b/consensus/CHANGELOG.md
index 64d55cba0..8dab5b81c 100644
--- a/consensus/CHANGELOG.md
+++ b/consensus/CHANGELOG.md
@@ -7,8 +7,39 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.0.3] - 2022-09-26
+
+Consensus logic
+
+- Pass in a list of messages to `findHighQC` instead of a hotstuff step
+- Made `CreateProposeMessage` and `CreateVotemessage` accept explicit values, identifying some bugs along the way
+- Made sure to call `applyBlock` when using `highQC` from previous round
+- Moved business logic for `prepareAndApplyBlock` into `hotstuff_leader.go`
+- Removed `MaxBlockBytes` and storing the consensus genesis type locally as is
+
+Consensus cleanup
+
+- Using appropriate getters for protocol types in the hotstuff lifecycle
+- Replaced `proto.Marshal` with `codec.GetCodec().Marshal`
+- Reorganized and cleaned up the code in `consensus/block.go`
+- Consolidated & removed a few `TODO`s throughout the consensus module
+- Added TECHDEBT and TODOs that will be require for a real block lifecycle
+- Fixed typo in `hotstuff_types.proto`
+- Moved the hotstuff handler interface to `consensus/hotstuff_handler.go`
+
+Consensus testing
+
+- Improved mock module initialization in `consensus/consensus_tests/utils_test.go`
+
+General
+
+- Added a diagram for `AppHash` related `ContextInitialization`
+- Added `Makefile` keywords for `TODO`
+
 ## [0.0.0.2] - 2022-08-25
+
 **Encapsulate structures previously in shared [#163](github.com/pokt-network/pocket/issues/163)**
+
 - Ensured proto structures implement shared interfaces
 - `ConsensusConfig` uses shared interfaces in order to accept `MockConsensusConfig` in test_artifacts
 - `ConsensusGenesisState` uses shared interfaces in order to accept `MockConsensusGenesisState` in test_artifacts
diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index ff716ce2c..2749968e5 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -367,8 +367,8 @@ func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 		ApplyBlock(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
 		Return(appHash, nil).
 		AnyTimes()
-	utilityContextMock.EXPECT().CommitContext(gomock.Any()).Return(nil).AnyTimes()
-	utilityContextMock.EXPECT().ReleaseContext().Return(nil).AnyTimes()
+	utilityContextMock.EXPECT().CommitPersistenceContext().Return(nil).AnyTimes()
+	utilityContextMock.EXPECT().ReleaseContext().Return().AnyTimes()
 
 	return utilityContextMock
 }
diff --git a/go.mod b/go.mod
index 6e76ac253..54191cb69 100644
--- a/go.mod
+++ b/go.mod
@@ -20,7 +20,6 @@ require (
 )
 
 require (
-	github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884
 	github.com/dgraph-io/badger/v3 v3.2103.2
 	github.com/jackc/pgconn v1.11.0
 	github.com/jordanorelli/lexnum v0.0.0-20141216151731-460eeb125754
diff --git a/go.sum b/go.sum
index 8c2cca931..d064b7f46 100644
--- a/go.sum
+++ b/go.sum
@@ -61,8 +61,6 @@ github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+Ce
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/boombuler/barcode v1.0.0/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8=
-github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884 h1:iRNKw2WmAbVgGMNYzDH5Y2yY3+jyxwEK9Hc5pwIjZAE=
-github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884/go.mod h1:/sdYDakowo/XaxS2Fl7CBqtuf/O2uTqF2zmAUFAtAiw=
 github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4=
 github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=

From 62a51ea37f692616e2b00adfeff511d83c13be14 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 26 Sep 2022 17:10:03 -0700
Subject: [PATCH 035/227] Added call to StoreBlock back

---
 consensus/block.go | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/consensus/block.go b/consensus/block.go
index df5d82268..a0c2d2929 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -5,11 +5,29 @@ import (
 	"unsafe"
 
 	typesCons "github.com/pokt-network/pocket/consensus/types"
+	"github.com/pokt-network/pocket/shared/codec"
 )
 
 func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
 
+	// Store the block in the KV store
+	codec := codec.GetCodec()
+	blockProtoBytes, err := codec.Marshal(block)
+	if err != nil {
+		return err
+	}
+
+	// IMPROVE(olshansky): temporary solution. `ApplyBlock` above applies the
+	// transactions to the postgres database, and this stores it in the KV store upon commitment.
+	// Instead of calling this directly, an alternative solution is to store the block metadata in
+	// the persistence context and have `CommitPersistenceContext` do this under the hood. However,
+	// additional `Block` metadata will need to be passed through and may change when we merkle the
+	// state hash.
+	if err := m.UtilityContext.StoreBlock(blockProtoBytes); err != nil {
+		return err
+	}
+
 	// Commit the utility context
 	if err := m.UtilityContext.CommitPersistenceContext(); err != nil {
 		return err

From 8f61b6f3e165bfebbafbf696148f5c4bd294f663 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 26 Sep 2022 17:24:27 -0700
Subject: [PATCH 036/227] Avoiding anypb in a few places in the consensus code

---
 consensus/consensus_tests/utils_test.go |  8 +++++---
 consensus/helpers.go                    |  5 ++---
 consensus/module.go                     | 12 ++++++++----
 shared/codec/codec.go                   |  4 ++++
 4 files changed, 19 insertions(+), 10 deletions(-)

diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 2749968e5..10f4758d2 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -14,6 +14,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/debug"
 	"github.com/pokt-network/pocket/shared/test_artifacts"
 
@@ -25,7 +26,6 @@ import (
 	"github.com/pokt-network/pocket/shared/modules"
 	modulesMock "github.com/pokt-network/pocket/shared/modules/mocks"
 	"github.com/stretchr/testify/require"
-	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/anypb"
 )
 
@@ -226,10 +226,12 @@ func WaitForNetworkConsensusMessages(
 ) (messages []*anypb.Any, err error) {
 
 	includeFilter := func(m *anypb.Any) bool {
-		var hotstuffMessage typesCons.HotstuffMessage
-		err := anypb.UnmarshalTo(m, &hotstuffMessage, proto.UnmarshalOptions{})
+		msg, err := codec.GetCodec().FromAny(m)
 		require.NoError(t, err)
 
+		hotstuffMessage, ok := msg.(*typesCons.HotstuffMessage)
+		require.True(t, ok)
+
 		return hotstuffMessage.Type == hotstuffMsgType && hotstuffMessage.Step == step
 	}
 
diff --git a/consensus/helpers.go b/consensus/helpers.go
index b59ac6397..d089d0338 100644
--- a/consensus/helpers.go
+++ b/consensus/helpers.go
@@ -12,7 +12,6 @@ import (
 
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 	cryptoPocket "github.com/pokt-network/pocket/shared/crypto"
-	"google.golang.org/protobuf/types/known/anypb"
 )
 
 // These constants and variables are wrappers around the autogenerated protobuf types and were
@@ -142,7 +141,7 @@ func (m *ConsensusModule) sendToNode(msg *typesCons.HotstuffMessage) {
 	}
 
 	m.nodeLog(typesCons.SendingMessage(msg, *m.LeaderId))
-	anyConsensusMessage, err := anypb.New(msg)
+	anyConsensusMessage, err := codec.GetCodec().ToAny(msg)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateConsensusMessage.Error(), err)
 		return
@@ -155,7 +154,7 @@ func (m *ConsensusModule) sendToNode(msg *typesCons.HotstuffMessage) {
 
 func (m *ConsensusModule) broadcastToNodes(msg *typesCons.HotstuffMessage) {
 	m.nodeLog(typesCons.BroadcastingMessage(msg))
-	anyConsensusMessage, err := anypb.New(msg)
+	anyConsensusMessage, err := codec.GetCodec().ToAny(msg)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateConsensusMessage.Error(), err)
 		return
diff --git a/consensus/module.go b/consensus/module.go
index f49e4a97e..4c8e7d94f 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -8,9 +8,9 @@ import (
 
 	"github.com/pokt-network/pocket/consensus/leader_election"
 	typesCons "github.com/pokt-network/pocket/consensus/types"
+	"github.com/pokt-network/pocket/shared/codec"
 	cryptoPocket "github.com/pokt-network/pocket/shared/crypto"
 	"github.com/pokt-network/pocket/shared/test_artifacts"
-	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/anypb"
 
 	consensusTelemetry "github.com/pokt-network/pocket/consensus/telemetry"
@@ -220,11 +220,15 @@ func (m *ConsensusModule) SetBus(pocketBus modules.Bus) {
 func (m *ConsensusModule) HandleMessage(message *anypb.Any) error {
 	switch message.MessageName() {
 	case HotstuffMessage:
-		var hotstuffMessage typesCons.HotstuffMessage
-		if err := anypb.UnmarshalTo(message, &hotstuffMessage, proto.UnmarshalOptions{}); err != nil {
+		msg, err := codec.GetCodec().FromAny(message)
+		if err != nil {
 			return err
 		}
-		if err := m.handleHotstuffMessage(&hotstuffMessage); err != nil {
+		hotstuffMessage, ok := msg.(*typesCons.HotstuffMessage)
+		if !ok {
+			return fmt.Errorf("failed to cast message to HotstuffMessage")
+		}
+		if err := m.handleHotstuffMessage(hotstuffMessage); err != nil {
 			return err
 		}
 	case UtilityMessage:
diff --git a/shared/codec/codec.go b/shared/codec/codec.go
index ac7765673..a41fe2e0b 100644
--- a/shared/codec/codec.go
+++ b/shared/codec/codec.go
@@ -5,6 +5,8 @@ import (
 	"google.golang.org/protobuf/types/known/anypb"
 )
 
+// TODO: Use generics in place of `proto.Message` in the interface below
+//       so every caller does not need to do in place casting.
 type Codec interface { // TODO (Team) move to shared. Possibly rename
 	Marshal(proto.Message) ([]byte, error)
 	Unmarshal([]byte, proto.Message) error
@@ -14,6 +16,8 @@ type Codec interface { // TODO (Team) move to shared. Possibly rename
 
 var _ Codec = &ProtoCodec{}
 
+// TODO: Need to define a type like `type ProtoAny anypb.Any` so that we are
+//       mixing protobufs and a centralized codec structure throughout the codebase.
 type ProtoCodec struct{}
 
 func (p *ProtoCodec) Marshal(message proto.Message) ([]byte, error) {

From 1200203ecd519be875a82a097764410a30970439 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 26 Sep 2022 17:31:24 -0700
Subject: [PATCH 037/227] Fixed unit tests

---
 consensus/consensus_tests/utils_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 10f4758d2..b5e3cf71a 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -371,6 +371,7 @@ func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 		AnyTimes()
 	utilityContextMock.EXPECT().CommitPersistenceContext().Return(nil).AnyTimes()
 	utilityContextMock.EXPECT().ReleaseContext().Return().AnyTimes()
+	utilityContextMock.EXPECT().StoreBlock(gomock.Any()).Return(nil).AnyTimes()
 
 	return utilityContextMock
 }

From 0e039766468d0d46809d0f8d8389b1f79e7fef5f Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 26 Sep 2022 20:35:11 -0700
Subject: [PATCH 038/227] Add back stateHash implementation

---
 consensus/block.go                        |  49 ++----
 consensus/consensus_tests/utils_test.go   |   5 +-
 consensus/types/block.go                  |  14 ++
 go.mod                                    |   3 +-
 go.sum                                    |   2 +
 persistence/StateHash.md                  | 194 ++++++++++++++++++++++
 persistence/application.go                |  51 ++++++
 persistence/block.go                      |  42 ++++-
 persistence/context.go                    |  26 ++-
 persistence/db.go                         |   8 +
 persistence/debug.go                      |   2 +-
 persistence/genesis.go                    |   4 +-
 persistence/kvstore/kvstore.go            |  35 +++-
 persistence/module.go                     |  31 +++-
 persistence/proto/block_persistence.proto |  13 ++
 persistence/shared_sql.go                 |  40 ++++-
 persistence/state.go                      | 119 +++++++++++++
 persistence/state_test.go                 |  15 ++
 persistence/test/module_test.go           |   4 +-
 persistence/types/base_actor.go           |   7 +-
 persistence/types/protocol_actor.go       |   3 +
 persistence/types/shared_sql.go           |   5 +
 shared/codec/codec.go                     |   4 -
 shared/docs/flows/AppHash.md              |  36 ----
 shared/docs/flows/README.md               |   3 -
 shared/indexer/indexer.go                 |   3 +-
 shared/modules/persistence_module.go      |  79 +++++++--
 shared/modules/utility_module.go          |   9 +-
 shared/test_artifacts/generator.go        |   5 +-
 shared/types/genesis/validator.go         |  49 ++++++
 utility/block.go                          |  53 ++----
 utility/context.go                        |  28 ++--
 utility/test/block_test.go                |  18 +-
 33 files changed, 756 insertions(+), 203 deletions(-)
 create mode 100644 consensus/types/block.go
 create mode 100644 persistence/StateHash.md
 create mode 100644 persistence/proto/block_persistence.proto
 create mode 100644 persistence/state.go
 create mode 100644 persistence/state_test.go
 delete mode 100644 shared/docs/flows/AppHash.md
 delete mode 100644 shared/docs/flows/README.md
 create mode 100644 shared/types/genesis/validator.go

diff --git a/consensus/block.go b/consensus/block.go
index a0c2d2929..f483ce587 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -5,42 +5,8 @@ import (
 	"unsafe"
 
 	typesCons "github.com/pokt-network/pocket/consensus/types"
-	"github.com/pokt-network/pocket/shared/codec"
 )
 
-func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
-	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
-
-	// Store the block in the KV store
-	codec := codec.GetCodec()
-	blockProtoBytes, err := codec.Marshal(block)
-	if err != nil {
-		return err
-	}
-
-	// IMPROVE(olshansky): temporary solution. `ApplyBlock` above applies the
-	// transactions to the postgres database, and this stores it in the KV store upon commitment.
-	// Instead of calling this directly, an alternative solution is to store the block metadata in
-	// the persistence context and have `CommitPersistenceContext` do this under the hood. However,
-	// additional `Block` metadata will need to be passed through and may change when we merkle the
-	// state hash.
-	if err := m.UtilityContext.StoreBlock(blockProtoBytes); err != nil {
-		return err
-	}
-
-	// Commit the utility context
-	if err := m.UtilityContext.CommitPersistenceContext(); err != nil {
-		return err
-	}
-	// Release the utility context
-	m.UtilityContext.ReleaseContext()
-	m.UtilityContext = nil
-	// Update the last app hash
-	m.lastAppHash = block.BlockHeader.Hash
-
-	return nil
-}
-
 // TODO: Add unit tests specific to block validation
 func (m *ConsensusModule) validateBlockBasic(block *typesCons.Block) error {
 	if block == nil && m.Step != NewRound {
@@ -86,3 +52,18 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 
 	return nil
 }
+
+func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
+	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
+
+	// Commit and release the context
+	if err := m.UtilityContext.CommitContext(block.BlockHeader.QuorumCertificate); err != nil {
+		return err
+	}
+	m.UtilityContext.ReleaseContext()
+	m.UtilityContext = nil
+
+	m.lastAppHash = block.BlockHeader.Hash
+
+	return nil
+}
diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index b5e3cf71a..3499f604d 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -369,9 +369,8 @@ func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 		ApplyBlock(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
 		Return(appHash, nil).
 		AnyTimes()
-	utilityContextMock.EXPECT().CommitPersistenceContext().Return(nil).AnyTimes()
-	utilityContextMock.EXPECT().ReleaseContext().Return().AnyTimes()
-	utilityContextMock.EXPECT().StoreBlock(gomock.Any()).Return(nil).AnyTimes()
+	utilityContextMock.EXPECT().CommitContext(gomock.Any()).Return(nil).AnyTimes()
+	utilityContextMock.EXPECT().ReleaseContext().Return(nil).AnyTimes()
 
 	return utilityContextMock
 }
diff --git a/consensus/types/block.go b/consensus/types/block.go
new file mode 100644
index 000000000..f6091b6b3
--- /dev/null
+++ b/consensus/types/block.go
@@ -0,0 +1,14 @@
+package types
+
+import (
+	"github.com/pokt-network/pocket/shared/codec"
+)
+
+func (b *Block) Bytes() ([]byte, error) {
+	codec := codec.GetCodec()
+	blockProtoBz, err := codec.Marshal(b)
+	if err != nil {
+		return nil, err
+	}
+	return blockProtoBz, nil
+}
diff --git a/go.mod b/go.mod
index 54191cb69..f83ae8336 100644
--- a/go.mod
+++ b/go.mod
@@ -20,6 +20,7 @@ require (
 )
 
 require (
+	github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884
 	github.com/dgraph-io/badger/v3 v3.2103.2
 	github.com/jackc/pgconn v1.11.0
 	github.com/jordanorelli/lexnum v0.0.0-20141216151731-460eeb125754
@@ -37,7 +38,7 @@ require (
 	github.com/docker/go-connections v0.4.0 // indirect
 	github.com/docker/go-units v0.4.0 // indirect
 	github.com/dustin/go-humanize v1.0.0 // indirect
-	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/gogo/protobuf v1.3.2
 	github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b // indirect
 	github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
diff --git a/go.sum b/go.sum
index d064b7f46..8c2cca931 100644
--- a/go.sum
+++ b/go.sum
@@ -61,6 +61,8 @@ github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+Ce
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/boombuler/barcode v1.0.0/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8=
+github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884 h1:iRNKw2WmAbVgGMNYzDH5Y2yY3+jyxwEK9Hc5pwIjZAE=
+github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884/go.mod h1:/sdYDakowo/XaxS2Fl7CBqtuf/O2uTqF2zmAUFAtAiw=
 github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4=
 github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
diff --git a/persistence/StateHash.md b/persistence/StateHash.md
new file mode 100644
index 000000000..cfc54af52
--- /dev/null
+++ b/persistence/StateHash.md
@@ -0,0 +1,194 @@
+Remaining tasks:
+
+1.  Simplify interfaces in utility & persistence (make it simple and clear)
+2.  How do we revert changes to the merkle trees?
+3.  Draw an end-to-end diagram of everything and the data flow
+
+## References:
+
+- https://github.com/cosmos/cosmos-sdk/discussions/9158
+- https://github.com/cosmos/cosmos-sdk/pull/8012
+- https://github.com/cosmos/cosmos-sdk/discussions/8297
+- https://github.com/cosmos/cosmos-sdk/discussions/8297
+- https://paper.dropbox.com/doc/State-commitments-and-storage-review--BpuF08OSksSkLeErjf66jrOAAg-wKl2RINZWD9I0DUmZIFwQ
+- https://arxiv.org/pdf/1803.05069.pdf
+
+## Open questions:
+
+1. Review flows
+2. How do we revert changes to the merkle trees?
+
+# This discussion is aimed at:
+
+1. Defining how we should compute the state hash
+2. Identify potential changes needed in the current codebase
+3. Propose next steps and actionable on implementation
+
+## Goals:
+
+- Define how the state hash will be computed
+- Propose the necessary changes in separate tasks
+- Implement each of the necessary pieces
+
+## Non-goals:
+
+- Choice/decision of Merkle Tree Design & Implementation
+- Selection of a key-value store engine
+
+## Primitives / non-negotiables:
+
+- We will be using Merkle Trees (and Merkle Proofs) for this design (i.e. not vector commitments)
+- We will be using a SQL engine for this (i.e. specifically PostgresSQL)
+- We will be using Protobufs (not Flatbuffers, json, yaml or other) for the schema
+
+## Necessary technical context:
+
+### DB Engines
+
+Insert table from here: [Merkle Tree Design & Implementation](https://tikv.org/deep-dive/key-value-engine/b-tree-vs-lsm/#summary)
+
+- Most **Key-Value Store DB** Engines use **LSM-trees** -> good for writes
+- Most **SQL DB** Engines use **B-Trees** -> good for reads
+
+_Basically all but there can be exceptions_
+
+### Addressable Merkle Trees
+
+State is stored use an Account Based (non UTXO) based Modle
+
+Insert image from: https://www.horizen.io/blockchain-academy/technology/expert/utxo-vs-account-model/#:~:text=The%20UTXO%20model%20is%20a,constructions%2C%20as%20well%20a%20sharding.
+
+---
+
+### Data Flow
+
+## Basics:
+
+1. Get each actor (flag, param, etc...) updated at a certain height (the context's height)
+2. Compute the protobuf (the deterministic schema we use as source of truth)
+3. Serialize the data struct
+4. Update the corresponding merkle tree
+5. Compute a state hash from the aggregated roots of all trees as per pokt-network/pocket-network-protocol@main/persistence#562-state-transition-sequence-diagram
+
+## Q&A
+
+Q: Can the SQL Engine be changed?
+A: Yes
+
+Q: Can the SQL Engine be removed altogether?
+A: Yes, but hard
+
+Q: Can the protobuf schema change?
+A: Yes, but out-of-scope
+
+Q: Can protobufs be replaced?
+A: Maybe, but out-of-scope
+
+---
+
+Learnings / Ideas:
+
+- Consolidate `UtilActorType` and `persistence.ActorType`
+- `modules.Actors` interface vs `types.Actor` in persistenceGenesis
+
+### Context Initialization
+
+```mermaid
+sequenceDiagram
+    %% autonumber
+    participant N as Node
+    participant C as Consensus
+    participant U as Utility
+    participant P as Persistence
+    participant PP as Persistence (PostgresDB)
+    participant PM as Persistence (MerkleTree)
+    participant P2P as P2P
+
+    %% Should this be P2P?
+    N-->>C: HandleMessage(anypb.Any)
+    critical NewRound Message
+        C->>+U: NewContext(height)
+        U->>P: NewRWContext(height)
+        P->>U: PersistenceRWContext
+        U->>U: Store persistenceContext
+        U->>-C: UtilityContext
+        C->>C: Store utilityContext
+        Note over C, PM: See 'Block Application'
+    end
+    Note over N, P2P: Hotstuff lifecycle
+    N-->>C: HandleMessage(anypb.Any)
+    critical Decide Message
+        Note over C, PM: See 'Block Commit'
+    end
+```
+
+### Block Application
+
+```mermaid
+sequenceDiagram
+    participant C as Consensus
+    participant U as Utility
+    participant P as Persistence
+    participant PP as Persistence (PostgresDB)
+    participant PM as Persistence (MerkleTree)
+
+    alt as leader
+        C->>+U: GetProposalTransactions(proposer, maxTxBz, [lastVal])
+        U->>U: reap mempool
+        U->>-C: txs
+        Note over C, U: Perform replica behaviour
+    else as replica
+        C->>+U: ApplyBlock(height, proposer, txs, lastVals)
+        loop Update DB: for each operation in tx
+            U->>P: ReadOp | WriteOp
+            P->>PP: ReadOp | WriteOp
+            PP->>P: data | ok
+            P->>U: data | ok
+            U->>U: validate
+            U->>P: StoreTransaction(tx)
+            P->>P: store locally
+            P->>U: ok
+        end
+        U->>+P: UpdateAppHash()
+        loop for each protocol actor type
+            P->>PP: GetActorsUpdate(height)
+            PP->>P: actors
+            loop Update Tree: for each actor
+                P->>PM: Update(addr, serialized(actor))
+                PM->>P: ok
+            end
+            P->>PM: GetRoot()
+            PM->>P: rootHash
+        end
+        P->>P: computeStateHash(rootHashes)
+        P->>-U: stateHash
+        U->>-C: hash
+    end
+```
+
+### Block Commit
+
+```mermaid
+sequenceDiagram
+    %% autonumber
+    participant C as Consensus
+    participant U as Utility
+    participant P as Persistence
+    participant PP as Persistence (PostgresDB)
+    participant PK as Persistence (Key-Value Store)
+
+    C->>U: CommitContext(quorumCert)
+    U->>P: Commit(proposerAddr, quorumCert)
+    P->>P: create typesPer.Block
+    P->>PP: insertBlock(block)
+    PP->>P: ok
+    P->>PK: Put(height, block)
+    PK->>P: ok
+    P->>P: commit tx
+    P->>U: ok
+    U->>P: Release()
+    P->>U: ok
+    C->>U: Release()
+    U->>C: ok
+    C->>C: release utilityContext
+```
diff --git a/persistence/application.go b/persistence/application.go
index 0f2b88512..0bd6750bd 100644
--- a/persistence/application.go
+++ b/persistence/application.go
@@ -5,15 +5,66 @@ import (
 	"log"
 
 	"github.com/pokt-network/pocket/persistence/types"
+	"google.golang.org/protobuf/proto"
+
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
+func (p PostgresContext) UpdateApplicationsTree(apps []modules.Actor) error {
+	for _, app := range apps {
+		bzAddr, err := hex.DecodeString(app.GetAddress())
+		if err != nil {
+			return err
+		}
+
+		appBz, err := proto.Marshal(app.(*types.Actor))
+		if err != nil {
+			return err
+		}
+
+		// OPTIMIZE: This is the only line unique to `Application`
+		if _, err := p.MerkleTrees[appMerkleTree].Update(bzAddr, appBz); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (p PostgresContext) getApplicationsUpdatedAtHeight(height int64) (apps []*types.Actor, err error) {
+	// OPTIMIZE: This is the only line unique to `Application`
+	actors, err := p.GetActorsUpdated(types.ApplicationActor, height)
+	if err != nil {
+		return nil, err
+	}
+
+	apps = make([]*types.Actor, len(actors))
+	for _, actor := range actors {
+		app := &types.Actor{
+			ActorType:       types.ActorType_App,
+			Address:         actor.Address,
+			PublicKey:       actor.PublicKey,
+			Chains:          actor.Chains,
+			GenericParam:    actor.ActorSpecificParam,
+			StakedAmount:    actor.StakedTokens,
+			PausedHeight:    actor.PausedHeight,
+			UnstakingHeight: actor.UnstakingHeight,
+			Output:          actor.OutputAddress,
+		}
+		apps = append(apps, app)
+	}
+	return
+}
+
 func (p PostgresContext) GetAppExists(address []byte, height int64) (exists bool, err error) {
 	return p.GetExists(types.ApplicationActor, address, height)
 }
 
 func (p PostgresContext) GetApp(address []byte, height int64) (operator, publicKey, stakedTokens, maxRelays, outputAddress string, pauseHeight, unstakingHeight int64, chains []string, err error) {
 	actor, err := p.GetActor(types.ApplicationActor, address, height)
+	if err != nil {
+		return
+	}
 	operator = actor.Address
 	publicKey = actor.PublicKey
 	stakedTokens = actor.StakedTokens
diff --git a/persistence/block.go b/persistence/block.go
index aaee96364..5efa1b71e 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -5,6 +5,7 @@ import (
 	"encoding/hex"
 	"log"
 
+	"github.com/gogo/protobuf/proto"
 	"github.com/pokt-network/pocket/persistence/types"
 )
 
@@ -49,23 +50,46 @@ func (p PostgresContext) StoreTransaction(transactionProtoBytes []byte) error {
 	return nil
 }
 
-func (p PostgresContext) StoreBlock(blockProtoBytes []byte) error {
-	// INVESTIGATE: Note that we are writing this directly to the blockStore. Depending on how
-	// the use of the PostgresContext evolves, we may need to write this to `ContextStore` and copy
-	// over to `BlockStore` when the block is committed.
-	return p.blockstore.Put(heightToBytes(p.Height), blockProtoBytes)
-}
-
-func (p PostgresContext) InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error {
+func (p PostgresContext) insertBlock(block *types.Block) error {
 	ctx, tx, err := p.GetCtxAndTx()
 	if err != nil {
 		return err
 	}
 
-	_, err = tx.Exec(ctx, types.InsertBlockQuery(height, hash, proposerAddr, quorumCert))
+	_, err = tx.Exec(ctx, types.InsertBlockQuery(block.Height, block.Hash, block.ProposerAddress, block.QuorumCertificate))
 	return err
 }
 
+func (p PostgresContext) storeBlock(block *types.Block) error {
+	blockBz, err := proto.Marshal(block)
+	if err != nil {
+		return err
+	}
+
+	return p.blockstore.Put(heightToBytes(p.Height), blockBz)
+}
+
+func (p PostgresContext) getBlock(proposerAddr []byte, quorumCert []byte) (*types.Block, error) {
+	prevHash, err := p.GetBlockHash(p.Height - 1)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: get this from the transactions that were store via `StoreTransaction`
+	txs := make([][]byte, 0)
+
+	block := &types.Block{
+		Height:            uint64(p.Height),
+		Hash:              string(p.stateHash),
+		PrevHash:          string(prevHash),
+		ProposerAddress:   proposerAddr,
+		QuorumCertificate: quorumCert,
+		Transactions:      txs,
+	}
+
+	return block, nil
+}
+
 // CLEANUP: Should this be moved to a shared directory?
 func heightToBytes(height int64) []byte {
 	heightBytes := make([]byte, 8)
diff --git a/persistence/context.go b/persistence/context.go
index fd44e3af1..8224a229a 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -15,25 +15,39 @@ func (p PostgresContext) RollbackToSavePoint(bytes []byte) error {
 	return p.GetTx().Rollback(context.TODO())
 }
 
-func (p PostgresContext) AppHash() ([]byte, error) {
-	log.Println("TODO: AppHash not implemented")
-	return []byte("A real app hash, I am not"), nil
+func (p PostgresContext) UpdateAppHash() ([]byte, error) {
+	if err := p.updateStateHash(); err != nil {
+		return nil, err
+	}
+	return p.stateHash, nil
 }
 
 func (p PostgresContext) Reset() error {
 	panic("TODO: PostgresContext Reset not implemented")
 }
 
-func (p PostgresContext) Commit() error {
+func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
+	block, err := p.getBlock(proposerAddr, quorumCert)
+	if err != nil {
+		return err
+	}
+
+	if err := p.insertBlock(block); err != nil {
+		return err
+	}
+
+	if err := p.storeBlock(block); err != nil {
+		return err
+	}
+
 	ctx := context.TODO()
-	if err := p.GetTx().Commit(context.TODO()); err != nil {
+	if err := p.GetTx().Commit(ctx); err != nil {
 		return err
 	}
 	if err := p.conn.Close(ctx); err != nil {
 		log.Println("[TODO][ERROR] Implement connection pooling. Error when closing DB connecting...", err)
-
 	}
 	return nil
 }
diff --git a/persistence/db.go b/persistence/db.go
index 3a495596c..b8a974939 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -7,6 +7,7 @@ import (
 
 	"github.com/pokt-network/pocket/persistence/types"
 
+	"github.com/celestiaorg/smt"
 	"github.com/jackc/pgconn"
 	"github.com/jackc/pgx/v4"
 	"github.com/pokt-network/pocket/persistence/kvstore"
@@ -40,6 +41,13 @@ type PostgresContext struct {
 	conn       *pgx.Conn
 	tx         pgx.Tx
 	blockstore kvstore.KVStore
+
+	stateHash []byte
+	// IMPROVE: Depending on how the use of `PostgresContext` evolves, we may be able to get
+	// access to these directly via the postgres module.
+	PostgresDB  *pgx.Conn
+	BlockStore  kvstore.KVStore                      // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context)
+	MerkleTrees map[MerkleTree]*smt.SparseMerkleTree // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context)
 }
 
 func (pg *PostgresContext) GetCtxAndTx() (context.Context, pgx.Tx, error) {
diff --git a/persistence/debug.go b/persistence/debug.go
index 3fdc583a4..e0e3b6e5e 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -44,7 +44,7 @@ func (m *PersistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 
 func (m *PersistenceModule) clearState(_ *debug.DebugMessage) {
 	context, err := m.NewRWContext(-1)
-	defer context.Commit()
+	defer context.Commit(nil, nil)
 	if err != nil {
 		log.Printf("Error creating new context: %s \n", err)
 		return
diff --git a/persistence/genesis.go b/persistence/genesis.go
index 1c7e82f14..a6eefaa90 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -149,7 +149,7 @@ func (m *PersistenceModule) populateGenesisState(state *types.PersistenceGenesis
 		log.Fatalf("an error occurred initializing flags: %s", err.Error())
 	}
 
-	if err = rwContext.Commit(); err != nil {
+	if err = rwContext.Commit(nil, nil); err != nil {
 		log.Fatalf("an error occurred during commit() on genesis state %s ", err.Error())
 	}
 }
@@ -316,7 +316,7 @@ func (p PostgresContext) GetAllFishermen(height int64) (f []modules.Actor, err e
 	return
 }
 
-// TODO (Team) deprecate with interface #163 <Bumped to #149> as #163 is getting large
+// CONSOLIDATE: Consolidate `types.BaseActor` with `types.Actor`
 func (p PostgresContext) BaseActorToActor(ba types.BaseActor, actorType types.ActorType) *types.Actor {
 	actor := new(types.Actor)
 	actor.ActorType = actorType
diff --git a/persistence/kvstore/kvstore.go b/persistence/kvstore/kvstore.go
index 24613afc9..8636e4519 100644
--- a/persistence/kvstore/kvstore.go
+++ b/persistence/kvstore/kvstore.go
@@ -1,33 +1,47 @@
 package kvstore
 
 import (
+	"errors"
 	"log"
 
+	"github.com/celestiaorg/smt"
 	badger "github.com/dgraph-io/badger/v3"
 )
 
-// CLEANUP: move this structure to a shared module
 type KVStore interface {
 	// Lifecycle methods
 	Stop() error
 
 	// Accessors
 	// TODO: Add a proper iterator interface
-	Put(key []byte, value []byte) error
-	Get(key []byte) ([]byte, error)
 	// TODO: Add pagination for `GetAll`
 	GetAll(prefixKey []byte, descending bool) ([][]byte, error)
+
 	Exists(key []byte) (bool, error)
 	ClearAll() error
+
+	// Same interface as in `smt.MapStore``
+	Put(key, value []byte) error
+	Get(key []byte) ([]byte, error)
+	Delete(key []byte) error
 }
 
 var _ KVStore = &badgerKVStore{}
+var _ smt.MapStore = &badgerKVStore{}
+
+var (
+	ErrKVStoreExists    = errors.New("kvstore already exists")
+	ErrKVStoreNotExists = errors.New("kvstore does not exist")
+)
 
 type badgerKVStore struct {
 	db *badger.DB
 }
 
-func NewKVStore(path string) (KVStore, error) {
+// REFACTOR: Loads or creates a badgerDb at `path`. This may potentially need to be refactored
+// into `NewKVStore` and `LoadKVStore` depending on how state sync evolves by leveraging `os.Stat`
+// on the file path.
+func OpenKVStore(path string) (KVStore, error) {
 	db, err := badger.Open(badger.DefaultOptions(path))
 	if err != nil {
 		return nil, err
@@ -43,7 +57,7 @@ func NewMemKVStore() KVStore {
 	return badgerKVStore{db: db}
 }
 
-func (store badgerKVStore) Put(key []byte, value []byte) error {
+func (store badgerKVStore) Put(key, value []byte) error {
 	tx := store.db.NewTransaction(true)
 	defer tx.Discard()
 
@@ -55,6 +69,12 @@ func (store badgerKVStore) Put(key []byte, value []byte) error {
 	return tx.Commit()
 }
 
+// CONSOLIDATE: We might be able to remove the `KVStore` interface altogether if we end up using `smt.MapStore`
+// A wrapper around `Put` to conform to the `smt.MapStore` interface
+func (store *badgerKVStore) Set(key, value []byte) error {
+	return store.Put(key, value)
+}
+
 func (store badgerKVStore) Get(key []byte) ([]byte, error) {
 	tx := store.db.NewTransaction(false)
 	defer tx.Discard()
@@ -76,6 +96,11 @@ func (store badgerKVStore) Get(key []byte) ([]byte, error) {
 	return value, nil
 }
 
+func (store badgerKVStore) Delete(key []byte) error {
+	log.Fatalf("badgerKVStore.Delete not implemented yet")
+	return nil
+}
+
 func (store badgerKVStore) GetAll(prefix []byte, descending bool) (values [][]byte, err error) {
 	// INVESTIGATE: research `badger.views` for further improvements and optimizations
 	txn := store.db.NewTransaction(false)
diff --git a/persistence/module.go b/persistence/module.go
index 33bd827bd..6761bb22b 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -7,10 +7,10 @@ import (
 	"io/ioutil"
 	"log"
 
-	"github.com/pokt-network/pocket/persistence/types"
-
+	"github.com/celestiaorg/smt"
 	"github.com/jackc/pgx/v4"
 	"github.com/pokt-network/pocket/persistence/kvstore"
+	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 	"github.com/pokt-network/pocket/shared/test_artifacts"
 )
@@ -26,10 +26,19 @@ type PersistenceModule struct {
 	postgresURL string
 	nodeSchema  string
 	genesisPath string
-	blockStore  kvstore.KVStore // INVESTIGATE: We may need to create a custom `BlockStore` package in the future
 
 	// TECHDEBT: Need to implement context pooling (for writes), timeouts (for read & writes), etc...
 	writeContext *PostgresContext // only one write context is allowed at a time
+
+	// The connection to the PostgreSQL database
+	postgresConn *pgx.Conn
+	// A reference to the block key-value store
+	// INVESTIGATE: We may need to create a custom `BlockStore` package in the future.
+	blockStore kvstore.KVStore
+	// A mapping of context IDs to persistence contexts
+	// contexts map[contextId]modules.PersistenceRWContext
+	// Merkle trees
+	trees map[MerkleTree]*smt.SparseMerkleTree
 }
 
 const (
@@ -42,8 +51,10 @@ func Create(configPath, genesisPath string) (modules.PersistenceModule, error) {
 	if err != nil {
 		return nil, err
 	}
+
 	cfg := c.(*types.PersistenceConfig)
 	g, err := m.InitGenesis(genesisPath)
+
 	if err != nil {
 		return nil, err
 	}
@@ -69,8 +80,20 @@ func Create(configPath, genesisPath string) (modules.PersistenceModule, error) {
 		genesisPath:  genesisPath,
 		blockStore:   blockStore,
 		writeContext: nil,
+		// contexts:     make(map[contextId]modules.PersistenceContext),
+		trees: make(map[MerkleTree]*smt.SparseMerkleTree),
 	}
 
+	// DISCUSS_IN_THIS_COMMIT: We've been using the module function pattern, but this making `initializeTrees`
+	// be able to create and/or load trees outside the scope of the persistence module makes it easier to test.
+	trees, err := newMerkleTrees()
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO_IN_THIS_COMMIT: load trees from state
+	persistenceMod.trees = trees
+
 	// Determine if we should hydrate the genesis db or use the current state of the DB attached
 	if shouldHydrateGenesis, err := persistenceMod.shouldHydrateGenesisDb(); err != nil {
 		return nil, err
@@ -214,7 +237,7 @@ func initializeBlockStore(blockStorePath string) (kvstore.KVStore, error) {
 	if blockStorePath == "" {
 		return kvstore.NewMemKVStore(), nil
 	}
-	return kvstore.NewKVStore(blockStorePath)
+	return kvstore.OpenKVStore(blockStorePath)
 }
 
 // TODO(drewsky): Simplify and externalize the logic for whether genesis should be populated and
diff --git a/persistence/proto/block_persistence.proto b/persistence/proto/block_persistence.proto
new file mode 100644
index 000000000..0c314690d
--- /dev/null
+++ b/persistence/proto/block_persistence.proto
@@ -0,0 +1,13 @@
+syntax = "proto3";
+package persistence;
+
+option go_package = "github.com/pokt-network/pocket/persistence/types";
+
+message Block {
+    uint64 height = 1;
+    string hash = 2;
+    string prevHash = 3;
+    bytes proposerAddress = 4;
+    bytes quorumCertificate = 5;
+    repeated bytes transactions = 6;
+}
\ No newline at end of file
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
index 9f2c19a00..8eac77562 100644
--- a/persistence/shared_sql.go
+++ b/persistence/shared_sql.go
@@ -44,6 +44,36 @@ func (p *PostgresContext) GetExists(actorSchema types.ProtocolActorSchema, addre
 	return
 }
 
+func (p *PostgresContext) GetActorsUpdated(actorSchema types.ProtocolActorSchema, height int64) (actors []types.BaseActor, err error) {
+	ctx, tx, err := p.GetCtxAndTx()
+	if err != nil {
+		return
+	}
+
+	rows, err := tx.Query(ctx, actorSchema.GetUpdatedAtHeightQuery(height))
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	// OPTIMIZE: Consolidate logic with `GetActor` to reduce code footprint
+	var addr string
+	for rows.Next() {
+		if err = rows.Scan(&addr); err != nil {
+			return
+		}
+
+		actor, err := p.GetActor(actorSchema, []byte(addr), height)
+		if err != nil {
+			return nil, err
+		}
+
+		actors = append(actors, actor)
+	}
+
+	return
+}
+
 func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, address []byte, height int64) (actor types.BaseActor, err error) {
 	ctx, tx, err := p.GetCtxAndTx()
 	if err != nil {
@@ -57,10 +87,16 @@ func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, addres
 	return p.GetChainsForActor(ctx, tx, actorSchema, actor, height)
 }
 
+// IMPORTANT: Need to consolidate `persistence/types.BaseActor` with `persistence/genesisTypes.Actor`
 func (p *PostgresContext) GetActorFromRow(row pgx.Row) (actor types.BaseActor, height int64, err error) {
 	err = row.Scan(
-		&actor.Address, &actor.PublicKey, &actor.StakedTokens, &actor.ActorSpecificParam,
-		&actor.OutputAddress, &actor.PausedHeight, &actor.UnstakingHeight,
+		&actor.Address,
+		&actor.PublicKey,
+		&actor.StakedTokens,
+		&actor.ActorSpecificParam,
+		&actor.OutputAddress,
+		&actor.PausedHeight,
+		&actor.UnstakingHeight,
 		&height)
 	return
 }
diff --git a/persistence/state.go b/persistence/state.go
new file mode 100644
index 000000000..5c3913140
--- /dev/null
+++ b/persistence/state.go
@@ -0,0 +1,119 @@
+package persistence
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"log"
+	"sort"
+
+	"github.com/celestiaorg/smt"
+	typesUtil "github.com/pokt-network/pocket/utility/types"
+	"google.golang.org/protobuf/proto"
+)
+
+type MerkleTree float64
+
+// A work-in-progress list of all the trees we need to update to maintain the overall state
+const (
+	// Actor  Merkle Trees
+	appMerkleTree MerkleTree = iota
+	valMerkleTree
+	fishMerkleTree
+	serviceNodeMerkleTree
+	accountMerkleTree
+	poolMerkleTree
+
+	// Data / State Merkle Trees
+	blocksMerkleTree
+	paramsMerkleTree
+	flagsMerkleTree
+
+	// Used for iteration purposes only - see https://stackoverflow.com/a/64178235/768439
+	lastMerkleTree
+)
+
+func newMerkleTrees() (map[MerkleTree]*smt.SparseMerkleTree, error) {
+	// We need a separate Merkle tree for each type of actor or storage
+	trees := make(map[MerkleTree]*smt.SparseMerkleTree, int(lastMerkleTree))
+
+	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
+		// TODO_IN_THIS_COMMIT: Rather than using `NewSimpleMap`, use a disk based key-value store
+		nodeStore := smt.NewSimpleMap()
+		valueStore := smt.NewSimpleMap()
+
+		trees[treeType] = smt.NewSparseMerkleTree(nodeStore, valueStore, sha256.New())
+	}
+	return trees, nil
+}
+
+func loadMerkleTrees(map[MerkleTree]*smt.SparseMerkleTree, error) {
+	log.Fatalf("loadMerkleTrees not implemented yet")
+}
+
+func (p *PostgresContext) updateStateHash() error {
+	// Update all the merkle trees
+	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
+		switch treeType {
+		case appMerkleTree:
+			apps, err := p.getApplicationsUpdatedAtHeight(p.Height)
+			if err != nil {
+				// TODO_IN_THIS_COMMIT: Update this error
+				return typesUtil.NewError(typesUtil.Code(42), "Couldn't figure out apps updated")
+			}
+			for _, app := range apps {
+				appBz, err := proto.Marshal(app)
+				if err != nil {
+					return err
+				}
+				// An update results in a create/update that is idempotent
+				addrBz, err := hex.DecodeString(app.Address)
+				if err != nil {
+					return err
+				}
+				if _, err := p.MerkleTrees[treeType].Update(addrBz, appBz); err != nil {
+					return err
+				}
+			}
+		case valMerkleTree:
+			fmt.Println("TODO: valMerkleTree not implemented")
+		case fishMerkleTree:
+			fmt.Println("TODO: fishMerkleTree not implemented")
+		case serviceNodeMerkleTree:
+			fmt.Println("TODO: serviceNodeMerkleTree not implemented")
+		case accountMerkleTree:
+			fmt.Println("TODO: accountMerkleTree not implemented")
+		case poolMerkleTree:
+			fmt.Println("TODO: poolMerkleTree not implemented")
+		case blocksMerkleTree:
+			// VERY VERY IMPORTANT DISCUSSION: What do we do here provided that `Commit`, which stores the block in the DB and tree
+			//                                 requires the quorumCert, which we receive at the very end of hotstuff consensus
+			fmt.Println("TODO: blocksMerkleTree not implemented")
+		case paramsMerkleTree:
+			fmt.Println("TODO: paramsMerkleTree not implemented")
+		case flagsMerkleTree:
+			fmt.Println("TODO: flagsMerkleTree not implemented")
+		default:
+			log.Fatalln("Not handled yet in state commitment update", treeType)
+		}
+	}
+
+	// Get the root of each Merkle Tree
+	roots := make([][]byte, 0)
+	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
+		roots = append(roots, p.MerkleTrees[treeType].Root())
+	}
+
+	// Sort the merkle roots lexicographically
+	sort.Slice(roots, func(r1, r2 int) bool {
+		return bytes.Compare(roots[r1], roots[r2]) < 0
+	})
+
+	// Get the state hash
+	rootsConcat := bytes.Join(roots, []byte{})
+	stateHash := sha256.Sum256(rootsConcat)
+
+	p.stateHash = stateHash[:]
+	return nil
+}
diff --git a/persistence/state_test.go b/persistence/state_test.go
new file mode 100644
index 000000000..9570f4c00
--- /dev/null
+++ b/persistence/state_test.go
@@ -0,0 +1,15 @@
+package persistence
+
+import "testing"
+
+func TestStateHash_InitializeTrees(t *testing.T) {
+
+}
+
+func TestStateHash_LoadTrees(t *testing.T) {
+
+}
+
+func TestStateHash_ComputeStateHash(t *testing.T) {
+
+}
diff --git a/persistence/test/module_test.go b/persistence/test/module_test.go
index 3bee636c5..ccb7bd37f 100644
--- a/persistence/test/module_test.go
+++ b/persistence/test/module_test.go
@@ -18,12 +18,14 @@ func TestPersistenceContextParallelReadWrite(t *testing.T) {
 	poolAddress := []byte("address")
 	originalAmount := "15"
 	modifiedAmount := "10"
+	proposer := []byte("proposer")
+	quorumCert := []byte("quorumCert")
 
 	// setup a write context, insert a pool and commit it
 	context, err := testPersistenceMod.NewRWContext(0)
 	require.NoError(t, err)
 	require.NoError(t, context.InsertPool(poolName, poolAddress, originalAmount))
-	require.NoError(t, context.Commit())
+	require.NoError(t, context.Commit(proposer, quorumCert))
 
 	// verify the insert in the previously committed context worked
 	contextA, err := testPersistenceMod.NewRWContext(0)
diff --git a/persistence/types/base_actor.go b/persistence/types/base_actor.go
index 9514b15eb..1c73da9a7 100644
--- a/persistence/types/base_actor.go
+++ b/persistence/types/base_actor.go
@@ -1,5 +1,6 @@
 package types
 
+// IMPROVE: Move schema related functions to a separate sub-package
 import "github.com/pokt-network/pocket/shared/modules"
 
 // TECHDEBT: Consider moving this to a protobuf. This struct was created to make testing simple of protocol actors that
@@ -60,6 +61,10 @@ func (actor *BaseProtocolActorSchema) GetChainsTableSchema() string {
 	return ProtocolActorChainsTableSchema(actor.chainsHeightConstraintName)
 }
 
+func (actor *BaseProtocolActorSchema) GetUpdatedAtHeightQuery(height int64) string {
+	return SelectAtHeight(AddressCol, height, actor.tableName)
+}
+
 func (actor *BaseProtocolActorSchema) GetQuery(address string, height int64) string {
 	return Select(AllColsSelector, address, height, actor.tableName)
 }
@@ -150,5 +155,5 @@ func (x *Actor) GetActorTyp() modules.ActorType {
 	if x != nil {
 		return x.GetActorType()
 	}
-	return ActorType_App
+	return ActorType_App // HACK: Is this a hack?
 }
diff --git a/persistence/types/protocol_actor.go b/persistence/types/protocol_actor.go
index 4b57e8e40..cb1e23fbf 100644
--- a/persistence/types/protocol_actor.go
+++ b/persistence/types/protocol_actor.go
@@ -15,6 +15,9 @@ type ProtocolActorSchema interface {
 	GetActorSpecificColName() string
 
 	/*** Read/Get Queries ***/
+
+	// Returns a query to retrieve the addresses of all the Actors updated at that specific height
+	GetUpdatedAtHeightQuery(height int64) string
 	// Returns a query to retrieve all of a single Actor's attributes.
 	GetQuery(address string, height int64) string
 	// Returns all actors at that height
diff --git a/persistence/types/shared_sql.go b/persistence/types/shared_sql.go
index 5502c03d3..6c053b6de 100644
--- a/persistence/types/shared_sql.go
+++ b/persistence/types/shared_sql.go
@@ -69,6 +69,11 @@ func ProtocolActorChainsTableSchema(constraintName string) string {
 		)`, AddressCol, ChainIDCol, HeightCol, DefaultBigInt, constraintName, AddressCol, ChainIDCol, HeightCol)
 }
 
+func SelectAtHeight(selector string, height int64, tableName string) string {
+	return fmt.Sprintf(`SELECT %s FROM %s WHERE height=%d`,
+		selector, tableName, height)
+}
+
 func Select(selector, address string, height int64, tableName string) string {
 	return fmt.Sprintf(`SELECT %s FROM %s WHERE address='%s' AND height<=%d ORDER BY height DESC LIMIT 1`,
 		selector, tableName, address, height)
diff --git a/shared/codec/codec.go b/shared/codec/codec.go
index a41fe2e0b..ac7765673 100644
--- a/shared/codec/codec.go
+++ b/shared/codec/codec.go
@@ -5,8 +5,6 @@ import (
 	"google.golang.org/protobuf/types/known/anypb"
 )
 
-// TODO: Use generics in place of `proto.Message` in the interface below
-//       so every caller does not need to do in place casting.
 type Codec interface { // TODO (Team) move to shared. Possibly rename
 	Marshal(proto.Message) ([]byte, error)
 	Unmarshal([]byte, proto.Message) error
@@ -16,8 +14,6 @@ type Codec interface { // TODO (Team) move to shared. Possibly rename
 
 var _ Codec = &ProtoCodec{}
 
-// TODO: Need to define a type like `type ProtoAny anypb.Any` so that we are
-//       mixing protobufs and a centralized codec structure throughout the codebase.
 type ProtoCodec struct{}
 
 func (p *ProtoCodec) Marshal(message proto.Message) ([]byte, error) {
diff --git a/shared/docs/flows/AppHash.md b/shared/docs/flows/AppHash.md
deleted file mode 100644
index 51a1824b0..000000000
--- a/shared/docs/flows/AppHash.md
+++ /dev/null
@@ -1,36 +0,0 @@
-# AppHash
-
-## Context Initialization
-
-```mermaid
-sequenceDiagram
-    %% autonumber
-    participant N as Node
-    participant C as Consensus
-    participant U as Utility
-    participant P as Persistence
-    participant PP as Persistence (PostgresDB)
-    participant PM as Persistence (MerkleTree)
-    participant P2P as P2P
-
-    %% Should this be P2P?
-    N-->>C: HandleMessage(anypb.Any)
-    critical NewRound Message
-        C->>+U: NewContext(height)
-        U->>P: NewRWContext(height)
-        P->>U: PersistenceRWContext
-        U->>U: Store persistenceContext
-        U->>-C: UtilityContext
-        C->>C: Store utilityContext
-        Note over C, PM: See 'Block Application'
-    end
-    Note over N, P2P: Hotstuff lifecycle
-    N-->>C: HandleMessage(anypb.Any)
-    critical Decide Message
-        Note over C, PM: See 'Block Commit'
-    end
-```
-
-## Block Application
-
-## Block Commit
diff --git a/shared/docs/flows/README.md b/shared/docs/flows/README.md
deleted file mode 100644
index cb4e5d663..000000000
--- a/shared/docs/flows/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# Flows
-
-The purpose of [shared/flows](./) is to document cross-module communication for end-to-end behaviour that has cross-module dependencies and and depends on the interfaces exposed by the interfaces exposed in [shared/modules](../modules).
diff --git a/shared/indexer/indexer.go b/shared/indexer/indexer.go
index 559ca1f6e..59355787f 100644
--- a/shared/indexer/indexer.go
+++ b/shared/indexer/indexer.go
@@ -5,6 +5,7 @@ package indexer
 import (
 	"encoding/hex"
 	"fmt"
+
 	"github.com/pokt-network/pocket/shared/codec"
 
 	"github.com/jordanorelli/lexnum"
@@ -111,7 +112,7 @@ type txIndexer struct {
 }
 
 func NewTxIndexer(databasePath string) (TxIndexer, error) {
-	db, err := kvstore.NewKVStore(databasePath)
+	db, err := kvstore.OpenKVStore(databasePath)
 	return &txIndexer{
 		db: db,
 	}, err
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index edc0e30cc..a4a587bb9 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -3,12 +3,14 @@ package modules
 //go:generate mockgen -source=$GOFILE -destination=./mocks/persistence_module_mock.go -aux_files=github.com/pokt-network/pocket/shared/modules=module.go
 
 import (
-	"github.com/pokt-network/pocket/persistence/kvstore"
+	"github.com/pokt-network/pocket/persistence/kvstore" // Should be moved to shared
 	"github.com/pokt-network/pocket/shared/debug"
 )
 
 type PersistenceModule interface {
 	Module
+
+	// Persistence Context Factory Methods
 	NewRWContext(height int64) (PersistenceRWContext, error)
 	NewReadContext(height int64) (PersistenceReadContext, error)
 
@@ -38,34 +40,28 @@ type PersistenceRWContext interface {
 	PersistenceWriteContext
 }
 
+// TODO: Simplify the interface (reference - https://dave.cheney.net/practical-go/presentations/gophercon-israel.html#_prefer_single_method_interfaces)
+// - Add general purpose methods such as `ActorOperation(enum_actor_type, ...)` which can be use like so: `Insert(FISHERMAN, ...)`
+// - Use general purpose parameter methods such as `Set(enum_gov_type, ...)` such as `Set(STAKING_ADJUSTMENT, ...)`
+
 // NOTE: There's not really a use case for a write only interface,
 // but it abstracts and contrasts nicely against the read only context
 // TODO (andrew) convert address and public key to string not bytes #149
 type PersistenceWriteContext interface {
-	// TODO: Simplify the interface (reference - https://dave.cheney.net/practical-go/presentations/gophercon-israel.html#_prefer_single_method_interfaces)
-	// - Add general purpose methods such as `ActorOperation(enum_actor_type, ...)` which can be use like so: `Insert(FISHERMAN, ...)`
-	// - Use general purpose parameter methods such as `Set(enum_gov_type, ...)` such as `Set(STAKING_ADJUSTMENT, ...)`
 	// Context Operations
 	NewSavePoint([]byte) error
 	RollbackToSavePoint([]byte) error
 
+	// DISCUSS: Can we consolidate `Reset` and `Release`
 	Reset() error
-	Commit() error
 	Release() error
 
-	AppHash() ([]byte, error)
-
-	// Block Operations
-
-	// Indexer Operations
-	StoreTransaction(transactionProtoBytes []byte) error
-
-	// Block Operations
-	// TODO_TEMPORARY: Including two functions for the SQL and KV Store as an interim solution
-	//                 until we include the schema as part of the SQL Store because persistence
-	//                 currently has no access to the protobuf schema which is the source of truth.
-	StoreBlock(blockProtoBytes []byte) error                                              // Store the block in the KV Store
-	InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error // Writes the block in the SQL database
+	// Block / indexer operations
+	UpdateAppHash() ([]byte, error)
+	// Commits the current context (height, hash, transactions, etc...) to finality.
+	Commit(proposerAddr []byte, quorumCert []byte) error
+	// Indexes the transaction
+	StoreTransaction(transactionProtoBytes []byte) error // Stores a transaction
 
 	// Pool Operations
 	AddPoolAmount(name string, amount string) error
@@ -126,6 +122,29 @@ type PersistenceWriteContext interface {
 	// Flag Operations
 	InitFlags() error
 	SetFlag(paramName string, value interface{}, enabled bool) error
+
+	// Tree Operations
+
+	// # Option 1:
+
+	UpdateApplicationsTree([]Actor) error
+	// UpdateValidatorsTree([]Actor) error
+	// UpdateServiceNodesTree([]Actor) error
+	// UpdateFishermanTree([]Actor) error
+	// Update<FutureActors>Tree([]Actor) error
+	// Update<Other>Tree([]Other) error
+
+	// # Option 2:
+	// UpdateActorTree(types.ProtocolActorSchema, []Actor) error
+	// Update<Other>Tree([]Other) error
+
+	// # Option 3:
+	// UpdateApplicationsTree([]Application) error
+	// UpdateValidatorsTree([]Validator) error
+	// UpdateServiceNodesTree([]ServiceNode) error
+	// UpdateFishermanTree([]Fisherman) error
+	// Update<FutureActors>Tree([]FutureActor) error
+	// Update<Other>Tree([]Other) error
 }
 
 type PersistenceReadContext interface {
@@ -204,4 +223,28 @@ type PersistenceReadContext interface {
 	GetIntFlag(paramName string, height int64) (int, bool, error)
 	GetStringFlag(paramName string, height int64) (string, bool, error)
 	GetBytesFlag(paramName string, height int64) ([]byte, bool, error)
+
+	// Tree Operations
+
+	// # Option 1:
+
+	// GetApplicationsUpdatedAtHeight(height int64) ([]Actor, error)
+	// GetValidatorsUpdatedAtHeight(height int64) ([]Actor, error)
+	// GetServiceNodesUpdatedAtHeight(height int64) ([]Actor, error)
+	// GetFishermanUpdatedAtHeight(height int64) ([]Actor, error)
+	// Get<FutureActor>UpdatedAtHeight(height int64) ([]Actor, error)
+	// Get<Other>UpdatedAtHeight(height int64) ([]Actor, error)
+	// Update<Other>Tree(height int64) ([]Actor, error)
+
+	// # Option 2:
+	// Get<FutureActor>UpdatedAtHeight(types.ProtocolActorSchema, height int64) ([]Actor, error)
+	// Get<Other>UpdatedAtHeight(height int64) ([]Other, error)
+
+	// # Option 3:
+	// GetApplicationsUpdatedAtHeight(height int64) ([]Application, error)
+	// GetValidatorsUpdatedAtHeight(height int64) ([]Validator, error)
+	// GetServiceNodesUpdatedAtHeight(height int64) ([]ServiceNode, error)
+	// GetFishermanUpdatedAtHeight(height int64) ([]Fisherman, error)
+	// Get<FutureActor>UpdatedAtHeight(height int64) ([]FutureActor, error)
+	// Get<Other>UpdatedAtHeight(height int64) ([]Other, error)
 }
diff --git a/shared/modules/utility_module.go b/shared/modules/utility_module.go
index 67617399a..5dbf9f887 100644
--- a/shared/modules/utility_module.go
+++ b/shared/modules/utility_module.go
@@ -14,14 +14,15 @@ type UtilityModule interface {
 // operations.
 type UtilityContext interface {
 	// Block operations
+
+	// Reaps the mempool for transactions that are ready to be proposed in a new block
 	GetProposalTransactions(proposer []byte, maxTransactionBytes int, lastBlockByzantineValidators [][]byte) (transactions [][]byte, err error)
+	// Applies the transactions to an ephemeral state in the utility & underlying persistence context;similar to `SafeNode` in the Hotstuff whitepaper.
 	ApplyBlock(height int64, proposer []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) (appHash []byte, err error)
-	StoreBlock(blockProtoBytes []byte) error
 
 	// Context operations
-	ReleaseContext()
-	GetPersistenceContext() PersistenceRWContext
-	CommitPersistenceContext() error
+	ReleaseContext() error
+	CommitContext(quorumCert []byte) error
 
 	// Validation operations
 	CheckTransaction(tx []byte) error
diff --git a/shared/test_artifacts/generator.go b/shared/test_artifacts/generator.go
index f89c68188..912e9fe2b 100644
--- a/shared/test_artifacts/generator.go
+++ b/shared/test_artifacts/generator.go
@@ -2,12 +2,11 @@ package test_artifacts
 
 import (
 	"fmt"
-	"math/big"
-	"strconv"
-
 	typesPersistence "github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 	"github.com/pokt-network/pocket/utility/types"
+	"math/big"
+	"strconv"
 
 	"github.com/pokt-network/pocket/shared/crypto"
 	"google.golang.org/protobuf/types/known/timestamppb"
diff --git a/shared/types/genesis/validator.go b/shared/types/genesis/validator.go
new file mode 100644
index 000000000..17c2af5fd
--- /dev/null
+++ b/shared/types/genesis/validator.go
@@ -0,0 +1,49 @@
+package genesis
+
+// import (
+// 	"encoding/hex"
+// 	"encoding/json"
+
+// 	"google.golang.org/protobuf/encoding/protojson"
+// )
+
+// // TODO_IN_THIS_COMMIT: See https://github.com/pokt-network/pocket/pull/139/files to remove this shit
+
+// // HACK: Since the protocol actor protobufs (e.g. validator, fisherman, etc) use `bytes` for some
+// // fields (e.g. `address`, `output`, `publicKey`), we need to use a helper struct to unmarshal the
+// // the types when they are defined via json (e.g. genesis file, testing configurations, etc...).
+// // Alternative solutions could include whole wrapper structs (i.e. duplication of schema definition),
+// // using strings instead of bytes (i.e. major change with downstream effects) or avoid defining these
+// // types in json altogether (i.e. limitation of usability).
+// type JsonBytesLoaderHelper struct {
+// 	Address   HexData `json:"address,omitempty"`
+// 	PublicKey HexData `json:"public_key,omitempty"`
+// 	Output    HexData `json:"output,omitempty"`
+// }
+
+// type HexData []byte
+
+// func (h *HexData) UnmarshalJSON(data []byte) error {
+// 	var s string
+// 	if err := json.Unmarshal(data, &s); err != nil {
+// 		return err
+// 	}
+// 	decoded, err := hex.DecodeString(s)
+// 	if err != nil {
+// 		return err
+// 	}
+// 	*h = HexData(decoded)
+// 	return nil
+// }
+
+// func (v *Validator) UnmarshalJSON(data []byte) error {
+// 	var jh JsonBytesLoaderHelper
+// 	json.Unmarshal(data, &jh)
+
+// 	protojson.Unmarshal(data, v)
+// 	v.Address = jh.Address
+// 	v.PublicKey = jh.PublicKey
+// 	v.Output = jh.Output
+
+// 	return nil
+// }
diff --git a/utility/block.go b/utility/block.go
index 6c09cd8cf..324ee78a8 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -3,7 +3,7 @@ package utility
 import (
 	"math/big"
 
-	typesCons "github.com/pokt-network/pocket/consensus/types" // TODO (andrew) importing consensus and persistence in this file?
+	// TODO (andrew) importing consensus and persistence in this file?
 	typesGenesis "github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 
@@ -34,6 +34,8 @@ var (
 
 func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) ([]byte, error) {
 	u.LatestHeight = latestHeight
+	u.CurrentProposer = proposerAddress
+
 	// begin block lifecycle phase
 	if err := u.BeginBlock(lastBlockByzantineValidators); err != nil {
 		return nil, err
@@ -51,22 +53,30 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 		if err := u.ApplyTransaction(tx); err != nil {
 			return nil, err
 		}
-		if err := u.GetPersistenceContext().StoreTransaction(transactionProtoBytes); err != nil {
+		if err := u.Context.PersistenceRWContext.StoreTransaction(transactionProtoBytes); err != nil {
 			return nil, err
 		}
 
-		// TODO: if found, remove transaction from mempool
 		// DISCUSS: What if the context is rolled back or cancelled. Do we add it back to the mempool?
+		// TODO: if found, remove transaction from mempool
 		// if err := u.Mempool.DeleteTransaction(transaction); err != nil {
 		// 	return nil, err
 		// }
 	}
+
 	// end block lifecycle phase
 	if err := u.EndBlock(proposerAddress); err != nil {
 		return nil, err
 	}
-	// return the app hash (consensus module will get the validator set directly
-	return u.GetAppHash()
+
+	// TODO: What if everything above succeeded but updating the app hash failed?
+	appHash, err := u.Context.UpdateAppHash()
+	if err != nil {
+		return nil, typesUtil.ErrAppHash(err)
+	}
+
+	// return the app hash; consensus module will get the validator set directly
+	return appHash, nil
 }
 
 func (u *UtilityContext) BeginBlock(previousBlockByzantineValidators [][]byte) typesUtil.Error {
@@ -92,15 +102,6 @@ func (u *UtilityContext) EndBlock(proposer []byte) typesUtil.Error {
 	return nil
 }
 
-func (u *UtilityContext) GetAppHash() ([]byte, typesUtil.Error) {
-	// Get the root hash of the merkle state tree for state consensus integrity
-	appHash, er := u.Context.AppHash()
-	if er != nil {
-		return nil, typesUtil.ErrAppHash(er)
-	}
-	return appHash, nil
-}
-
 // HandleByzantineValidators handles the validators who either didn't sign at all or disagreed with the 2/3+ majority
 func (u *UtilityContext) HandleByzantineValidators(lastBlockByzantineValidators [][]byte) typesUtil.Error {
 	latestBlockHeight, err := u.GetLatestHeight()
@@ -284,27 +285,3 @@ func (u *UtilityContext) SetValidatorMissedBlocks(address []byte, missedBlocks i
 	}
 	return nil
 }
-
-func (u *UtilityContext) StoreBlock(blockProtoBytes []byte) error {
-	store := u.Store()
-
-	// Store in KV Store
-	if err := store.StoreBlock(blockProtoBytes); err != nil {
-		return err
-	}
-
-	// Store in SQL Store
-	// OPTIMIZE: Ideally we'd pass in the block proto struct to utility so we don't
-	//           have to unmarshal it here, but that's a major design decision for the interfaces.
-	codec := u.Codec()
-	block := &typesCons.Block{}
-	if err := codec.Unmarshal(blockProtoBytes, block); err != nil {
-		return typesUtil.ErrProtoUnmarshal(err)
-	}
-	header := block.BlockHeader
-	if err := store.InsertBlock(uint64(header.Height), header.Hash, header.ProposerAddress, header.QuorumCertificate); err != nil {
-		return err
-	}
-
-	return nil
-}
diff --git a/utility/context.go b/utility/context.go
index 460b7cfa1..b0ca4bebc 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -2,19 +2,24 @@ package utility
 
 import (
 	"encoding/hex"
+
 	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/modules"
 	typesUtil "github.com/pokt-network/pocket/utility/types"
 )
 
 type UtilityContext struct {
-	LatestHeight int64
-	Mempool      typesUtil.Mempool
-	Context      *Context // IMPROVE: Consider renmaming to PersistenceContext
+	LatestHeight    int64 // IMPROVE: Rename to `currentHeight?`
+	CurrentProposer []byte
+
+	Mempool typesUtil.Mempool
+	Context *Context // IMPROVE: Rename to `persistenceContext` or `storeContext` or `reversibleContext`?
 }
 
-type Context struct {
+type Context struct { // IMPROVE: Rename to `persistenceContext` or `storeContext`?
+	// TODO: Since `Context` embeds `PersistenceRWContext`, we don't need to do `u.Context.PersistenceRWContext`, but can call `u.Context` directly
 	modules.PersistenceRWContext
+	// TODO/DISCUSS: `SavePoints`` have not been implemented yet
 	SavePointsM map[string]struct{}
 	SavePoints  [][]byte
 }
@@ -39,17 +44,16 @@ func (u *UtilityContext) Store() *Context {
 	return u.Context
 }
 
-func (u *UtilityContext) GetPersistenceContext() modules.PersistenceRWContext {
-	return u.Context.PersistenceRWContext
-}
-
-func (u *UtilityContext) CommitPersistenceContext() error {
-	return u.Context.PersistenceRWContext.Commit()
+func (u *UtilityContext) CommitContext(quorumCert []byte) error {
+	err := u.Context.PersistenceRWContext.Commit(u.CurrentProposer, quorumCert)
+	u.Context = nil // DISCUSS: Should we release the context if there was an error here?
+	return err
 }
 
-func (u *UtilityContext) ReleaseContext() {
-	u.Context.Release()
+func (u *UtilityContext) ReleaseContext() error {
+	err := u.Context.Release()
 	u.Context = nil
+	return err
 }
 
 func (u *UtilityContext) GetLatestHeight() (int64, typesUtil.Error) {
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index c1441e405..f4a1420e9 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -3,12 +3,13 @@ package test
 import (
 	"encoding/hex"
 	"fmt"
-	"github.com/pokt-network/pocket/shared/modules"
-	"github.com/pokt-network/pocket/shared/test_artifacts"
 	"math"
 	"math/big"
 	"testing"
 
+	"github.com/pokt-network/pocket/shared/modules"
+	"github.com/pokt-network/pocket/shared/test_artifacts"
+
 	typesUtil "github.com/pokt-network/pocket/utility/types"
 	"github.com/stretchr/testify/require"
 )
@@ -172,19 +173,6 @@ func TestUtilityContext_EndBlock(t *testing.T) {
 	test_artifacts.CleanupTest(ctx)
 }
 
-func TestUtilityContext_GetAppHash(t *testing.T) {
-	ctx := NewTestingUtilityContext(t, 0)
-
-	appHashTest, err := ctx.GetAppHash()
-	require.NoError(t, err)
-
-	appHashSource, er := ctx.Context.AppHash()
-	require.NoError(t, er)
-	require.Equal(t, appHashSource, appHashTest, "unexpected appHash")
-
-	test_artifacts.CleanupTest(ctx)
-}
-
 func TestUtilityContext_UnstakeValidatorsActorsThatAreReady(t *testing.T) {
 	for _, actorType := range typesUtil.ActorTypes {
 		ctx := NewTestingUtilityContext(t, 1)

From f2777a16bbb791b0efe6d5f752db1b22590a3df2 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 26 Sep 2022 20:44:22 -0700
Subject: [PATCH 039/227] Isolate interface changes only

---
 consensus/block.go                        |  49 +++-
 consensus/types/block.go                  |  14 -
 persistence/StateHash.md                  | 194 -------------
 persistence/application.go                |  51 ----
 persistence/block.go                      |  42 +--
 persistence/context.go                    |  26 +-
 persistence/db.go                         |   8 -
 persistence/debug.go                      |   2 +-
 persistence/genesis.go                    |   4 +-
 persistence/kvstore/kvstore.go            | 164 -----------
 persistence/module.go                     | 258 -----------------
 persistence/proto/block_persistence.proto |  13 -
 persistence/shared_sql.go                 | 325 ----------------------
 persistence/state.go                      | 119 --------
 persistence/state_test.go                 |  15 -
 persistence/test/module_test.go           |   4 +-
 persistence/types/base_actor.go           |   7 +-
 persistence/types/protocol_actor.go       |   3 -
 persistence/types/shared_sql.go           |   5 -
 shared/codec/codec.go                     |   4 +
 shared/docs/flows/AppHash.md              | 101 +++++++
 shared/docs/flows/README.md               |   3 +
 shared/indexer/indexer.go                 |   3 +-
 shared/types/genesis/validator.go         |  49 ----
 utility/test/block_test.go                |  18 +-
 25 files changed, 178 insertions(+), 1303 deletions(-)
 delete mode 100644 consensus/types/block.go
 delete mode 100644 persistence/StateHash.md
 delete mode 100644 persistence/kvstore/kvstore.go
 delete mode 100644 persistence/module.go
 delete mode 100644 persistence/proto/block_persistence.proto
 delete mode 100644 persistence/shared_sql.go
 delete mode 100644 persistence/state.go
 delete mode 100644 persistence/state_test.go
 create mode 100644 shared/docs/flows/AppHash.md
 create mode 100644 shared/docs/flows/README.md
 delete mode 100644 shared/types/genesis/validator.go

diff --git a/consensus/block.go b/consensus/block.go
index f483ce587..a0c2d2929 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -5,8 +5,42 @@ import (
 	"unsafe"
 
 	typesCons "github.com/pokt-network/pocket/consensus/types"
+	"github.com/pokt-network/pocket/shared/codec"
 )
 
+func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
+	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
+
+	// Store the block in the KV store
+	codec := codec.GetCodec()
+	blockProtoBytes, err := codec.Marshal(block)
+	if err != nil {
+		return err
+	}
+
+	// IMPROVE(olshansky): temporary solution. `ApplyBlock` above applies the
+	// transactions to the postgres database, and this stores it in the KV store upon commitment.
+	// Instead of calling this directly, an alternative solution is to store the block metadata in
+	// the persistence context and have `CommitPersistenceContext` do this under the hood. However,
+	// additional `Block` metadata will need to be passed through and may change when we merkle the
+	// state hash.
+	if err := m.UtilityContext.StoreBlock(blockProtoBytes); err != nil {
+		return err
+	}
+
+	// Commit the utility context
+	if err := m.UtilityContext.CommitPersistenceContext(); err != nil {
+		return err
+	}
+	// Release the utility context
+	m.UtilityContext.ReleaseContext()
+	m.UtilityContext = nil
+	// Update the last app hash
+	m.lastAppHash = block.BlockHeader.Hash
+
+	return nil
+}
+
 // TODO: Add unit tests specific to block validation
 func (m *ConsensusModule) validateBlockBasic(block *typesCons.Block) error {
 	if block == nil && m.Step != NewRound {
@@ -52,18 +86,3 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 
 	return nil
 }
-
-func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
-	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
-
-	// Commit and release the context
-	if err := m.UtilityContext.CommitContext(block.BlockHeader.QuorumCertificate); err != nil {
-		return err
-	}
-	m.UtilityContext.ReleaseContext()
-	m.UtilityContext = nil
-
-	m.lastAppHash = block.BlockHeader.Hash
-
-	return nil
-}
diff --git a/consensus/types/block.go b/consensus/types/block.go
deleted file mode 100644
index f6091b6b3..000000000
--- a/consensus/types/block.go
+++ /dev/null
@@ -1,14 +0,0 @@
-package types
-
-import (
-	"github.com/pokt-network/pocket/shared/codec"
-)
-
-func (b *Block) Bytes() ([]byte, error) {
-	codec := codec.GetCodec()
-	blockProtoBz, err := codec.Marshal(b)
-	if err != nil {
-		return nil, err
-	}
-	return blockProtoBz, nil
-}
diff --git a/persistence/StateHash.md b/persistence/StateHash.md
deleted file mode 100644
index cfc54af52..000000000
--- a/persistence/StateHash.md
+++ /dev/null
@@ -1,194 +0,0 @@
-Remaining tasks:
-
-1.  Simplify interfaces in utility & persistence (make it simple and clear)
-2.  How do we revert changes to the merkle trees?
-3.  Draw an end-to-end diagram of everything and the data flow
-
-## References:
-
-- https://github.com/cosmos/cosmos-sdk/discussions/9158
-- https://github.com/cosmos/cosmos-sdk/pull/8012
-- https://github.com/cosmos/cosmos-sdk/discussions/8297
-- https://github.com/cosmos/cosmos-sdk/discussions/8297
-- https://paper.dropbox.com/doc/State-commitments-and-storage-review--BpuF08OSksSkLeErjf66jrOAAg-wKl2RINZWD9I0DUmZIFwQ
-- https://arxiv.org/pdf/1803.05069.pdf
-
-## Open questions:
-
-1. Review flows
-2. How do we revert changes to the merkle trees?
-
-# This discussion is aimed at:
-
-1. Defining how we should compute the state hash
-2. Identify potential changes needed in the current codebase
-3. Propose next steps and actionable on implementation
-
-## Goals:
-
-- Define how the state hash will be computed
-- Propose the necessary changes in separate tasks
-- Implement each of the necessary pieces
-
-## Non-goals:
-
-- Choice/decision of Merkle Tree Design & Implementation
-- Selection of a key-value store engine
-
-## Primitives / non-negotiables:
-
-- We will be using Merkle Trees (and Merkle Proofs) for this design (i.e. not vector commitments)
-- We will be using a SQL engine for this (i.e. specifically PostgresSQL)
-- We will be using Protobufs (not Flatbuffers, json, yaml or other) for the schema
-
-## Necessary technical context:
-
-### DB Engines
-
-Insert table from here: [Merkle Tree Design & Implementation](https://tikv.org/deep-dive/key-value-engine/b-tree-vs-lsm/#summary)
-
-- Most **Key-Value Store DB** Engines use **LSM-trees** -> good for writes
-- Most **SQL DB** Engines use **B-Trees** -> good for reads
-
-_Basically all but there can be exceptions_
-
-### Addressable Merkle Trees
-
-State is stored use an Account Based (non UTXO) based Modle
-
-Insert image from: https://www.horizen.io/blockchain-academy/technology/expert/utxo-vs-account-model/#:~:text=The%20UTXO%20model%20is%20a,constructions%2C%20as%20well%20a%20sharding.
-
----
-
-### Data Flow
-
-## Basics:
-
-1. Get each actor (flag, param, etc...) updated at a certain height (the context's height)
-2. Compute the protobuf (the deterministic schema we use as source of truth)
-3. Serialize the data struct
-4. Update the corresponding merkle tree
-5. Compute a state hash from the aggregated roots of all trees as per pokt-network/pocket-network-protocol@main/persistence#562-state-transition-sequence-diagram
-
-## Q&A
-
-Q: Can the SQL Engine be changed?
-A: Yes
-
-Q: Can the SQL Engine be removed altogether?
-A: Yes, but hard
-
-Q: Can the protobuf schema change?
-A: Yes, but out-of-scope
-
-Q: Can protobufs be replaced?
-A: Maybe, but out-of-scope
-
----
-
-Learnings / Ideas:
-
-- Consolidate `UtilActorType` and `persistence.ActorType`
-- `modules.Actors` interface vs `types.Actor` in persistenceGenesis
-
-### Context Initialization
-
-```mermaid
-sequenceDiagram
-    %% autonumber
-    participant N as Node
-    participant C as Consensus
-    participant U as Utility
-    participant P as Persistence
-    participant PP as Persistence (PostgresDB)
-    participant PM as Persistence (MerkleTree)
-    participant P2P as P2P
-
-    %% Should this be P2P?
-    N-->>C: HandleMessage(anypb.Any)
-    critical NewRound Message
-        C->>+U: NewContext(height)
-        U->>P: NewRWContext(height)
-        P->>U: PersistenceRWContext
-        U->>U: Store persistenceContext
-        U->>-C: UtilityContext
-        C->>C: Store utilityContext
-        Note over C, PM: See 'Block Application'
-    end
-    Note over N, P2P: Hotstuff lifecycle
-    N-->>C: HandleMessage(anypb.Any)
-    critical Decide Message
-        Note over C, PM: See 'Block Commit'
-    end
-```
-
-### Block Application
-
-```mermaid
-sequenceDiagram
-    participant C as Consensus
-    participant U as Utility
-    participant P as Persistence
-    participant PP as Persistence (PostgresDB)
-    participant PM as Persistence (MerkleTree)
-
-    alt as leader
-        C->>+U: GetProposalTransactions(proposer, maxTxBz, [lastVal])
-        U->>U: reap mempool
-        U->>-C: txs
-        Note over C, U: Perform replica behaviour
-    else as replica
-        C->>+U: ApplyBlock(height, proposer, txs, lastVals)
-        loop Update DB: for each operation in tx
-            U->>P: ReadOp | WriteOp
-            P->>PP: ReadOp | WriteOp
-            PP->>P: data | ok
-            P->>U: data | ok
-            U->>U: validate
-            U->>P: StoreTransaction(tx)
-            P->>P: store locally
-            P->>U: ok
-        end
-        U->>+P: UpdateAppHash()
-        loop for each protocol actor type
-            P->>PP: GetActorsUpdate(height)
-            PP->>P: actors
-            loop Update Tree: for each actor
-                P->>PM: Update(addr, serialized(actor))
-                PM->>P: ok
-            end
-            P->>PM: GetRoot()
-            PM->>P: rootHash
-        end
-        P->>P: computeStateHash(rootHashes)
-        P->>-U: stateHash
-        U->>-C: hash
-    end
-```
-
-### Block Commit
-
-```mermaid
-sequenceDiagram
-    %% autonumber
-    participant C as Consensus
-    participant U as Utility
-    participant P as Persistence
-    participant PP as Persistence (PostgresDB)
-    participant PK as Persistence (Key-Value Store)
-
-    C->>U: CommitContext(quorumCert)
-    U->>P: Commit(proposerAddr, quorumCert)
-    P->>P: create typesPer.Block
-    P->>PP: insertBlock(block)
-    PP->>P: ok
-    P->>PK: Put(height, block)
-    PK->>P: ok
-    P->>P: commit tx
-    P->>U: ok
-    U->>P: Release()
-    P->>U: ok
-    C->>U: Release()
-    U->>C: ok
-    C->>C: release utilityContext
-```
diff --git a/persistence/application.go b/persistence/application.go
index 0bd6750bd..0f2b88512 100644
--- a/persistence/application.go
+++ b/persistence/application.go
@@ -5,66 +5,15 @@ import (
 	"log"
 
 	"github.com/pokt-network/pocket/persistence/types"
-	"google.golang.org/protobuf/proto"
-
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
-func (p PostgresContext) UpdateApplicationsTree(apps []modules.Actor) error {
-	for _, app := range apps {
-		bzAddr, err := hex.DecodeString(app.GetAddress())
-		if err != nil {
-			return err
-		}
-
-		appBz, err := proto.Marshal(app.(*types.Actor))
-		if err != nil {
-			return err
-		}
-
-		// OPTIMIZE: This is the only line unique to `Application`
-		if _, err := p.MerkleTrees[appMerkleTree].Update(bzAddr, appBz); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (p PostgresContext) getApplicationsUpdatedAtHeight(height int64) (apps []*types.Actor, err error) {
-	// OPTIMIZE: This is the only line unique to `Application`
-	actors, err := p.GetActorsUpdated(types.ApplicationActor, height)
-	if err != nil {
-		return nil, err
-	}
-
-	apps = make([]*types.Actor, len(actors))
-	for _, actor := range actors {
-		app := &types.Actor{
-			ActorType:       types.ActorType_App,
-			Address:         actor.Address,
-			PublicKey:       actor.PublicKey,
-			Chains:          actor.Chains,
-			GenericParam:    actor.ActorSpecificParam,
-			StakedAmount:    actor.StakedTokens,
-			PausedHeight:    actor.PausedHeight,
-			UnstakingHeight: actor.UnstakingHeight,
-			Output:          actor.OutputAddress,
-		}
-		apps = append(apps, app)
-	}
-	return
-}
-
 func (p PostgresContext) GetAppExists(address []byte, height int64) (exists bool, err error) {
 	return p.GetExists(types.ApplicationActor, address, height)
 }
 
 func (p PostgresContext) GetApp(address []byte, height int64) (operator, publicKey, stakedTokens, maxRelays, outputAddress string, pauseHeight, unstakingHeight int64, chains []string, err error) {
 	actor, err := p.GetActor(types.ApplicationActor, address, height)
-	if err != nil {
-		return
-	}
 	operator = actor.Address
 	publicKey = actor.PublicKey
 	stakedTokens = actor.StakedTokens
diff --git a/persistence/block.go b/persistence/block.go
index 5efa1b71e..aaee96364 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -5,7 +5,6 @@ import (
 	"encoding/hex"
 	"log"
 
-	"github.com/gogo/protobuf/proto"
 	"github.com/pokt-network/pocket/persistence/types"
 )
 
@@ -50,44 +49,21 @@ func (p PostgresContext) StoreTransaction(transactionProtoBytes []byte) error {
 	return nil
 }
 
-func (p PostgresContext) insertBlock(block *types.Block) error {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return err
-	}
-
-	_, err = tx.Exec(ctx, types.InsertBlockQuery(block.Height, block.Hash, block.ProposerAddress, block.QuorumCertificate))
-	return err
+func (p PostgresContext) StoreBlock(blockProtoBytes []byte) error {
+	// INVESTIGATE: Note that we are writing this directly to the blockStore. Depending on how
+	// the use of the PostgresContext evolves, we may need to write this to `ContextStore` and copy
+	// over to `BlockStore` when the block is committed.
+	return p.blockstore.Put(heightToBytes(p.Height), blockProtoBytes)
 }
 
-func (p PostgresContext) storeBlock(block *types.Block) error {
-	blockBz, err := proto.Marshal(block)
+func (p PostgresContext) InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error {
+	ctx, tx, err := p.GetCtxAndTx()
 	if err != nil {
 		return err
 	}
 
-	return p.blockstore.Put(heightToBytes(p.Height), blockBz)
-}
-
-func (p PostgresContext) getBlock(proposerAddr []byte, quorumCert []byte) (*types.Block, error) {
-	prevHash, err := p.GetBlockHash(p.Height - 1)
-	if err != nil {
-		return nil, err
-	}
-
-	// TODO: get this from the transactions that were store via `StoreTransaction`
-	txs := make([][]byte, 0)
-
-	block := &types.Block{
-		Height:            uint64(p.Height),
-		Hash:              string(p.stateHash),
-		PrevHash:          string(prevHash),
-		ProposerAddress:   proposerAddr,
-		QuorumCertificate: quorumCert,
-		Transactions:      txs,
-	}
-
-	return block, nil
+	_, err = tx.Exec(ctx, types.InsertBlockQuery(height, hash, proposerAddr, quorumCert))
+	return err
 }
 
 // CLEANUP: Should this be moved to a shared directory?
diff --git a/persistence/context.go b/persistence/context.go
index 8224a229a..fd44e3af1 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -15,39 +15,25 @@ func (p PostgresContext) RollbackToSavePoint(bytes []byte) error {
 	return p.GetTx().Rollback(context.TODO())
 }
 
-func (p PostgresContext) UpdateAppHash() ([]byte, error) {
-	if err := p.updateStateHash(); err != nil {
-		return nil, err
-	}
-	return p.stateHash, nil
+func (p PostgresContext) AppHash() ([]byte, error) {
+	log.Println("TODO: AppHash not implemented")
+	return []byte("A real app hash, I am not"), nil
 }
 
 func (p PostgresContext) Reset() error {
 	panic("TODO: PostgresContext Reset not implemented")
 }
 
-func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
+func (p PostgresContext) Commit() error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
-	block, err := p.getBlock(proposerAddr, quorumCert)
-	if err != nil {
-		return err
-	}
-
-	if err := p.insertBlock(block); err != nil {
-		return err
-	}
-
-	if err := p.storeBlock(block); err != nil {
-		return err
-	}
-
 	ctx := context.TODO()
-	if err := p.GetTx().Commit(ctx); err != nil {
+	if err := p.GetTx().Commit(context.TODO()); err != nil {
 		return err
 	}
 	if err := p.conn.Close(ctx); err != nil {
 		log.Println("[TODO][ERROR] Implement connection pooling. Error when closing DB connecting...", err)
+
 	}
 	return nil
 }
diff --git a/persistence/db.go b/persistence/db.go
index b8a974939..3a495596c 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -7,7 +7,6 @@ import (
 
 	"github.com/pokt-network/pocket/persistence/types"
 
-	"github.com/celestiaorg/smt"
 	"github.com/jackc/pgconn"
 	"github.com/jackc/pgx/v4"
 	"github.com/pokt-network/pocket/persistence/kvstore"
@@ -41,13 +40,6 @@ type PostgresContext struct {
 	conn       *pgx.Conn
 	tx         pgx.Tx
 	blockstore kvstore.KVStore
-
-	stateHash []byte
-	// IMPROVE: Depending on how the use of `PostgresContext` evolves, we may be able to get
-	// access to these directly via the postgres module.
-	PostgresDB  *pgx.Conn
-	BlockStore  kvstore.KVStore                      // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context)
-	MerkleTrees map[MerkleTree]*smt.SparseMerkleTree // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context)
 }
 
 func (pg *PostgresContext) GetCtxAndTx() (context.Context, pgx.Tx, error) {
diff --git a/persistence/debug.go b/persistence/debug.go
index e0e3b6e5e..3fdc583a4 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -44,7 +44,7 @@ func (m *PersistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 
 func (m *PersistenceModule) clearState(_ *debug.DebugMessage) {
 	context, err := m.NewRWContext(-1)
-	defer context.Commit(nil, nil)
+	defer context.Commit()
 	if err != nil {
 		log.Printf("Error creating new context: %s \n", err)
 		return
diff --git a/persistence/genesis.go b/persistence/genesis.go
index a6eefaa90..1c7e82f14 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -149,7 +149,7 @@ func (m *PersistenceModule) populateGenesisState(state *types.PersistenceGenesis
 		log.Fatalf("an error occurred initializing flags: %s", err.Error())
 	}
 
-	if err = rwContext.Commit(nil, nil); err != nil {
+	if err = rwContext.Commit(); err != nil {
 		log.Fatalf("an error occurred during commit() on genesis state %s ", err.Error())
 	}
 }
@@ -316,7 +316,7 @@ func (p PostgresContext) GetAllFishermen(height int64) (f []modules.Actor, err e
 	return
 }
 
-// CONSOLIDATE: Consolidate `types.BaseActor` with `types.Actor`
+// TODO (Team) deprecate with interface #163 <Bumped to #149> as #163 is getting large
 func (p PostgresContext) BaseActorToActor(ba types.BaseActor, actorType types.ActorType) *types.Actor {
 	actor := new(types.Actor)
 	actor.ActorType = actorType
diff --git a/persistence/kvstore/kvstore.go b/persistence/kvstore/kvstore.go
deleted file mode 100644
index 8636e4519..000000000
--- a/persistence/kvstore/kvstore.go
+++ /dev/null
@@ -1,164 +0,0 @@
-package kvstore
-
-import (
-	"errors"
-	"log"
-
-	"github.com/celestiaorg/smt"
-	badger "github.com/dgraph-io/badger/v3"
-)
-
-type KVStore interface {
-	// Lifecycle methods
-	Stop() error
-
-	// Accessors
-	// TODO: Add a proper iterator interface
-	// TODO: Add pagination for `GetAll`
-	GetAll(prefixKey []byte, descending bool) ([][]byte, error)
-
-	Exists(key []byte) (bool, error)
-	ClearAll() error
-
-	// Same interface as in `smt.MapStore``
-	Put(key, value []byte) error
-	Get(key []byte) ([]byte, error)
-	Delete(key []byte) error
-}
-
-var _ KVStore = &badgerKVStore{}
-var _ smt.MapStore = &badgerKVStore{}
-
-var (
-	ErrKVStoreExists    = errors.New("kvstore already exists")
-	ErrKVStoreNotExists = errors.New("kvstore does not exist")
-)
-
-type badgerKVStore struct {
-	db *badger.DB
-}
-
-// REFACTOR: Loads or creates a badgerDb at `path`. This may potentially need to be refactored
-// into `NewKVStore` and `LoadKVStore` depending on how state sync evolves by leveraging `os.Stat`
-// on the file path.
-func OpenKVStore(path string) (KVStore, error) {
-	db, err := badger.Open(badger.DefaultOptions(path))
-	if err != nil {
-		return nil, err
-	}
-	return badgerKVStore{db: db}, nil
-}
-
-func NewMemKVStore() KVStore {
-	db, err := badger.Open(badger.DefaultOptions("").WithInMemory(true))
-	if err != nil {
-		log.Fatal(err)
-	}
-	return badgerKVStore{db: db}
-}
-
-func (store badgerKVStore) Put(key, value []byte) error {
-	tx := store.db.NewTransaction(true)
-	defer tx.Discard()
-
-	err := tx.Set(key, value)
-	if err != nil {
-		return err
-	}
-
-	return tx.Commit()
-}
-
-// CONSOLIDATE: We might be able to remove the `KVStore` interface altogether if we end up using `smt.MapStore`
-// A wrapper around `Put` to conform to the `smt.MapStore` interface
-func (store *badgerKVStore) Set(key, value []byte) error {
-	return store.Put(key, value)
-}
-
-func (store badgerKVStore) Get(key []byte) ([]byte, error) {
-	tx := store.db.NewTransaction(false)
-	defer tx.Discard()
-
-	item, err := tx.Get(key)
-	if err != nil {
-		return nil, err
-	}
-
-	value, err := item.ValueCopy(nil)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := tx.Commit(); err != nil {
-		return nil, err
-	}
-
-	return value, nil
-}
-
-func (store badgerKVStore) Delete(key []byte) error {
-	log.Fatalf("badgerKVStore.Delete not implemented yet")
-	return nil
-}
-
-func (store badgerKVStore) GetAll(prefix []byte, descending bool) (values [][]byte, err error) {
-	// INVESTIGATE: research `badger.views` for further improvements and optimizations
-	txn := store.db.NewTransaction(false)
-	defer txn.Discard()
-
-	opt := badger.DefaultIteratorOptions
-	opt.Prefix = prefix
-	opt.Reverse = descending
-	if descending {
-		prefix = prefixEndBytes(prefix)
-	}
-	it := txn.NewIterator(opt)
-	defer it.Close()
-
-	for it.Seek(prefix); it.Valid(); it.Next() {
-		item := it.Item()
-		err = item.Value(func(v []byte) error {
-			b := make([]byte, len(v))
-			copy(b, v)
-			values = append(values, b)
-			return nil
-		})
-		if err != nil {
-			return
-		}
-	}
-	return
-}
-
-func (store badgerKVStore) Exists(key []byte) (bool, error) {
-	val, err := store.Get(key)
-	if err != nil {
-		return false, err
-	}
-	return val != nil, nil
-}
-
-func (store badgerKVStore) ClearAll() error {
-	return store.db.DropAll()
-}
-
-func (store badgerKVStore) Stop() error {
-	return store.db.Close()
-}
-
-// PrefixEndBytes returns the end byteslice for a noninclusive range
-// that would include all byte slices for which the input is the prefix
-func prefixEndBytes(prefix []byte) []byte {
-	if len(prefix) == 0 {
-		return nil
-	}
-
-	if prefix[len(prefix)-1] == byte(255) {
-		return prefixEndBytes(prefix[:len(prefix)-1])
-	}
-
-	end := make([]byte, len(prefix))
-	copy(end, prefix)
-	end[len(end)-1]++
-	return end
-}
diff --git a/persistence/module.go b/persistence/module.go
deleted file mode 100644
index 6761bb22b..000000000
--- a/persistence/module.go
+++ /dev/null
@@ -1,258 +0,0 @@
-package persistence
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"log"
-
-	"github.com/celestiaorg/smt"
-	"github.com/jackc/pgx/v4"
-	"github.com/pokt-network/pocket/persistence/kvstore"
-	"github.com/pokt-network/pocket/persistence/types"
-	"github.com/pokt-network/pocket/shared/modules"
-	"github.com/pokt-network/pocket/shared/test_artifacts"
-)
-
-var _ modules.PersistenceModule = &PersistenceModule{}
-var _ modules.PersistenceRWContext = &PostgresContext{}
-var _ modules.PersistenceGenesisState = &types.PersistenceGenesisState{}
-var _ modules.PersistenceConfig = &types.PersistenceConfig{}
-
-type PersistenceModule struct {
-	bus modules.Bus
-
-	postgresURL string
-	nodeSchema  string
-	genesisPath string
-
-	// TECHDEBT: Need to implement context pooling (for writes), timeouts (for read & writes), etc...
-	writeContext *PostgresContext // only one write context is allowed at a time
-
-	// The connection to the PostgreSQL database
-	postgresConn *pgx.Conn
-	// A reference to the block key-value store
-	// INVESTIGATE: We may need to create a custom `BlockStore` package in the future.
-	blockStore kvstore.KVStore
-	// A mapping of context IDs to persistence contexts
-	// contexts map[contextId]modules.PersistenceRWContext
-	// Merkle trees
-	trees map[MerkleTree]*smt.SparseMerkleTree
-}
-
-const (
-	PersistenceModuleName = "persistence"
-)
-
-func Create(configPath, genesisPath string) (modules.PersistenceModule, error) {
-	m := new(PersistenceModule)
-	c, err := m.InitConfig(configPath)
-	if err != nil {
-		return nil, err
-	}
-
-	cfg := c.(*types.PersistenceConfig)
-	g, err := m.InitGenesis(genesisPath)
-
-	if err != nil {
-		return nil, err
-	}
-	genesis := g.(*types.PersistenceGenesisState)
-	conn, err := connectToDatabase(cfg.GetPostgresUrl(), cfg.GetNodeSchema())
-	if err != nil {
-		return nil, err
-	}
-	if err := initializeDatabase(conn); err != nil {
-		return nil, err
-	}
-	conn.Close(context.TODO())
-
-	blockStore, err := initializeBlockStore(cfg.GetBlockStorePath())
-	if err != nil {
-		return nil, err
-	}
-
-	persistenceMod := &PersistenceModule{
-		bus:          nil,
-		postgresURL:  cfg.GetPostgresUrl(),
-		nodeSchema:   cfg.GetNodeSchema(),
-		genesisPath:  genesisPath,
-		blockStore:   blockStore,
-		writeContext: nil,
-		// contexts:     make(map[contextId]modules.PersistenceContext),
-		trees: make(map[MerkleTree]*smt.SparseMerkleTree),
-	}
-
-	// DISCUSS_IN_THIS_COMMIT: We've been using the module function pattern, but this making `initializeTrees`
-	// be able to create and/or load trees outside the scope of the persistence module makes it easier to test.
-	trees, err := newMerkleTrees()
-	if err != nil {
-		return nil, err
-	}
-
-	// TODO_IN_THIS_COMMIT: load trees from state
-	persistenceMod.trees = trees
-
-	// Determine if we should hydrate the genesis db or use the current state of the DB attached
-	if shouldHydrateGenesis, err := persistenceMod.shouldHydrateGenesisDb(); err != nil {
-		return nil, err
-	} else if shouldHydrateGenesis {
-		// TECHDEBT: reconsider if this is the best place to call `populateGenesisState`. Note that
-		// 		     this forces the genesis state to be reloaded on every node startup until state sync is
-		//           implemented.
-		// NOTE: `populateGenesisState` does not return an error but logs a fatal error if there's a problem
-		persistenceMod.populateGenesisState(genesis)
-	} else {
-		log.Println("Loading state from previous state...")
-	}
-
-	return persistenceMod, nil
-}
-
-func (m *PersistenceModule) InitConfig(pathToConfigJSON string) (config modules.IConfig, err error) {
-	data, err := ioutil.ReadFile(pathToConfigJSON)
-	if err != nil {
-		return
-	}
-	// over arching configuration file
-	rawJSON := make(map[string]json.RawMessage)
-	if err = json.Unmarshal(data, &rawJSON); err != nil {
-		log.Fatalf("[ERROR] an error occurred unmarshalling the %s file: %v", pathToConfigJSON, err.Error())
-	}
-	// persistence specific configuration file
-	config = new(types.PersistenceConfig)
-	err = json.Unmarshal(rawJSON[m.GetModuleName()], config)
-	return
-}
-
-func (m *PersistenceModule) InitGenesis(pathToGenesisJSON string) (genesis modules.IGenesis, err error) {
-	data, err := ioutil.ReadFile(pathToGenesisJSON)
-	if err != nil {
-		return
-	}
-	// over arching configuration file
-	rawJSON := make(map[string]json.RawMessage)
-	if err = json.Unmarshal(data, &rawJSON); err != nil {
-		log.Fatalf("[ERROR] an error occurred unmarshalling the %s file: %v", pathToGenesisJSON, err.Error())
-	}
-	// persistence specific configuration file
-	genesis = new(types.PersistenceGenesisState)
-	err = json.Unmarshal(rawJSON[test_artifacts.GetGenesisFileName(m.GetModuleName())], genesis)
-	return
-}
-
-func (m *PersistenceModule) Start() error {
-	log.Println("Starting persistence module...")
-	return nil
-}
-
-func (m *PersistenceModule) Stop() error {
-	m.blockStore.Stop()
-	return nil
-}
-
-func (m *PersistenceModule) GetModuleName() string {
-	return PersistenceModuleName
-}
-
-func (m *PersistenceModule) SetBus(bus modules.Bus) {
-	m.bus = bus
-}
-
-func (m *PersistenceModule) GetBus() modules.Bus {
-	if m.bus == nil {
-		log.Fatalf("PocketBus is not initialized")
-	}
-	return m.bus
-}
-
-func (m *PersistenceModule) NewRWContext(height int64) (modules.PersistenceRWContext, error) {
-	if m.writeContext != nil && !m.writeContext.conn.IsClosed() {
-		return nil, fmt.Errorf("write context already exists")
-	}
-	conn, err := connectToDatabase(m.postgresURL, m.nodeSchema)
-	if err != nil {
-		return nil, err
-	}
-	tx, err := conn.BeginTx(context.TODO(), pgx.TxOptions{
-		IsoLevel:       pgx.ReadUncommitted,
-		AccessMode:     pgx.ReadWrite,
-		DeferrableMode: pgx.Deferrable, // TODO(andrew): Research if this should be `Deferrable`
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	m.writeContext = &PostgresContext{
-		Height:     height,
-		conn:       conn,
-		tx:         tx,
-		blockstore: m.blockStore,
-	}
-
-	return *m.writeContext, nil
-
-}
-
-func (m *PersistenceModule) NewReadContext(height int64) (modules.PersistenceReadContext, error) {
-	conn, err := connectToDatabase(m.postgresURL, m.nodeSchema)
-	if err != nil {
-		return nil, err
-	}
-	tx, err := conn.BeginTx(context.TODO(), pgx.TxOptions{
-		IsoLevel:       pgx.ReadCommitted,
-		AccessMode:     pgx.ReadOnly,
-		DeferrableMode: pgx.NotDeferrable, // TODO(andrew): Research if this should be `Deferrable`
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return PostgresContext{
-		Height:     height,
-		conn:       conn,
-		tx:         tx,
-		blockstore: m.blockStore,
-	}, nil
-}
-
-func (m *PersistenceModule) ResetContext() error {
-	if m.writeContext != nil {
-		if !m.writeContext.GetTx().Conn().IsClosed() {
-			if err := m.writeContext.Release(); err != nil {
-				log.Println("[TODO][ERROR] Error releasing write context...", err)
-			}
-		}
-		m.writeContext = nil
-	}
-	return nil
-}
-
-func (m *PersistenceModule) GetBlockStore() kvstore.KVStore {
-	return m.blockStore
-}
-
-func initializeBlockStore(blockStorePath string) (kvstore.KVStore, error) {
-	if blockStorePath == "" {
-		return kvstore.NewMemKVStore(), nil
-	}
-	return kvstore.OpenKVStore(blockStorePath)
-}
-
-// TODO(drewsky): Simplify and externalize the logic for whether genesis should be populated and
-// move the if logic out of this file.
-func (m *PersistenceModule) shouldHydrateGenesisDb() (bool, error) {
-	checkContext, err := m.NewReadContext(-1)
-	if err != nil {
-		return false, err
-	}
-	defer checkContext.Close()
-
-	maxHeight, err := checkContext.GetLatestBlockHeight()
-	if err == nil || maxHeight == 0 {
-		return true, nil
-	}
-
-	return m.blockStore.Exists(heightToBytes(int64(maxHeight)))
-}
diff --git a/persistence/proto/block_persistence.proto b/persistence/proto/block_persistence.proto
deleted file mode 100644
index 0c314690d..000000000
--- a/persistence/proto/block_persistence.proto
+++ /dev/null
@@ -1,13 +0,0 @@
-syntax = "proto3";
-package persistence;
-
-option go_package = "github.com/pokt-network/pocket/persistence/types";
-
-message Block {
-    uint64 height = 1;
-    string hash = 2;
-    string prevHash = 3;
-    bytes proposerAddress = 4;
-    bytes quorumCertificate = 5;
-    repeated bytes transactions = 6;
-}
\ No newline at end of file
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
deleted file mode 100644
index 8eac77562..000000000
--- a/persistence/shared_sql.go
+++ /dev/null
@@ -1,325 +0,0 @@
-package persistence
-
-import (
-	"context"
-	"encoding/hex"
-	"fmt"
-
-	"github.com/jackc/pgx/v4"
-	"github.com/pokt-network/pocket/persistence/types"
-	"github.com/pokt-network/pocket/shared/modules"
-)
-
-// IMPROVE(team): Move this into a proto enum. We are not using `iota` for the time being
-// for the purpose of being explicit: https://github.com/pokt-network/pocket/pull/140#discussion_r939731342
-// TODO Cleanup with #149
-const (
-	UndefinedStakingStatus = 0
-	UnstakingStatus        = 1
-	StakedStatus           = 2
-	UnstakedStatus         = 3
-)
-
-func UnstakingHeightToStatus(unstakingHeight int64) int32 {
-	switch unstakingHeight {
-	case -1:
-		return StakedStatus
-	case 0:
-		return UnstakedStatus
-	default:
-		return UnstakingStatus
-	}
-}
-
-func (p *PostgresContext) GetExists(actorSchema types.ProtocolActorSchema, address []byte, height int64) (exists bool, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return
-	}
-
-	if err = tx.QueryRow(ctx, actorSchema.GetExistsQuery(hex.EncodeToString(address), height)).Scan(&exists); err != nil {
-		return
-	}
-
-	return
-}
-
-func (p *PostgresContext) GetActorsUpdated(actorSchema types.ProtocolActorSchema, height int64) (actors []types.BaseActor, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return
-	}
-
-	rows, err := tx.Query(ctx, actorSchema.GetUpdatedAtHeightQuery(height))
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	// OPTIMIZE: Consolidate logic with `GetActor` to reduce code footprint
-	var addr string
-	for rows.Next() {
-		if err = rows.Scan(&addr); err != nil {
-			return
-		}
-
-		actor, err := p.GetActor(actorSchema, []byte(addr), height)
-		if err != nil {
-			return nil, err
-		}
-
-		actors = append(actors, actor)
-	}
-
-	return
-}
-
-func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, address []byte, height int64) (actor types.BaseActor, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return
-	}
-	actor, height, err = p.GetActorFromRow(tx.QueryRow(ctx, actorSchema.GetQuery(hex.EncodeToString(address), height)))
-	if err != nil {
-		return
-	}
-
-	return p.GetChainsForActor(ctx, tx, actorSchema, actor, height)
-}
-
-// IMPORTANT: Need to consolidate `persistence/types.BaseActor` with `persistence/genesisTypes.Actor`
-func (p *PostgresContext) GetActorFromRow(row pgx.Row) (actor types.BaseActor, height int64, err error) {
-	err = row.Scan(
-		&actor.Address,
-		&actor.PublicKey,
-		&actor.StakedTokens,
-		&actor.ActorSpecificParam,
-		&actor.OutputAddress,
-		&actor.PausedHeight,
-		&actor.UnstakingHeight,
-		&height)
-	return
-}
-
-func (p *PostgresContext) GetChainsForActor(
-	ctx context.Context,
-	tx pgx.Tx,
-	actorSchema types.ProtocolActorSchema,
-	actor types.BaseActor,
-	height int64) (a types.BaseActor, err error) {
-	if actorSchema.GetChainsTableName() == "" {
-		return actor, nil
-	}
-	rows, err := tx.Query(ctx, actorSchema.GetChainsQuery(actor.Address, height))
-	if err != nil {
-		return actor, err
-	}
-	defer rows.Close()
-
-	var chainAddr string
-	var chainID string
-	var chainEndHeight int64 // unused
-	for rows.Next() {
-		err = rows.Scan(&chainAddr, &chainID, &chainEndHeight)
-		if err != nil {
-			return
-		}
-		if chainAddr != actor.Address {
-			return actor, fmt.Errorf("unexpected address %s, expected %s when reading chains", chainAddr, actor.Address)
-		}
-		actor.Chains = append(actor.Chains, chainID)
-	}
-	return actor, nil
-}
-
-func (p *PostgresContext) InsertActor(actorSchema types.ProtocolActorSchema, actor types.BaseActor) error {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return err
-	}
-
-	height, err := p.GetHeight()
-	if err != nil {
-		return err
-	}
-
-	_, err = tx.Exec(ctx, actorSchema.InsertQuery(
-		actor.Address, actor.PublicKey, actor.StakedTokens, actor.ActorSpecificParam,
-		actor.OutputAddress, actor.PausedHeight, actor.UnstakingHeight, actor.Chains,
-		height))
-	return err
-}
-
-func (p *PostgresContext) UpdateActor(actorSchema types.ProtocolActorSchema, actor types.BaseActor) error {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return err
-	}
-
-	height, err := p.GetHeight()
-	if err != nil {
-		return err
-	}
-
-	if _, err = tx.Exec(ctx, actorSchema.UpdateQuery(actor.Address, actor.StakedTokens, actor.ActorSpecificParam, height)); err != nil {
-		return err
-	}
-
-	chainsTableName := actorSchema.GetChainsTableName()
-	if chainsTableName != "" && actor.Chains != nil {
-		if _, err = tx.Exec(ctx, types.NullifyChains(actor.Address, height, chainsTableName)); err != nil {
-			return err
-		}
-		if _, err = tx.Exec(ctx, actorSchema.UpdateChainsQuery(actor.Address, actor.Chains, height)); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (p *PostgresContext) GetActorsReadyToUnstake(actorSchema types.ProtocolActorSchema, height int64) (actors []modules.IUnstakingActor, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return nil, err
-	}
-
-	rows, err := tx.Query(ctx, actorSchema.GetReadyToUnstakeQuery(height))
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	for rows.Next() {
-		unstakingActor := &types.UnstakingActor{}
-		var addr, output, stakeAmount string
-		if err = rows.Scan(&addr, &stakeAmount, &output); err != nil {
-			return
-		}
-		unstakingActor.SetAddress(addr)
-		unstakingActor.SetStakeAmount(stakeAmount)
-		unstakingActor.SetOutputAddress(output)
-		actors = append(actors, unstakingActor)
-	}
-	return
-}
-
-func (p *PostgresContext) GetActorStatus(actorSchema types.ProtocolActorSchema, address []byte, height int64) (int, error) {
-	var unstakingHeight int64
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return UndefinedStakingStatus, err
-	}
-
-	if err := tx.QueryRow(ctx, actorSchema.GetUnstakingHeightQuery(hex.EncodeToString(address), height)).Scan(&unstakingHeight); err != nil {
-		return UndefinedStakingStatus, err
-	}
-
-	switch {
-	case unstakingHeight == -1:
-		return StakedStatus, nil
-	case unstakingHeight > height:
-		return UnstakingStatus, nil
-	default:
-		return UnstakedStatus, nil
-	}
-}
-
-func (p *PostgresContext) SetActorUnstakingHeightAndStatus(actorSchema types.ProtocolActorSchema, address []byte, unstakingHeight int64) error {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return err
-	}
-
-	height, err := p.GetHeight()
-	if err != nil {
-		return err
-	}
-
-	_, err = tx.Exec(ctx, actorSchema.UpdateUnstakingHeightQuery(hex.EncodeToString(address), unstakingHeight, height))
-	return err
-}
-
-func (p *PostgresContext) GetActorPauseHeightIfExists(actorSchema types.ProtocolActorSchema, address []byte, height int64) (pausedHeight int64, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return types.DefaultBigInt, err
-	}
-
-	if err := tx.QueryRow(ctx, actorSchema.GetPausedHeightQuery(hex.EncodeToString(address), height)).Scan(&pausedHeight); err != nil {
-		return types.DefaultBigInt, err
-	}
-
-	return pausedHeight, nil
-}
-
-func (p PostgresContext) SetActorStatusAndUnstakingHeightIfPausedBefore(actorSchema types.ProtocolActorSchema, pausedBeforeHeight, unstakingHeight int64) error {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return err
-	}
-
-	currentHeight, err := p.GetHeight()
-	if err != nil {
-		return err
-	}
-
-	_, err = tx.Exec(ctx, actorSchema.UpdateUnstakedHeightIfPausedBeforeQuery(pausedBeforeHeight, unstakingHeight, currentHeight))
-	return err
-}
-
-func (p PostgresContext) SetActorPauseHeight(actorSchema types.ProtocolActorSchema, address []byte, pauseHeight int64) error {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return err
-	}
-
-	currentHeight, err := p.GetHeight()
-	if err != nil {
-		return err
-	}
-
-	_, err = tx.Exec(ctx, actorSchema.UpdatePausedHeightQuery(hex.EncodeToString(address), pauseHeight, currentHeight))
-	return err
-}
-
-func (p PostgresContext) SetActorStakeAmount(actorSchema types.ProtocolActorSchema, address []byte, stakeAmount string) error {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return err
-	}
-
-	currentHeight, err := p.GetHeight()
-	if err != nil {
-		return err
-	}
-	_, err = tx.Exec(ctx, actorSchema.SetStakeAmountQuery(hex.EncodeToString(address), stakeAmount, currentHeight))
-	return err
-}
-
-func (p PostgresContext) GetActorOutputAddress(actorSchema types.ProtocolActorSchema, operatorAddr []byte, height int64) ([]byte, error) {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return nil, err
-	}
-
-	var outputAddr string
-	if err := tx.QueryRow(ctx, actorSchema.GetOutputAddressQuery(hex.EncodeToString(operatorAddr), height)).Scan(&outputAddr); err != nil {
-		return nil, err
-	}
-
-	return hex.DecodeString(outputAddr)
-}
-
-func (p PostgresContext) GetActorStakeAmount(actorSchema types.ProtocolActorSchema, address []byte, height int64) (string, error) {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return "", err
-	}
-
-	var stakeAmount string
-	if err := tx.QueryRow(ctx, actorSchema.GetStakeAmountQuery(hex.EncodeToString(address), height)).Scan(&stakeAmount); err != nil {
-		return "", err
-	}
-	return stakeAmount, nil
-}
diff --git a/persistence/state.go b/persistence/state.go
deleted file mode 100644
index 5c3913140..000000000
--- a/persistence/state.go
+++ /dev/null
@@ -1,119 +0,0 @@
-package persistence
-
-import (
-	"bytes"
-	"crypto/sha256"
-	"encoding/hex"
-	"fmt"
-	"log"
-	"sort"
-
-	"github.com/celestiaorg/smt"
-	typesUtil "github.com/pokt-network/pocket/utility/types"
-	"google.golang.org/protobuf/proto"
-)
-
-type MerkleTree float64
-
-// A work-in-progress list of all the trees we need to update to maintain the overall state
-const (
-	// Actor  Merkle Trees
-	appMerkleTree MerkleTree = iota
-	valMerkleTree
-	fishMerkleTree
-	serviceNodeMerkleTree
-	accountMerkleTree
-	poolMerkleTree
-
-	// Data / State Merkle Trees
-	blocksMerkleTree
-	paramsMerkleTree
-	flagsMerkleTree
-
-	// Used for iteration purposes only - see https://stackoverflow.com/a/64178235/768439
-	lastMerkleTree
-)
-
-func newMerkleTrees() (map[MerkleTree]*smt.SparseMerkleTree, error) {
-	// We need a separate Merkle tree for each type of actor or storage
-	trees := make(map[MerkleTree]*smt.SparseMerkleTree, int(lastMerkleTree))
-
-	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
-		// TODO_IN_THIS_COMMIT: Rather than using `NewSimpleMap`, use a disk based key-value store
-		nodeStore := smt.NewSimpleMap()
-		valueStore := smt.NewSimpleMap()
-
-		trees[treeType] = smt.NewSparseMerkleTree(nodeStore, valueStore, sha256.New())
-	}
-	return trees, nil
-}
-
-func loadMerkleTrees(map[MerkleTree]*smt.SparseMerkleTree, error) {
-	log.Fatalf("loadMerkleTrees not implemented yet")
-}
-
-func (p *PostgresContext) updateStateHash() error {
-	// Update all the merkle trees
-	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
-		switch treeType {
-		case appMerkleTree:
-			apps, err := p.getApplicationsUpdatedAtHeight(p.Height)
-			if err != nil {
-				// TODO_IN_THIS_COMMIT: Update this error
-				return typesUtil.NewError(typesUtil.Code(42), "Couldn't figure out apps updated")
-			}
-			for _, app := range apps {
-				appBz, err := proto.Marshal(app)
-				if err != nil {
-					return err
-				}
-				// An update results in a create/update that is idempotent
-				addrBz, err := hex.DecodeString(app.Address)
-				if err != nil {
-					return err
-				}
-				if _, err := p.MerkleTrees[treeType].Update(addrBz, appBz); err != nil {
-					return err
-				}
-			}
-		case valMerkleTree:
-			fmt.Println("TODO: valMerkleTree not implemented")
-		case fishMerkleTree:
-			fmt.Println("TODO: fishMerkleTree not implemented")
-		case serviceNodeMerkleTree:
-			fmt.Println("TODO: serviceNodeMerkleTree not implemented")
-		case accountMerkleTree:
-			fmt.Println("TODO: accountMerkleTree not implemented")
-		case poolMerkleTree:
-			fmt.Println("TODO: poolMerkleTree not implemented")
-		case blocksMerkleTree:
-			// VERY VERY IMPORTANT DISCUSSION: What do we do here provided that `Commit`, which stores the block in the DB and tree
-			//                                 requires the quorumCert, which we receive at the very end of hotstuff consensus
-			fmt.Println("TODO: blocksMerkleTree not implemented")
-		case paramsMerkleTree:
-			fmt.Println("TODO: paramsMerkleTree not implemented")
-		case flagsMerkleTree:
-			fmt.Println("TODO: flagsMerkleTree not implemented")
-		default:
-			log.Fatalln("Not handled yet in state commitment update", treeType)
-		}
-	}
-
-	// Get the root of each Merkle Tree
-	roots := make([][]byte, 0)
-	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
-		roots = append(roots, p.MerkleTrees[treeType].Root())
-	}
-
-	// Sort the merkle roots lexicographically
-	sort.Slice(roots, func(r1, r2 int) bool {
-		return bytes.Compare(roots[r1], roots[r2]) < 0
-	})
-
-	// Get the state hash
-	rootsConcat := bytes.Join(roots, []byte{})
-	stateHash := sha256.Sum256(rootsConcat)
-
-	p.stateHash = stateHash[:]
-	return nil
-}
diff --git a/persistence/state_test.go b/persistence/state_test.go
deleted file mode 100644
index 9570f4c00..000000000
--- a/persistence/state_test.go
+++ /dev/null
@@ -1,15 +0,0 @@
-package persistence
-
-import "testing"
-
-func TestStateHash_InitializeTrees(t *testing.T) {
-
-}
-
-func TestStateHash_LoadTrees(t *testing.T) {
-
-}
-
-func TestStateHash_ComputeStateHash(t *testing.T) {
-
-}
diff --git a/persistence/test/module_test.go b/persistence/test/module_test.go
index ccb7bd37f..3bee636c5 100644
--- a/persistence/test/module_test.go
+++ b/persistence/test/module_test.go
@@ -18,14 +18,12 @@ func TestPersistenceContextParallelReadWrite(t *testing.T) {
 	poolAddress := []byte("address")
 	originalAmount := "15"
 	modifiedAmount := "10"
-	proposer := []byte("proposer")
-	quorumCert := []byte("quorumCert")
 
 	// setup a write context, insert a pool and commit it
 	context, err := testPersistenceMod.NewRWContext(0)
 	require.NoError(t, err)
 	require.NoError(t, context.InsertPool(poolName, poolAddress, originalAmount))
-	require.NoError(t, context.Commit(proposer, quorumCert))
+	require.NoError(t, context.Commit())
 
 	// verify the insert in the previously committed context worked
 	contextA, err := testPersistenceMod.NewRWContext(0)
diff --git a/persistence/types/base_actor.go b/persistence/types/base_actor.go
index 1c73da9a7..9514b15eb 100644
--- a/persistence/types/base_actor.go
+++ b/persistence/types/base_actor.go
@@ -1,6 +1,5 @@
 package types
 
-// IMPROVE: Move schema related functions to a separate sub-package
 import "github.com/pokt-network/pocket/shared/modules"
 
 // TECHDEBT: Consider moving this to a protobuf. This struct was created to make testing simple of protocol actors that
@@ -61,10 +60,6 @@ func (actor *BaseProtocolActorSchema) GetChainsTableSchema() string {
 	return ProtocolActorChainsTableSchema(actor.chainsHeightConstraintName)
 }
 
-func (actor *BaseProtocolActorSchema) GetUpdatedAtHeightQuery(height int64) string {
-	return SelectAtHeight(AddressCol, height, actor.tableName)
-}
-
 func (actor *BaseProtocolActorSchema) GetQuery(address string, height int64) string {
 	return Select(AllColsSelector, address, height, actor.tableName)
 }
@@ -155,5 +150,5 @@ func (x *Actor) GetActorTyp() modules.ActorType {
 	if x != nil {
 		return x.GetActorType()
 	}
-	return ActorType_App // HACK: Is this a hack?
+	return ActorType_App
 }
diff --git a/persistence/types/protocol_actor.go b/persistence/types/protocol_actor.go
index cb1e23fbf..4b57e8e40 100644
--- a/persistence/types/protocol_actor.go
+++ b/persistence/types/protocol_actor.go
@@ -15,9 +15,6 @@ type ProtocolActorSchema interface {
 	GetActorSpecificColName() string
 
 	/*** Read/Get Queries ***/
-
-	// Returns a query to retrieve the addresses of all the Actors updated at that specific height
-	GetUpdatedAtHeightQuery(height int64) string
 	// Returns a query to retrieve all of a single Actor's attributes.
 	GetQuery(address string, height int64) string
 	// Returns all actors at that height
diff --git a/persistence/types/shared_sql.go b/persistence/types/shared_sql.go
index 6c053b6de..5502c03d3 100644
--- a/persistence/types/shared_sql.go
+++ b/persistence/types/shared_sql.go
@@ -69,11 +69,6 @@ func ProtocolActorChainsTableSchema(constraintName string) string {
 		)`, AddressCol, ChainIDCol, HeightCol, DefaultBigInt, constraintName, AddressCol, ChainIDCol, HeightCol)
 }
 
-func SelectAtHeight(selector string, height int64, tableName string) string {
-	return fmt.Sprintf(`SELECT %s FROM %s WHERE height=%d`,
-		selector, tableName, height)
-}
-
 func Select(selector, address string, height int64, tableName string) string {
 	return fmt.Sprintf(`SELECT %s FROM %s WHERE address='%s' AND height<=%d ORDER BY height DESC LIMIT 1`,
 		selector, tableName, address, height)
diff --git a/shared/codec/codec.go b/shared/codec/codec.go
index ac7765673..a41fe2e0b 100644
--- a/shared/codec/codec.go
+++ b/shared/codec/codec.go
@@ -5,6 +5,8 @@ import (
 	"google.golang.org/protobuf/types/known/anypb"
 )
 
+// TODO: Use generics in place of `proto.Message` in the interface below
+//       so every caller does not need to do in place casting.
 type Codec interface { // TODO (Team) move to shared. Possibly rename
 	Marshal(proto.Message) ([]byte, error)
 	Unmarshal([]byte, proto.Message) error
@@ -14,6 +16,8 @@ type Codec interface { // TODO (Team) move to shared. Possibly rename
 
 var _ Codec = &ProtoCodec{}
 
+// TODO: Need to define a type like `type ProtoAny anypb.Any` so that we are
+//       mixing protobufs and a centralized codec structure throughout the codebase.
 type ProtoCodec struct{}
 
 func (p *ProtoCodec) Marshal(message proto.Message) ([]byte, error) {
diff --git a/shared/docs/flows/AppHash.md b/shared/docs/flows/AppHash.md
new file mode 100644
index 000000000..61b3eb79b
--- /dev/null
+++ b/shared/docs/flows/AppHash.md
@@ -0,0 +1,101 @@
+# AppHash
+
+## Context Initialization
+
+```mermaid
+sequenceDiagram
+    %% autonumber
+    participant N as Node
+    participant C as Consensus
+    participant U as Utility
+    participant P as Persistence
+    participant PP as Persistence (PostgresDB)
+    participant PM as Persistence (MerkleTree)
+    participant P2P as P2P
+
+    %% Should this be P2P?
+    N-->>C: HandleMessage(anypb.Any)
+    critical NewRound Message
+        C->>+U: NewContext(height)
+        U->>P: NewRWContext(height)
+        P->>U: PersistenceRWContext
+        U->>U: Store persistenceContext
+        U->>-C: UtilityContext
+        C->>C: Store utilityContext
+        Note over C, PM: See 'Block Application'
+    end
+    Note over N, P2P: Hotstuff lifecycle
+    N-->>C: HandleMessage(anypb.Any)
+    critical Decide Message
+        Note over C, PM: See 'Block Commit'
+    end
+```
+
+### Block Application
+
+```mermaid
+sequenceDiagram
+    participant C as Consensus
+    participant U as Utility
+    participant P as Persistence
+    participant PP as Persistence (PostgresDB)
+    participant PM as Persistence (MerkleTree)
+    alt as leader
+        C->>+U: GetProposalTransactions(proposer, maxTxBz, [lastVal])
+        U->>U: reap mempool
+        U->>-C: txs
+        Note over C, U: Perform replica behaviour
+    else as replica
+        C->>+U: ApplyBlock(height, proposer, txs, lastVals)
+        loop Update DB: for each operation in tx
+            U->>P: ReadOp | WriteOp
+            P->>PP: ReadOp | WriteOp
+            PP->>P: data | ok
+            P->>U: data | ok
+            U->>U: validate
+            U->>P: StoreTransaction(tx)
+            P->>P: store locally
+            P->>U: ok
+        end
+        U->>+P: UpdateAppHash()
+        loop for each protocol actor type
+            P->>PP: GetActorsUpdate(height)
+            PP->>P: actors
+            loop Update Tree: for each actor
+                P->>PM: Update(addr, serialized(actor))
+                PM->>P: ok
+            end
+            P->>PM: GetRoot()
+            PM->>P: rootHash
+        end
+        P->>P: computeStateHash(rootHashes)
+        P->>-U: stateHash
+        U->>-C: hash
+    end
+```
+
+### Block Commit
+
+```mermaid
+sequenceDiagram
+    %% autonumber
+    participant C as Consensus
+    participant U as Utility
+    participant P as Persistence
+    participant PP as Persistence (PostgresDB)
+    participant PK as Persistence (Key-Value Store)
+    C->>U: CommitContext(quorumCert)
+    U->>P: Commit(proposerAddr, quorumCert)
+    P->>P: create typesPer.Block
+    P->>PP: insertBlock(block)
+    PP->>P: ok
+    P->>PK: Put(height, block)
+    PK->>P: ok
+    P->>P: commit tx
+    P->>U: ok
+    U->>P: Release()
+    P->>U: ok
+    C->>U: Release()
+    U->>C: ok
+    C->>C: release utilityContext
+```
diff --git a/shared/docs/flows/README.md b/shared/docs/flows/README.md
new file mode 100644
index 000000000..cb4e5d663
--- /dev/null
+++ b/shared/docs/flows/README.md
@@ -0,0 +1,3 @@
+# Flows
+
+The purpose of [shared/flows](./) is to document cross-module communication for end-to-end behaviour that has cross-module dependencies and and depends on the interfaces exposed by the interfaces exposed in [shared/modules](../modules).
diff --git a/shared/indexer/indexer.go b/shared/indexer/indexer.go
index 59355787f..559ca1f6e 100644
--- a/shared/indexer/indexer.go
+++ b/shared/indexer/indexer.go
@@ -5,7 +5,6 @@ package indexer
 import (
 	"encoding/hex"
 	"fmt"
-
 	"github.com/pokt-network/pocket/shared/codec"
 
 	"github.com/jordanorelli/lexnum"
@@ -112,7 +111,7 @@ type txIndexer struct {
 }
 
 func NewTxIndexer(databasePath string) (TxIndexer, error) {
-	db, err := kvstore.OpenKVStore(databasePath)
+	db, err := kvstore.NewKVStore(databasePath)
 	return &txIndexer{
 		db: db,
 	}, err
diff --git a/shared/types/genesis/validator.go b/shared/types/genesis/validator.go
deleted file mode 100644
index 17c2af5fd..000000000
--- a/shared/types/genesis/validator.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package genesis
-
-// import (
-// 	"encoding/hex"
-// 	"encoding/json"
-
-// 	"google.golang.org/protobuf/encoding/protojson"
-// )
-
-// // TODO_IN_THIS_COMMIT: See https://github.com/pokt-network/pocket/pull/139/files to remove this shit
-
-// // HACK: Since the protocol actor protobufs (e.g. validator, fisherman, etc) use `bytes` for some
-// // fields (e.g. `address`, `output`, `publicKey`), we need to use a helper struct to unmarshal the
-// // the types when they are defined via json (e.g. genesis file, testing configurations, etc...).
-// // Alternative solutions could include whole wrapper structs (i.e. duplication of schema definition),
-// // using strings instead of bytes (i.e. major change with downstream effects) or avoid defining these
-// // types in json altogether (i.e. limitation of usability).
-// type JsonBytesLoaderHelper struct {
-// 	Address   HexData `json:"address,omitempty"`
-// 	PublicKey HexData `json:"public_key,omitempty"`
-// 	Output    HexData `json:"output,omitempty"`
-// }
-
-// type HexData []byte
-
-// func (h *HexData) UnmarshalJSON(data []byte) error {
-// 	var s string
-// 	if err := json.Unmarshal(data, &s); err != nil {
-// 		return err
-// 	}
-// 	decoded, err := hex.DecodeString(s)
-// 	if err != nil {
-// 		return err
-// 	}
-// 	*h = HexData(decoded)
-// 	return nil
-// }
-
-// func (v *Validator) UnmarshalJSON(data []byte) error {
-// 	var jh JsonBytesLoaderHelper
-// 	json.Unmarshal(data, &jh)
-
-// 	protojson.Unmarshal(data, v)
-// 	v.Address = jh.Address
-// 	v.PublicKey = jh.PublicKey
-// 	v.Output = jh.Output
-
-// 	return nil
-// }
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index f4a1420e9..c1441e405 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -3,13 +3,12 @@ package test
 import (
 	"encoding/hex"
 	"fmt"
+	"github.com/pokt-network/pocket/shared/modules"
+	"github.com/pokt-network/pocket/shared/test_artifacts"
 	"math"
 	"math/big"
 	"testing"
 
-	"github.com/pokt-network/pocket/shared/modules"
-	"github.com/pokt-network/pocket/shared/test_artifacts"
-
 	typesUtil "github.com/pokt-network/pocket/utility/types"
 	"github.com/stretchr/testify/require"
 )
@@ -173,6 +172,19 @@ func TestUtilityContext_EndBlock(t *testing.T) {
 	test_artifacts.CleanupTest(ctx)
 }
 
+func TestUtilityContext_GetAppHash(t *testing.T) {
+	ctx := NewTestingUtilityContext(t, 0)
+
+	appHashTest, err := ctx.GetAppHash()
+	require.NoError(t, err)
+
+	appHashSource, er := ctx.Context.AppHash()
+	require.NoError(t, er)
+	require.Equal(t, appHashSource, appHashTest, "unexpected appHash")
+
+	test_artifacts.CleanupTest(ctx)
+}
+
 func TestUtilityContext_UnstakeValidatorsActorsThatAreReady(t *testing.T) {
 	for _, actorType := range typesUtil.ActorTypes {
 		ctx := NewTestingUtilityContext(t, 1)

From 242565cd694b10971961c2a6adfbc6c5c6ff1f9a Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 26 Sep 2022 20:46:10 -0700
Subject: [PATCH 040/227] Undo more change

---
 consensus/consensus_tests/utils_test.go |   5 +-
 persistence/kvstore/kvstore.go          | 139 ++++++++++++
 persistence/module.go                   | 235 +++++++++++++++++++
 persistence/shared_sql.go               | 289 ++++++++++++++++++++++++
 utility/block.go                        |  53 +++--
 utility/context.go                      |  28 +--
 6 files changed, 716 insertions(+), 33 deletions(-)
 create mode 100644 persistence/kvstore/kvstore.go
 create mode 100644 persistence/module.go
 create mode 100644 persistence/shared_sql.go

diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 3499f604d..b5e3cf71a 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -369,8 +369,9 @@ func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 		ApplyBlock(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
 		Return(appHash, nil).
 		AnyTimes()
-	utilityContextMock.EXPECT().CommitContext(gomock.Any()).Return(nil).AnyTimes()
-	utilityContextMock.EXPECT().ReleaseContext().Return(nil).AnyTimes()
+	utilityContextMock.EXPECT().CommitPersistenceContext().Return(nil).AnyTimes()
+	utilityContextMock.EXPECT().ReleaseContext().Return().AnyTimes()
+	utilityContextMock.EXPECT().StoreBlock(gomock.Any()).Return(nil).AnyTimes()
 
 	return utilityContextMock
 }
diff --git a/persistence/kvstore/kvstore.go b/persistence/kvstore/kvstore.go
new file mode 100644
index 000000000..24613afc9
--- /dev/null
+++ b/persistence/kvstore/kvstore.go
@@ -0,0 +1,139 @@
+package kvstore
+
+import (
+	"log"
+
+	badger "github.com/dgraph-io/badger/v3"
+)
+
+// CLEANUP: move this structure to a shared module
+type KVStore interface {
+	// Lifecycle methods
+	Stop() error
+
+	// Accessors
+	// TODO: Add a proper iterator interface
+	Put(key []byte, value []byte) error
+	Get(key []byte) ([]byte, error)
+	// TODO: Add pagination for `GetAll`
+	GetAll(prefixKey []byte, descending bool) ([][]byte, error)
+	Exists(key []byte) (bool, error)
+	ClearAll() error
+}
+
+var _ KVStore = &badgerKVStore{}
+
+type badgerKVStore struct {
+	db *badger.DB
+}
+
+func NewKVStore(path string) (KVStore, error) {
+	db, err := badger.Open(badger.DefaultOptions(path))
+	if err != nil {
+		return nil, err
+	}
+	return badgerKVStore{db: db}, nil
+}
+
+func NewMemKVStore() KVStore {
+	db, err := badger.Open(badger.DefaultOptions("").WithInMemory(true))
+	if err != nil {
+		log.Fatal(err)
+	}
+	return badgerKVStore{db: db}
+}
+
+func (store badgerKVStore) Put(key []byte, value []byte) error {
+	tx := store.db.NewTransaction(true)
+	defer tx.Discard()
+
+	err := tx.Set(key, value)
+	if err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+func (store badgerKVStore) Get(key []byte) ([]byte, error) {
+	tx := store.db.NewTransaction(false)
+	defer tx.Discard()
+
+	item, err := tx.Get(key)
+	if err != nil {
+		return nil, err
+	}
+
+	value, err := item.ValueCopy(nil)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := tx.Commit(); err != nil {
+		return nil, err
+	}
+
+	return value, nil
+}
+
+func (store badgerKVStore) GetAll(prefix []byte, descending bool) (values [][]byte, err error) {
+	// INVESTIGATE: research `badger.views` for further improvements and optimizations
+	txn := store.db.NewTransaction(false)
+	defer txn.Discard()
+
+	opt := badger.DefaultIteratorOptions
+	opt.Prefix = prefix
+	opt.Reverse = descending
+	if descending {
+		prefix = prefixEndBytes(prefix)
+	}
+	it := txn.NewIterator(opt)
+	defer it.Close()
+
+	for it.Seek(prefix); it.Valid(); it.Next() {
+		item := it.Item()
+		err = item.Value(func(v []byte) error {
+			b := make([]byte, len(v))
+			copy(b, v)
+			values = append(values, b)
+			return nil
+		})
+		if err != nil {
+			return
+		}
+	}
+	return
+}
+
+func (store badgerKVStore) Exists(key []byte) (bool, error) {
+	val, err := store.Get(key)
+	if err != nil {
+		return false, err
+	}
+	return val != nil, nil
+}
+
+func (store badgerKVStore) ClearAll() error {
+	return store.db.DropAll()
+}
+
+func (store badgerKVStore) Stop() error {
+	return store.db.Close()
+}
+
+// PrefixEndBytes returns the end byteslice for a noninclusive range
+// that would include all byte slices for which the input is the prefix
+func prefixEndBytes(prefix []byte) []byte {
+	if len(prefix) == 0 {
+		return nil
+	}
+
+	if prefix[len(prefix)-1] == byte(255) {
+		return prefixEndBytes(prefix[:len(prefix)-1])
+	}
+
+	end := make([]byte, len(prefix))
+	copy(end, prefix)
+	end[len(end)-1]++
+	return end
+}
diff --git a/persistence/module.go b/persistence/module.go
new file mode 100644
index 000000000..33bd827bd
--- /dev/null
+++ b/persistence/module.go
@@ -0,0 +1,235 @@
+package persistence
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"log"
+
+	"github.com/pokt-network/pocket/persistence/types"
+
+	"github.com/jackc/pgx/v4"
+	"github.com/pokt-network/pocket/persistence/kvstore"
+	"github.com/pokt-network/pocket/shared/modules"
+	"github.com/pokt-network/pocket/shared/test_artifacts"
+)
+
+var _ modules.PersistenceModule = &PersistenceModule{}
+var _ modules.PersistenceRWContext = &PostgresContext{}
+var _ modules.PersistenceGenesisState = &types.PersistenceGenesisState{}
+var _ modules.PersistenceConfig = &types.PersistenceConfig{}
+
+type PersistenceModule struct {
+	bus modules.Bus
+
+	postgresURL string
+	nodeSchema  string
+	genesisPath string
+	blockStore  kvstore.KVStore // INVESTIGATE: We may need to create a custom `BlockStore` package in the future
+
+	// TECHDEBT: Need to implement context pooling (for writes), timeouts (for read & writes), etc...
+	writeContext *PostgresContext // only one write context is allowed at a time
+}
+
+const (
+	PersistenceModuleName = "persistence"
+)
+
+func Create(configPath, genesisPath string) (modules.PersistenceModule, error) {
+	m := new(PersistenceModule)
+	c, err := m.InitConfig(configPath)
+	if err != nil {
+		return nil, err
+	}
+	cfg := c.(*types.PersistenceConfig)
+	g, err := m.InitGenesis(genesisPath)
+	if err != nil {
+		return nil, err
+	}
+	genesis := g.(*types.PersistenceGenesisState)
+	conn, err := connectToDatabase(cfg.GetPostgresUrl(), cfg.GetNodeSchema())
+	if err != nil {
+		return nil, err
+	}
+	if err := initializeDatabase(conn); err != nil {
+		return nil, err
+	}
+	conn.Close(context.TODO())
+
+	blockStore, err := initializeBlockStore(cfg.GetBlockStorePath())
+	if err != nil {
+		return nil, err
+	}
+
+	persistenceMod := &PersistenceModule{
+		bus:          nil,
+		postgresURL:  cfg.GetPostgresUrl(),
+		nodeSchema:   cfg.GetNodeSchema(),
+		genesisPath:  genesisPath,
+		blockStore:   blockStore,
+		writeContext: nil,
+	}
+
+	// Determine if we should hydrate the genesis db or use the current state of the DB attached
+	if shouldHydrateGenesis, err := persistenceMod.shouldHydrateGenesisDb(); err != nil {
+		return nil, err
+	} else if shouldHydrateGenesis {
+		// TECHDEBT: reconsider if this is the best place to call `populateGenesisState`. Note that
+		// 		     this forces the genesis state to be reloaded on every node startup until state sync is
+		//           implemented.
+		// NOTE: `populateGenesisState` does not return an error but logs a fatal error if there's a problem
+		persistenceMod.populateGenesisState(genesis)
+	} else {
+		log.Println("Loading state from previous state...")
+	}
+
+	return persistenceMod, nil
+}
+
+func (m *PersistenceModule) InitConfig(pathToConfigJSON string) (config modules.IConfig, err error) {
+	data, err := ioutil.ReadFile(pathToConfigJSON)
+	if err != nil {
+		return
+	}
+	// over arching configuration file
+	rawJSON := make(map[string]json.RawMessage)
+	if err = json.Unmarshal(data, &rawJSON); err != nil {
+		log.Fatalf("[ERROR] an error occurred unmarshalling the %s file: %v", pathToConfigJSON, err.Error())
+	}
+	// persistence specific configuration file
+	config = new(types.PersistenceConfig)
+	err = json.Unmarshal(rawJSON[m.GetModuleName()], config)
+	return
+}
+
+func (m *PersistenceModule) InitGenesis(pathToGenesisJSON string) (genesis modules.IGenesis, err error) {
+	data, err := ioutil.ReadFile(pathToGenesisJSON)
+	if err != nil {
+		return
+	}
+	// over arching configuration file
+	rawJSON := make(map[string]json.RawMessage)
+	if err = json.Unmarshal(data, &rawJSON); err != nil {
+		log.Fatalf("[ERROR] an error occurred unmarshalling the %s file: %v", pathToGenesisJSON, err.Error())
+	}
+	// persistence specific configuration file
+	genesis = new(types.PersistenceGenesisState)
+	err = json.Unmarshal(rawJSON[test_artifacts.GetGenesisFileName(m.GetModuleName())], genesis)
+	return
+}
+
+func (m *PersistenceModule) Start() error {
+	log.Println("Starting persistence module...")
+	return nil
+}
+
+func (m *PersistenceModule) Stop() error {
+	m.blockStore.Stop()
+	return nil
+}
+
+func (m *PersistenceModule) GetModuleName() string {
+	return PersistenceModuleName
+}
+
+func (m *PersistenceModule) SetBus(bus modules.Bus) {
+	m.bus = bus
+}
+
+func (m *PersistenceModule) GetBus() modules.Bus {
+	if m.bus == nil {
+		log.Fatalf("PocketBus is not initialized")
+	}
+	return m.bus
+}
+
+func (m *PersistenceModule) NewRWContext(height int64) (modules.PersistenceRWContext, error) {
+	if m.writeContext != nil && !m.writeContext.conn.IsClosed() {
+		return nil, fmt.Errorf("write context already exists")
+	}
+	conn, err := connectToDatabase(m.postgresURL, m.nodeSchema)
+	if err != nil {
+		return nil, err
+	}
+	tx, err := conn.BeginTx(context.TODO(), pgx.TxOptions{
+		IsoLevel:       pgx.ReadUncommitted,
+		AccessMode:     pgx.ReadWrite,
+		DeferrableMode: pgx.Deferrable, // TODO(andrew): Research if this should be `Deferrable`
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	m.writeContext = &PostgresContext{
+		Height:     height,
+		conn:       conn,
+		tx:         tx,
+		blockstore: m.blockStore,
+	}
+
+	return *m.writeContext, nil
+
+}
+
+func (m *PersistenceModule) NewReadContext(height int64) (modules.PersistenceReadContext, error) {
+	conn, err := connectToDatabase(m.postgresURL, m.nodeSchema)
+	if err != nil {
+		return nil, err
+	}
+	tx, err := conn.BeginTx(context.TODO(), pgx.TxOptions{
+		IsoLevel:       pgx.ReadCommitted,
+		AccessMode:     pgx.ReadOnly,
+		DeferrableMode: pgx.NotDeferrable, // TODO(andrew): Research if this should be `Deferrable`
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return PostgresContext{
+		Height:     height,
+		conn:       conn,
+		tx:         tx,
+		blockstore: m.blockStore,
+	}, nil
+}
+
+func (m *PersistenceModule) ResetContext() error {
+	if m.writeContext != nil {
+		if !m.writeContext.GetTx().Conn().IsClosed() {
+			if err := m.writeContext.Release(); err != nil {
+				log.Println("[TODO][ERROR] Error releasing write context...", err)
+			}
+		}
+		m.writeContext = nil
+	}
+	return nil
+}
+
+func (m *PersistenceModule) GetBlockStore() kvstore.KVStore {
+	return m.blockStore
+}
+
+func initializeBlockStore(blockStorePath string) (kvstore.KVStore, error) {
+	if blockStorePath == "" {
+		return kvstore.NewMemKVStore(), nil
+	}
+	return kvstore.NewKVStore(blockStorePath)
+}
+
+// TODO(drewsky): Simplify and externalize the logic for whether genesis should be populated and
+// move the if logic out of this file.
+func (m *PersistenceModule) shouldHydrateGenesisDb() (bool, error) {
+	checkContext, err := m.NewReadContext(-1)
+	if err != nil {
+		return false, err
+	}
+	defer checkContext.Close()
+
+	maxHeight, err := checkContext.GetLatestBlockHeight()
+	if err == nil || maxHeight == 0 {
+		return true, nil
+	}
+
+	return m.blockStore.Exists(heightToBytes(int64(maxHeight)))
+}
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
new file mode 100644
index 000000000..9f2c19a00
--- /dev/null
+++ b/persistence/shared_sql.go
@@ -0,0 +1,289 @@
+package persistence
+
+import (
+	"context"
+	"encoding/hex"
+	"fmt"
+
+	"github.com/jackc/pgx/v4"
+	"github.com/pokt-network/pocket/persistence/types"
+	"github.com/pokt-network/pocket/shared/modules"
+)
+
+// IMPROVE(team): Move this into a proto enum. We are not using `iota` for the time being
+// for the purpose of being explicit: https://github.com/pokt-network/pocket/pull/140#discussion_r939731342
+// TODO Cleanup with #149
+const (
+	UndefinedStakingStatus = 0
+	UnstakingStatus        = 1
+	StakedStatus           = 2
+	UnstakedStatus         = 3
+)
+
+func UnstakingHeightToStatus(unstakingHeight int64) int32 {
+	switch unstakingHeight {
+	case -1:
+		return StakedStatus
+	case 0:
+		return UnstakedStatus
+	default:
+		return UnstakingStatus
+	}
+}
+
+func (p *PostgresContext) GetExists(actorSchema types.ProtocolActorSchema, address []byte, height int64) (exists bool, err error) {
+	ctx, tx, err := p.GetCtxAndTx()
+	if err != nil {
+		return
+	}
+
+	if err = tx.QueryRow(ctx, actorSchema.GetExistsQuery(hex.EncodeToString(address), height)).Scan(&exists); err != nil {
+		return
+	}
+
+	return
+}
+
+func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, address []byte, height int64) (actor types.BaseActor, err error) {
+	ctx, tx, err := p.GetCtxAndTx()
+	if err != nil {
+		return
+	}
+	actor, height, err = p.GetActorFromRow(tx.QueryRow(ctx, actorSchema.GetQuery(hex.EncodeToString(address), height)))
+	if err != nil {
+		return
+	}
+
+	return p.GetChainsForActor(ctx, tx, actorSchema, actor, height)
+}
+
+func (p *PostgresContext) GetActorFromRow(row pgx.Row) (actor types.BaseActor, height int64, err error) {
+	err = row.Scan(
+		&actor.Address, &actor.PublicKey, &actor.StakedTokens, &actor.ActorSpecificParam,
+		&actor.OutputAddress, &actor.PausedHeight, &actor.UnstakingHeight,
+		&height)
+	return
+}
+
+func (p *PostgresContext) GetChainsForActor(
+	ctx context.Context,
+	tx pgx.Tx,
+	actorSchema types.ProtocolActorSchema,
+	actor types.BaseActor,
+	height int64) (a types.BaseActor, err error) {
+	if actorSchema.GetChainsTableName() == "" {
+		return actor, nil
+	}
+	rows, err := tx.Query(ctx, actorSchema.GetChainsQuery(actor.Address, height))
+	if err != nil {
+		return actor, err
+	}
+	defer rows.Close()
+
+	var chainAddr string
+	var chainID string
+	var chainEndHeight int64 // unused
+	for rows.Next() {
+		err = rows.Scan(&chainAddr, &chainID, &chainEndHeight)
+		if err != nil {
+			return
+		}
+		if chainAddr != actor.Address {
+			return actor, fmt.Errorf("unexpected address %s, expected %s when reading chains", chainAddr, actor.Address)
+		}
+		actor.Chains = append(actor.Chains, chainID)
+	}
+	return actor, nil
+}
+
+func (p *PostgresContext) InsertActor(actorSchema types.ProtocolActorSchema, actor types.BaseActor) error {
+	ctx, tx, err := p.GetCtxAndTx()
+	if err != nil {
+		return err
+	}
+
+	height, err := p.GetHeight()
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, actorSchema.InsertQuery(
+		actor.Address, actor.PublicKey, actor.StakedTokens, actor.ActorSpecificParam,
+		actor.OutputAddress, actor.PausedHeight, actor.UnstakingHeight, actor.Chains,
+		height))
+	return err
+}
+
+func (p *PostgresContext) UpdateActor(actorSchema types.ProtocolActorSchema, actor types.BaseActor) error {
+	ctx, tx, err := p.GetCtxAndTx()
+	if err != nil {
+		return err
+	}
+
+	height, err := p.GetHeight()
+	if err != nil {
+		return err
+	}
+
+	if _, err = tx.Exec(ctx, actorSchema.UpdateQuery(actor.Address, actor.StakedTokens, actor.ActorSpecificParam, height)); err != nil {
+		return err
+	}
+
+	chainsTableName := actorSchema.GetChainsTableName()
+	if chainsTableName != "" && actor.Chains != nil {
+		if _, err = tx.Exec(ctx, types.NullifyChains(actor.Address, height, chainsTableName)); err != nil {
+			return err
+		}
+		if _, err = tx.Exec(ctx, actorSchema.UpdateChainsQuery(actor.Address, actor.Chains, height)); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (p *PostgresContext) GetActorsReadyToUnstake(actorSchema types.ProtocolActorSchema, height int64) (actors []modules.IUnstakingActor, err error) {
+	ctx, tx, err := p.GetCtxAndTx()
+	if err != nil {
+		return nil, err
+	}
+
+	rows, err := tx.Query(ctx, actorSchema.GetReadyToUnstakeQuery(height))
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		unstakingActor := &types.UnstakingActor{}
+		var addr, output, stakeAmount string
+		if err = rows.Scan(&addr, &stakeAmount, &output); err != nil {
+			return
+		}
+		unstakingActor.SetAddress(addr)
+		unstakingActor.SetStakeAmount(stakeAmount)
+		unstakingActor.SetOutputAddress(output)
+		actors = append(actors, unstakingActor)
+	}
+	return
+}
+
+func (p *PostgresContext) GetActorStatus(actorSchema types.ProtocolActorSchema, address []byte, height int64) (int, error) {
+	var unstakingHeight int64
+	ctx, tx, err := p.GetCtxAndTx()
+	if err != nil {
+		return UndefinedStakingStatus, err
+	}
+
+	if err := tx.QueryRow(ctx, actorSchema.GetUnstakingHeightQuery(hex.EncodeToString(address), height)).Scan(&unstakingHeight); err != nil {
+		return UndefinedStakingStatus, err
+	}
+
+	switch {
+	case unstakingHeight == -1:
+		return StakedStatus, nil
+	case unstakingHeight > height:
+		return UnstakingStatus, nil
+	default:
+		return UnstakedStatus, nil
+	}
+}
+
+func (p *PostgresContext) SetActorUnstakingHeightAndStatus(actorSchema types.ProtocolActorSchema, address []byte, unstakingHeight int64) error {
+	ctx, tx, err := p.GetCtxAndTx()
+	if err != nil {
+		return err
+	}
+
+	height, err := p.GetHeight()
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, actorSchema.UpdateUnstakingHeightQuery(hex.EncodeToString(address), unstakingHeight, height))
+	return err
+}
+
+func (p *PostgresContext) GetActorPauseHeightIfExists(actorSchema types.ProtocolActorSchema, address []byte, height int64) (pausedHeight int64, err error) {
+	ctx, tx, err := p.GetCtxAndTx()
+	if err != nil {
+		return types.DefaultBigInt, err
+	}
+
+	if err := tx.QueryRow(ctx, actorSchema.GetPausedHeightQuery(hex.EncodeToString(address), height)).Scan(&pausedHeight); err != nil {
+		return types.DefaultBigInt, err
+	}
+
+	return pausedHeight, nil
+}
+
+func (p PostgresContext) SetActorStatusAndUnstakingHeightIfPausedBefore(actorSchema types.ProtocolActorSchema, pausedBeforeHeight, unstakingHeight int64) error {
+	ctx, tx, err := p.GetCtxAndTx()
+	if err != nil {
+		return err
+	}
+
+	currentHeight, err := p.GetHeight()
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, actorSchema.UpdateUnstakedHeightIfPausedBeforeQuery(pausedBeforeHeight, unstakingHeight, currentHeight))
+	return err
+}
+
+func (p PostgresContext) SetActorPauseHeight(actorSchema types.ProtocolActorSchema, address []byte, pauseHeight int64) error {
+	ctx, tx, err := p.GetCtxAndTx()
+	if err != nil {
+		return err
+	}
+
+	currentHeight, err := p.GetHeight()
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, actorSchema.UpdatePausedHeightQuery(hex.EncodeToString(address), pauseHeight, currentHeight))
+	return err
+}
+
+func (p PostgresContext) SetActorStakeAmount(actorSchema types.ProtocolActorSchema, address []byte, stakeAmount string) error {
+	ctx, tx, err := p.GetCtxAndTx()
+	if err != nil {
+		return err
+	}
+
+	currentHeight, err := p.GetHeight()
+	if err != nil {
+		return err
+	}
+	_, err = tx.Exec(ctx, actorSchema.SetStakeAmountQuery(hex.EncodeToString(address), stakeAmount, currentHeight))
+	return err
+}
+
+func (p PostgresContext) GetActorOutputAddress(actorSchema types.ProtocolActorSchema, operatorAddr []byte, height int64) ([]byte, error) {
+	ctx, tx, err := p.GetCtxAndTx()
+	if err != nil {
+		return nil, err
+	}
+
+	var outputAddr string
+	if err := tx.QueryRow(ctx, actorSchema.GetOutputAddressQuery(hex.EncodeToString(operatorAddr), height)).Scan(&outputAddr); err != nil {
+		return nil, err
+	}
+
+	return hex.DecodeString(outputAddr)
+}
+
+func (p PostgresContext) GetActorStakeAmount(actorSchema types.ProtocolActorSchema, address []byte, height int64) (string, error) {
+	ctx, tx, err := p.GetCtxAndTx()
+	if err != nil {
+		return "", err
+	}
+
+	var stakeAmount string
+	if err := tx.QueryRow(ctx, actorSchema.GetStakeAmountQuery(hex.EncodeToString(address), height)).Scan(&stakeAmount); err != nil {
+		return "", err
+	}
+	return stakeAmount, nil
+}
diff --git a/utility/block.go b/utility/block.go
index 324ee78a8..6c09cd8cf 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -3,7 +3,7 @@ package utility
 import (
 	"math/big"
 
-	// TODO (andrew) importing consensus and persistence in this file?
+	typesCons "github.com/pokt-network/pocket/consensus/types" // TODO (andrew) importing consensus and persistence in this file?
 	typesGenesis "github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 
@@ -34,8 +34,6 @@ var (
 
 func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) ([]byte, error) {
 	u.LatestHeight = latestHeight
-	u.CurrentProposer = proposerAddress
-
 	// begin block lifecycle phase
 	if err := u.BeginBlock(lastBlockByzantineValidators); err != nil {
 		return nil, err
@@ -53,30 +51,22 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 		if err := u.ApplyTransaction(tx); err != nil {
 			return nil, err
 		}
-		if err := u.Context.PersistenceRWContext.StoreTransaction(transactionProtoBytes); err != nil {
+		if err := u.GetPersistenceContext().StoreTransaction(transactionProtoBytes); err != nil {
 			return nil, err
 		}
 
-		// DISCUSS: What if the context is rolled back or cancelled. Do we add it back to the mempool?
 		// TODO: if found, remove transaction from mempool
+		// DISCUSS: What if the context is rolled back or cancelled. Do we add it back to the mempool?
 		// if err := u.Mempool.DeleteTransaction(transaction); err != nil {
 		// 	return nil, err
 		// }
 	}
-
 	// end block lifecycle phase
 	if err := u.EndBlock(proposerAddress); err != nil {
 		return nil, err
 	}
-
-	// TODO: What if everything above succeeded but updating the app hash failed?
-	appHash, err := u.Context.UpdateAppHash()
-	if err != nil {
-		return nil, typesUtil.ErrAppHash(err)
-	}
-
-	// return the app hash; consensus module will get the validator set directly
-	return appHash, nil
+	// return the app hash (consensus module will get the validator set directly
+	return u.GetAppHash()
 }
 
 func (u *UtilityContext) BeginBlock(previousBlockByzantineValidators [][]byte) typesUtil.Error {
@@ -102,6 +92,15 @@ func (u *UtilityContext) EndBlock(proposer []byte) typesUtil.Error {
 	return nil
 }
 
+func (u *UtilityContext) GetAppHash() ([]byte, typesUtil.Error) {
+	// Get the root hash of the merkle state tree for state consensus integrity
+	appHash, er := u.Context.AppHash()
+	if er != nil {
+		return nil, typesUtil.ErrAppHash(er)
+	}
+	return appHash, nil
+}
+
 // HandleByzantineValidators handles the validators who either didn't sign at all or disagreed with the 2/3+ majority
 func (u *UtilityContext) HandleByzantineValidators(lastBlockByzantineValidators [][]byte) typesUtil.Error {
 	latestBlockHeight, err := u.GetLatestHeight()
@@ -285,3 +284,27 @@ func (u *UtilityContext) SetValidatorMissedBlocks(address []byte, missedBlocks i
 	}
 	return nil
 }
+
+func (u *UtilityContext) StoreBlock(blockProtoBytes []byte) error {
+	store := u.Store()
+
+	// Store in KV Store
+	if err := store.StoreBlock(blockProtoBytes); err != nil {
+		return err
+	}
+
+	// Store in SQL Store
+	// OPTIMIZE: Ideally we'd pass in the block proto struct to utility so we don't
+	//           have to unmarshal it here, but that's a major design decision for the interfaces.
+	codec := u.Codec()
+	block := &typesCons.Block{}
+	if err := codec.Unmarshal(blockProtoBytes, block); err != nil {
+		return typesUtil.ErrProtoUnmarshal(err)
+	}
+	header := block.BlockHeader
+	if err := store.InsertBlock(uint64(header.Height), header.Hash, header.ProposerAddress, header.QuorumCertificate); err != nil {
+		return err
+	}
+
+	return nil
+}
diff --git a/utility/context.go b/utility/context.go
index b0ca4bebc..460b7cfa1 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -2,24 +2,19 @@ package utility
 
 import (
 	"encoding/hex"
-
 	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/modules"
 	typesUtil "github.com/pokt-network/pocket/utility/types"
 )
 
 type UtilityContext struct {
-	LatestHeight    int64 // IMPROVE: Rename to `currentHeight?`
-	CurrentProposer []byte
-
-	Mempool typesUtil.Mempool
-	Context *Context // IMPROVE: Rename to `persistenceContext` or `storeContext` or `reversibleContext`?
+	LatestHeight int64
+	Mempool      typesUtil.Mempool
+	Context      *Context // IMPROVE: Consider renmaming to PersistenceContext
 }
 
-type Context struct { // IMPROVE: Rename to `persistenceContext` or `storeContext`?
-	// TODO: Since `Context` embeds `PersistenceRWContext`, we don't need to do `u.Context.PersistenceRWContext`, but can call `u.Context` directly
+type Context struct {
 	modules.PersistenceRWContext
-	// TODO/DISCUSS: `SavePoints`` have not been implemented yet
 	SavePointsM map[string]struct{}
 	SavePoints  [][]byte
 }
@@ -44,16 +39,17 @@ func (u *UtilityContext) Store() *Context {
 	return u.Context
 }
 
-func (u *UtilityContext) CommitContext(quorumCert []byte) error {
-	err := u.Context.PersistenceRWContext.Commit(u.CurrentProposer, quorumCert)
-	u.Context = nil // DISCUSS: Should we release the context if there was an error here?
-	return err
+func (u *UtilityContext) GetPersistenceContext() modules.PersistenceRWContext {
+	return u.Context.PersistenceRWContext
+}
+
+func (u *UtilityContext) CommitPersistenceContext() error {
+	return u.Context.PersistenceRWContext.Commit()
 }
 
-func (u *UtilityContext) ReleaseContext() error {
-	err := u.Context.Release()
+func (u *UtilityContext) ReleaseContext() {
+	u.Context.Release()
 	u.Context = nil
-	return err
 }
 
 func (u *UtilityContext) GetLatestHeight() (int64, typesUtil.Error) {

From 55df6cf6ed305f4d3d6f55d03e2d4aac5cc113bc Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 26 Sep 2022 20:53:40 -0700
Subject: [PATCH 041/227] Update the interfaces

---
 go.mod                               |  3 +-
 go.sum                               |  2 -
 shared/modules/persistence_module.go | 68 ++--------------------------
 shared/modules/utility_module.go     |  4 +-
 shared/test_artifacts/generator.go   |  5 +-
 5 files changed, 11 insertions(+), 71 deletions(-)

diff --git a/go.mod b/go.mod
index f83ae8336..54191cb69 100644
--- a/go.mod
+++ b/go.mod
@@ -20,7 +20,6 @@ require (
 )
 
 require (
-	github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884
 	github.com/dgraph-io/badger/v3 v3.2103.2
 	github.com/jackc/pgconn v1.11.0
 	github.com/jordanorelli/lexnum v0.0.0-20141216151731-460eeb125754
@@ -38,7 +37,7 @@ require (
 	github.com/docker/go-connections v0.4.0 // indirect
 	github.com/docker/go-units v0.4.0 // indirect
 	github.com/dustin/go-humanize v1.0.0 // indirect
-	github.com/gogo/protobuf v1.3.2
+	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b // indirect
 	github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
diff --git a/go.sum b/go.sum
index 8c2cca931..d064b7f46 100644
--- a/go.sum
+++ b/go.sum
@@ -61,8 +61,6 @@ github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+Ce
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/boombuler/barcode v1.0.0/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8=
-github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884 h1:iRNKw2WmAbVgGMNYzDH5Y2yY3+jyxwEK9Hc5pwIjZAE=
-github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884/go.mod h1:/sdYDakowo/XaxS2Fl7CBqtuf/O2uTqF2zmAUFAtAiw=
 github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4=
 github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index a4a587bb9..3f0e7f841 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -10,16 +10,12 @@ import (
 type PersistenceModule interface {
 	Module
 
-	// Persistence Context Factory Methods
+	// Context interface
 	NewRWContext(height int64) (PersistenceRWContext, error)
 	NewReadContext(height int64) (PersistenceReadContext, error)
+	ReleaseWriteContext() error // Only one write context can exist at a time
 
-	// TODO(drewsky): Make this a context function only and do not expose it at the module level.
-	//                The reason `Olshansky` originally made it a module level function is because
-	//                the module was responsible for maintaining a single write context and assuring
-	//                that a second can't be created (or a previous one is cleaned up) but there is
-	//                likely a better and cleaner approach that simplifies the interface.
-	ResetContext() error
+	// BlockStore interface
 	GetBlockStore() kvstore.KVStore
 
 	// Debugging / development only
@@ -40,20 +36,18 @@ type PersistenceRWContext interface {
 	PersistenceWriteContext
 }
 
+// TODO (andrew) convert address and public key to string not bytes #149
 // TODO: Simplify the interface (reference - https://dave.cheney.net/practical-go/presentations/gophercon-israel.html#_prefer_single_method_interfaces)
 // - Add general purpose methods such as `ActorOperation(enum_actor_type, ...)` which can be use like so: `Insert(FISHERMAN, ...)`
 // - Use general purpose parameter methods such as `Set(enum_gov_type, ...)` such as `Set(STAKING_ADJUSTMENT, ...)`
 
 // NOTE: There's not really a use case for a write only interface,
-// but it abstracts and contrasts nicely against the read only context
-// TODO (andrew) convert address and public key to string not bytes #149
+//       but it abstracts and contrasts nicely against the read only context
 type PersistenceWriteContext interface {
 	// Context Operations
 	NewSavePoint([]byte) error
 	RollbackToSavePoint([]byte) error
 
-	// DISCUSS: Can we consolidate `Reset` and `Release`
-	Reset() error
 	Release() error
 
 	// Block / indexer operations
@@ -67,7 +61,6 @@ type PersistenceWriteContext interface {
 	AddPoolAmount(name string, amount string) error
 	SubtractPoolAmount(name string, amount string) error
 	SetPoolAmount(name string, amount string) error
-
 	InsertPool(name string, address []byte, amount string) error // TODO (Andrew) remove address from pool #149
 
 	// Account Operations
@@ -113,8 +106,6 @@ type PersistenceWriteContext interface {
 	SetValidatorPauseHeightAndMissedBlocks(address []byte, pauseHeight int64, missedBlocks int) error
 	SetValidatorMissedBlocks(address []byte, missedBlocks int) error
 
-	/* TODO(olshansky): review/revisit this in more details */
-
 	// Param Operations
 	InitParams() error
 	SetParam(paramName string, value interface{}) error
@@ -122,29 +113,6 @@ type PersistenceWriteContext interface {
 	// Flag Operations
 	InitFlags() error
 	SetFlag(paramName string, value interface{}, enabled bool) error
-
-	// Tree Operations
-
-	// # Option 1:
-
-	UpdateApplicationsTree([]Actor) error
-	// UpdateValidatorsTree([]Actor) error
-	// UpdateServiceNodesTree([]Actor) error
-	// UpdateFishermanTree([]Actor) error
-	// Update<FutureActors>Tree([]Actor) error
-	// Update<Other>Tree([]Other) error
-
-	// # Option 2:
-	// UpdateActorTree(types.ProtocolActorSchema, []Actor) error
-	// Update<Other>Tree([]Other) error
-
-	// # Option 3:
-	// UpdateApplicationsTree([]Application) error
-	// UpdateValidatorsTree([]Validator) error
-	// UpdateServiceNodesTree([]ServiceNode) error
-	// UpdateFishermanTree([]Fisherman) error
-	// Update<FutureActors>Tree([]FutureActor) error
-	// Update<Other>Tree([]Other) error
 }
 
 type PersistenceReadContext interface {
@@ -212,8 +180,6 @@ type PersistenceReadContext interface {
 	GetValidatorOutputAddress(operator []byte, height int64) (output []byte, err error)
 	GetValidatorMissedBlocks(address []byte, height int64) (int, error)
 
-	/* TODO(olshansky): review/revisit this in more details */
-
 	// Params
 	GetIntParam(paramName string, height int64) (int, error)
 	GetStringParam(paramName string, height int64) (string, error)
@@ -223,28 +189,4 @@ type PersistenceReadContext interface {
 	GetIntFlag(paramName string, height int64) (int, bool, error)
 	GetStringFlag(paramName string, height int64) (string, bool, error)
 	GetBytesFlag(paramName string, height int64) ([]byte, bool, error)
-
-	// Tree Operations
-
-	// # Option 1:
-
-	// GetApplicationsUpdatedAtHeight(height int64) ([]Actor, error)
-	// GetValidatorsUpdatedAtHeight(height int64) ([]Actor, error)
-	// GetServiceNodesUpdatedAtHeight(height int64) ([]Actor, error)
-	// GetFishermanUpdatedAtHeight(height int64) ([]Actor, error)
-	// Get<FutureActor>UpdatedAtHeight(height int64) ([]Actor, error)
-	// Get<Other>UpdatedAtHeight(height int64) ([]Actor, error)
-	// Update<Other>Tree(height int64) ([]Actor, error)
-
-	// # Option 2:
-	// Get<FutureActor>UpdatedAtHeight(types.ProtocolActorSchema, height int64) ([]Actor, error)
-	// Get<Other>UpdatedAtHeight(height int64) ([]Other, error)
-
-	// # Option 3:
-	// GetApplicationsUpdatedAtHeight(height int64) ([]Application, error)
-	// GetValidatorsUpdatedAtHeight(height int64) ([]Validator, error)
-	// GetServiceNodesUpdatedAtHeight(height int64) ([]ServiceNode, error)
-	// GetFishermanUpdatedAtHeight(height int64) ([]Fisherman, error)
-	// Get<FutureActor>UpdatedAtHeight(height int64) ([]FutureActor, error)
-	// Get<Other>UpdatedAtHeight(height int64) ([]Other, error)
 }
diff --git a/shared/modules/utility_module.go b/shared/modules/utility_module.go
index 5dbf9f887..37729fba1 100644
--- a/shared/modules/utility_module.go
+++ b/shared/modules/utility_module.go
@@ -21,8 +21,8 @@ type UtilityContext interface {
 	ApplyBlock(height int64, proposer []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) (appHash []byte, err error)
 
 	// Context operations
-	ReleaseContext() error
-	CommitContext(quorumCert []byte) error
+	Release() error
+	Commit(quorumCert []byte) error
 
 	// Validation operations
 	CheckTransaction(tx []byte) error
diff --git a/shared/test_artifacts/generator.go b/shared/test_artifacts/generator.go
index 912e9fe2b..f89c68188 100644
--- a/shared/test_artifacts/generator.go
+++ b/shared/test_artifacts/generator.go
@@ -2,11 +2,12 @@ package test_artifacts
 
 import (
 	"fmt"
+	"math/big"
+	"strconv"
+
 	typesPersistence "github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 	"github.com/pokt-network/pocket/utility/types"
-	"math/big"
-	"strconv"
 
 	"github.com/pokt-network/pocket/shared/crypto"
 	"google.golang.org/protobuf/types/known/timestamppb"

From 637092221f397b2178f79298a85a77abbdbe8823 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 28 Sep 2022 14:52:04 -0700
Subject: [PATCH 042/227] Added shouldElectNextLeader

---
 consensus/hotstuff_handler.go | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/consensus/hotstuff_handler.go b/consensus/hotstuff_handler.go
index 90b7b3b29..b27e65ba1 100644
--- a/consensus/hotstuff_handler.go
+++ b/consensus/hotstuff_handler.go
@@ -29,8 +29,7 @@ func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage)
 		return err
 	}
 
-	// Leader Election - Need to execute leader election if there is no leader and we are in a new round.
-	if m.Step == NewRound && m.LeaderId == nil {
+	if m.shouldElectNextLeader() {
 		if err := m.electNextLeader(msg); err != nil {
 			return err
 		}
@@ -45,3 +44,8 @@ func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage)
 
 	return nil
 }
+
+func (m *ConsensusModule) shouldElectNextLeader() bool {
+	// Execute leader election if there is no leader and we are in a new round
+	return m.Step == NewRound && m.LeaderId == nil
+}

From 05e011884b757532a8ab492aa997b9deef4580d5 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 28 Sep 2022 17:38:39 -0700
Subject: [PATCH 043/227] Added a comment for getSignableBytes

---
 consensus/messages.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/consensus/messages.go b/consensus/messages.go
index 66fb8d836..7ff8355c8 100644
--- a/consensus/messages.go
+++ b/consensus/messages.go
@@ -89,6 +89,8 @@ func getMessageSignature(msg *typesCons.HotstuffMessage, privKey crypto.PrivateK
 }
 
 // Signature only over subset of fields in HotstuffMessage
+// For reference, see section 4.3 of the the hotstuff whitepaper, partial signatures are
+// computed over `tsignr(hm.type, m.viewNumber , m.nodei)`. https://arxiv.org/pdf/1803.05069.pdf
 func getSignableBytes(msg *typesCons.HotstuffMessage) ([]byte, error) {
 	msgToSign := &typesCons.HotstuffMessage{
 		Height: msg.GetHeight(),

From 45da8225beeb731fd4dec084d0d7d94cfe249110 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 28 Sep 2022 17:41:59 -0700
Subject: [PATCH 044/227] Check for nil in CreateProposeMessage

---
 consensus/messages.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/consensus/messages.go b/consensus/messages.go
index 7ff8355c8..b2a06013e 100644
--- a/consensus/messages.go
+++ b/consensus/messages.go
@@ -15,6 +15,10 @@ func CreateProposeMessage(
 	block *typesCons.Block,
 	qc *typesCons.QuorumCertificate,
 ) (*typesCons.HotstuffMessage, error) {
+	if block == nil {
+		return nil, typesCons.ErrNilBlockVote
+	}
+
 	msg := &typesCons.HotstuffMessage{
 		Type:          Propose,
 		Height:        height,

From 2410521eb059a70a702fe2cabfd2fc3e97d587d3 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 28 Sep 2022 17:44:02 -0700
Subject: [PATCH 045/227] Revert order of pacemaker defer and telemetry event
 emitting

---
 consensus/hotstuff_leader.go  | 10 +++++-----
 consensus/hotstuff_replica.go | 10 +++++-----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 4aba0298b..2b7642bc4 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -24,8 +24,8 @@ var (
 /*** Prepare Step ***/
 
 func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	handler.emitTelemetryEvent(m, msg)
 	defer m.paceMaker.RestartTimer()
+	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
@@ -93,8 +93,8 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusM
 /*** PreCommit Step ***/
 
 func (handler *HotstuffLeaderMessageHandler) HandlePrepareMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	handler.emitTelemetryEvent(m, msg)
 	defer m.paceMaker.RestartTimer()
+	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
@@ -137,8 +137,8 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrepareMessage(m *ConsensusMo
 /*** Commit Step ***/
 
 func (handler *HotstuffLeaderMessageHandler) HandlePrecommitMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	handler.emitTelemetryEvent(m, msg)
 	defer m.paceMaker.RestartTimer()
+	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
@@ -181,8 +181,8 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrecommitMessage(m *Consensus
 /*** Decide Step ***/
 
 func (handler *HotstuffLeaderMessageHandler) HandleCommitMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	handler.emitTelemetryEvent(m, msg)
 	defer m.paceMaker.RestartTimer()
+	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
@@ -230,8 +230,8 @@ func (handler *HotstuffLeaderMessageHandler) HandleCommitMessage(m *ConsensusMod
 }
 
 func (handler *HotstuffLeaderMessageHandler) HandleDecideMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	handler.emitTelemetryEvent(m, msg)
 	defer m.paceMaker.RestartTimer()
+	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
diff --git a/consensus/hotstuff_replica.go b/consensus/hotstuff_replica.go
index a4eda9951..0cc440389 100644
--- a/consensus/hotstuff_replica.go
+++ b/consensus/hotstuff_replica.go
@@ -24,8 +24,8 @@ var (
 /*** NewRound Step ***/
 
 func (handler *HotstuffReplicaMessageHandler) HandleNewRoundMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	handler.emitTelemetryEvent(m, msg)
 	defer m.paceMaker.RestartTimer()
+	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
@@ -43,8 +43,8 @@ func (handler *HotstuffReplicaMessageHandler) HandleNewRoundMessage(m *Consensus
 /*** Prepare Step ***/
 
 func (handler *HotstuffReplicaMessageHandler) HandlePrepareMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	handler.emitTelemetryEvent(m, msg)
 	defer m.paceMaker.RestartTimer()
+	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
@@ -78,8 +78,8 @@ func (handler *HotstuffReplicaMessageHandler) HandlePrepareMessage(m *ConsensusM
 /*** PreCommit Step ***/
 
 func (handler *HotstuffReplicaMessageHandler) HandlePrecommitMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	handler.emitTelemetryEvent(m, msg)
 	defer m.paceMaker.RestartTimer()
+	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
@@ -107,8 +107,8 @@ func (handler *HotstuffReplicaMessageHandler) HandlePrecommitMessage(m *Consensu
 /*** Commit Step ***/
 
 func (handler *HotstuffReplicaMessageHandler) HandleCommitMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	handler.emitTelemetryEvent(m, msg)
 	defer m.paceMaker.RestartTimer()
+	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
@@ -136,8 +136,8 @@ func (handler *HotstuffReplicaMessageHandler) HandleCommitMessage(m *ConsensusMo
 /*** Decide Step ***/
 
 func (handler *HotstuffReplicaMessageHandler) HandleDecideMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	handler.emitTelemetryEvent(m, msg)
 	defer m.paceMaker.RestartTimer()
+	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)

From a478516c7ef643989679b527cf1ca240e53596a0 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 28 Sep 2022 17:47:30 -0700
Subject: [PATCH 046/227] s/IdToValAddrMap/idToValAddrMap

---
 consensus/helpers.go | 6 +++---
 consensus/module.go  | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/consensus/helpers.go b/consensus/helpers.go
index d089d0338..fb4a57c1d 100644
--- a/consensus/helpers.go
+++ b/consensus/helpers.go
@@ -146,7 +146,7 @@ func (m *ConsensusModule) sendToNode(msg *typesCons.HotstuffMessage) {
 		m.nodeLogError(typesCons.ErrCreateConsensusMessage.Error(), err)
 		return
 	}
-	if err := m.GetBus().GetP2PModule().Send(cryptoPocket.AddressFromString(m.IdToValAddrMap[*m.LeaderId]), anyConsensusMessage, debug.PocketTopic_CONSENSUS_MESSAGE_TOPIC); err != nil {
+	if err := m.GetBus().GetP2PModule().Send(cryptoPocket.AddressFromString(m.idToValAddrMap[*m.LeaderId]), anyConsensusMessage, debug.PocketTopic_CONSENSUS_MESSAGE_TOPIC); err != nil {
 		m.nodeLogError(typesCons.ErrSendMessage.Error(), err)
 		return
 	}
@@ -201,10 +201,10 @@ func (m *ConsensusModule) electNextLeader(message *typesCons.HotstuffMessage) er
 
 	if m.LeaderId != nil && *m.LeaderId == m.NodeId {
 		m.logPrefix = "LEADER"
-		m.nodeLog(typesCons.ElectedSelfAsNewLeader(m.IdToValAddrMap[*m.LeaderId], *m.LeaderId, m.Height, m.Round))
+		m.nodeLog(typesCons.ElectedSelfAsNewLeader(m.idToValAddrMap[*m.LeaderId], *m.LeaderId, m.Height, m.Round))
 	} else {
 		m.logPrefix = "REPLICA"
-		m.nodeLog(typesCons.ElectedNewLeader(m.IdToValAddrMap[*m.LeaderId], *m.LeaderId, m.Height, m.Round))
+		m.nodeLog(typesCons.ElectedNewLeader(m.idToValAddrMap[*m.LeaderId], *m.LeaderId, m.Height, m.Round))
 	}
 
 	return nil
diff --git a/consensus/module.go b/consensus/module.go
index 4c8e7d94f..6ec334946 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -48,7 +48,7 @@ type ConsensusModule struct {
 	LeaderId       *typesCons.NodeId
 	NodeId         typesCons.NodeId
 	ValAddrToIdMap typesCons.ValAddrToIdMap // TODO: This needs to be updated every time the ValMap is modified
-	IdToValAddrMap typesCons.IdToValAddrMap // TODO: This needs to be updated every time the ValMap is modified
+	idToValAddrMap typesCons.IdToValAddrMap // TODO: This needs to be updated every time the ValMap is modified
 
 	// Consensus State
 	lastAppHash  string // TODO: Always retrieve this variable from the persistence module and simplify this struct
@@ -120,7 +120,7 @@ func Create(configPath, genesisPath string, useRandomPK bool) (modules.Consensus
 		NodeId:         valIdMap[address],
 		LeaderId:       nil,
 		ValAddrToIdMap: valIdMap,
-		IdToValAddrMap: idValMap,
+		idToValAddrMap: idValMap,
 
 		lastAppHash:  "",
 		validatorMap: valMap,

From 8faaf21d575304f6785060c7c748dfc00b81cc2b Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 28 Sep 2022 17:47:44 -0700
Subject: [PATCH 047/227] s/ValAddrToIdMap/valAddrToIdMap

---
 consensus/hotstuff_leader.go  | 4 ++--
 consensus/hotstuff_replica.go | 4 ++--
 consensus/module.go           | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 2b7642bc4..8e948d5d8 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -293,7 +293,7 @@ func (m *ConsensusModule) validatePartialSignature(msg *typesCons.HotstuffMessag
 	address := partialSig.GetAddress()
 	validator, ok := m.validatorMap[address]
 	if !ok {
-		return typesCons.ErrMissingValidator(address, m.ValAddrToIdMap[address])
+		return typesCons.ErrMissingValidator(address, m.valAddrToIdMap[address])
 	}
 	pubKey := validator.GetPublicKey()
 	if isSignatureValid(msg, pubKey, partialSig.GetSignature()) {
@@ -301,7 +301,7 @@ func (m *ConsensusModule) validatePartialSignature(msg *typesCons.HotstuffMessag
 	}
 
 	return typesCons.ErrValidatingPartialSig(
-		address, m.ValAddrToIdMap[address], msg, pubKey)
+		address, m.valAddrToIdMap[address], msg, pubKey)
 }
 
 // TODO: This is just a placeholder at the moment for indexing hotstuff messages ONLY.
diff --git a/consensus/hotstuff_replica.go b/consensus/hotstuff_replica.go
index 0cc440389..4fb925bff 100644
--- a/consensus/hotstuff_replica.go
+++ b/consensus/hotstuff_replica.go
@@ -262,13 +262,13 @@ func (m *ConsensusModule) validateQuorumCertificate(qc *typesCons.QuorumCertific
 	for _, partialSig := range qc.ThresholdSignature.Signatures {
 		validator, ok := m.validatorMap[partialSig.Address]
 		if !ok {
-			m.nodeLogError(typesCons.ErrMissingValidator(partialSig.Address, m.ValAddrToIdMap[partialSig.Address]).Error(), nil)
+			m.nodeLogError(typesCons.ErrMissingValidator(partialSig.Address, m.valAddrToIdMap[partialSig.Address]).Error(), nil)
 			continue
 		}
 		// TODO(olshansky): Every call to `IsSignatureValid` does a serialization and should be optimized. We can
 		// just serialize `Message` once and verify each signature without re-serializing every time.
 		if !isSignatureValid(msgToJustify, validator.GetPublicKey(), partialSig.Signature) {
-			m.nodeLog(typesCons.WarnInvalidPartialSigInQC(partialSig.Address, m.ValAddrToIdMap[partialSig.Address]))
+			m.nodeLog(typesCons.WarnInvalidPartialSigInQC(partialSig.Address, m.valAddrToIdMap[partialSig.Address]))
 			continue
 		}
 		numValid++
diff --git a/consensus/module.go b/consensus/module.go
index 6ec334946..195568c79 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -47,7 +47,7 @@ type ConsensusModule struct {
 	// Leader Election
 	LeaderId       *typesCons.NodeId
 	NodeId         typesCons.NodeId
-	ValAddrToIdMap typesCons.ValAddrToIdMap // TODO: This needs to be updated every time the ValMap is modified
+	valAddrToIdMap typesCons.ValAddrToIdMap // TODO: This needs to be updated every time the ValMap is modified
 	idToValAddrMap typesCons.IdToValAddrMap // TODO: This needs to be updated every time the ValMap is modified
 
 	// Consensus State
@@ -119,7 +119,7 @@ func Create(configPath, genesisPath string, useRandomPK bool) (modules.Consensus
 
 		NodeId:         valIdMap[address],
 		LeaderId:       nil,
-		ValAddrToIdMap: valIdMap,
+		valAddrToIdMap: valIdMap,
 		idToValAddrMap: idValMap,
 
 		lastAppHash:  "",

From 25971b773c63b2504362abcb6ce4f542f3a46c3e Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 28 Sep 2022 17:48:16 -0700
Subject: [PATCH 048/227] s/NodeId/nodeId

---
 consensus/debugging.go | 2 +-
 consensus/helpers.go   | 8 ++++----
 consensus/module.go    | 4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/consensus/debugging.go b/consensus/debugging.go
index 0419575ba..319d1848b 100644
--- a/consensus/debugging.go
+++ b/consensus/debugging.go
@@ -31,7 +31,7 @@ func (m *ConsensusModule) GetNodeState() typesCons.ConsensusNodeState {
 		leaderId = *m.LeaderId
 	}
 	return typesCons.ConsensusNodeState{
-		NodeId:   m.NodeId,
+		NodeId:   m.nodeId,
 		Height:   m.Height,
 		Round:    uint8(m.Round),
 		Step:     uint8(m.Step),
diff --git a/consensus/helpers.go b/consensus/helpers.go
index fb4a57c1d..fd99734df 100644
--- a/consensus/helpers.go
+++ b/consensus/helpers.go
@@ -177,7 +177,7 @@ func (m *ConsensusModule) clearMessagesPool() {
 /*** Leader Election Helpers ***/
 
 func (m *ConsensusModule) isLeader() bool {
-	return m.LeaderId != nil && *m.LeaderId == m.NodeId
+	return m.LeaderId != nil && *m.LeaderId == m.nodeId
 }
 
 func (m *ConsensusModule) isReplica() bool {
@@ -199,7 +199,7 @@ func (m *ConsensusModule) electNextLeader(message *typesCons.HotstuffMessage) er
 
 	m.LeaderId = &leaderId
 
-	if m.LeaderId != nil && *m.LeaderId == m.NodeId {
+	if m.LeaderId != nil && *m.LeaderId == m.nodeId {
 		m.logPrefix = "LEADER"
 		m.nodeLog(typesCons.ElectedSelfAsNewLeader(m.idToValAddrMap[*m.LeaderId], *m.LeaderId, m.Height, m.Round))
 	} else {
@@ -214,10 +214,10 @@ func (m *ConsensusModule) electNextLeader(message *typesCons.HotstuffMessage) er
 
 // TODO(#164): Remove this once we have a proper logging system.
 func (m *ConsensusModule) nodeLog(s string) {
-	log.Printf("[%s][%d] %s\n", m.logPrefix, m.NodeId, s)
+	log.Printf("[%s][%d] %s\n", m.logPrefix, m.nodeId, s)
 }
 
 // TODO(#164): Remove this once we have a proper logging system.
 func (m *ConsensusModule) nodeLogError(s string, err error) {
-	log.Printf("[ERROR][%s][%d] %s: %v\n", m.logPrefix, m.NodeId, s, err)
+	log.Printf("[ERROR][%s][%d] %s: %v\n", m.logPrefix, m.nodeId, s, err)
 }
diff --git a/consensus/module.go b/consensus/module.go
index 195568c79..ea17e5484 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -46,7 +46,7 @@ type ConsensusModule struct {
 
 	// Leader Election
 	LeaderId       *typesCons.NodeId
-	NodeId         typesCons.NodeId
+	nodeId         typesCons.NodeId
 	valAddrToIdMap typesCons.ValAddrToIdMap // TODO: This needs to be updated every time the ValMap is modified
 	idToValAddrMap typesCons.IdToValAddrMap // TODO: This needs to be updated every time the ValMap is modified
 
@@ -117,7 +117,7 @@ func Create(configPath, genesisPath string, useRandomPK bool) (modules.Consensus
 		HighPrepareQC: nil,
 		LockedQC:      nil,
 
-		NodeId:         valIdMap[address],
+		nodeId:         valIdMap[address],
 		LeaderId:       nil,
 		valAddrToIdMap: valIdMap,
 		idToValAddrMap: idValMap,

From 472473ce17d78e238cfb098028ae4c8fb511a50b Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 28 Sep 2022 17:48:28 -0700
Subject: [PATCH 049/227] s/LeaderId/leaderId

---
 consensus/debugging.go        |  4 ++--
 consensus/helpers.go          | 18 +++++++++---------
 consensus/hotstuff_handler.go |  4 ++--
 consensus/module.go           |  4 ++--
 consensus/pacemaker.go        |  2 +-
 5 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/consensus/debugging.go b/consensus/debugging.go
index 319d1848b..94f09bf18 100644
--- a/consensus/debugging.go
+++ b/consensus/debugging.go
@@ -27,8 +27,8 @@ func (m *ConsensusModule) HandleDebugMessage(debugMessage *debug.DebugMessage) e
 
 func (m *ConsensusModule) GetNodeState() typesCons.ConsensusNodeState {
 	leaderId := typesCons.NodeId(0)
-	if m.LeaderId != nil {
-		leaderId = *m.LeaderId
+	if m.leaderId != nil {
+		leaderId = *m.leaderId
 	}
 	return typesCons.ConsensusNodeState{
 		NodeId:   m.nodeId,
diff --git a/consensus/helpers.go b/consensus/helpers.go
index fd99734df..b1d2a6569 100644
--- a/consensus/helpers.go
+++ b/consensus/helpers.go
@@ -135,18 +135,18 @@ func protoHash(m proto.Message) string {
 
 func (m *ConsensusModule) sendToNode(msg *typesCons.HotstuffMessage) {
 	// TODO(olshansky): This can happen due to a race condition with the pacemaker.
-	if m.LeaderId == nil {
+	if m.leaderId == nil {
 		m.nodeLogError(typesCons.ErrNilLeaderId.Error(), nil)
 		return
 	}
 
-	m.nodeLog(typesCons.SendingMessage(msg, *m.LeaderId))
+	m.nodeLog(typesCons.SendingMessage(msg, *m.leaderId))
 	anyConsensusMessage, err := codec.GetCodec().ToAny(msg)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateConsensusMessage.Error(), err)
 		return
 	}
-	if err := m.GetBus().GetP2PModule().Send(cryptoPocket.AddressFromString(m.idToValAddrMap[*m.LeaderId]), anyConsensusMessage, debug.PocketTopic_CONSENSUS_MESSAGE_TOPIC); err != nil {
+	if err := m.GetBus().GetP2PModule().Send(cryptoPocket.AddressFromString(m.idToValAddrMap[*m.leaderId]), anyConsensusMessage, debug.PocketTopic_CONSENSUS_MESSAGE_TOPIC); err != nil {
 		m.nodeLogError(typesCons.ErrSendMessage.Error(), err)
 		return
 	}
@@ -177,7 +177,7 @@ func (m *ConsensusModule) clearMessagesPool() {
 /*** Leader Election Helpers ***/
 
 func (m *ConsensusModule) isLeader() bool {
-	return m.LeaderId != nil && *m.LeaderId == m.nodeId
+	return m.leaderId != nil && *m.leaderId == m.nodeId
 }
 
 func (m *ConsensusModule) isReplica() bool {
@@ -186,7 +186,7 @@ func (m *ConsensusModule) isReplica() bool {
 
 func (m *ConsensusModule) clearLeader() {
 	m.logPrefix = DefaultLogPrefix
-	m.LeaderId = nil
+	m.leaderId = nil
 }
 
 func (m *ConsensusModule) electNextLeader(message *typesCons.HotstuffMessage) error {
@@ -197,14 +197,14 @@ func (m *ConsensusModule) electNextLeader(message *typesCons.HotstuffMessage) er
 		return err
 	}
 
-	m.LeaderId = &leaderId
+	m.leaderId = &leaderId
 
-	if m.LeaderId != nil && *m.LeaderId == m.nodeId {
+	if m.leaderId != nil && *m.leaderId == m.nodeId {
 		m.logPrefix = "LEADER"
-		m.nodeLog(typesCons.ElectedSelfAsNewLeader(m.idToValAddrMap[*m.LeaderId], *m.LeaderId, m.Height, m.Round))
+		m.nodeLog(typesCons.ElectedSelfAsNewLeader(m.idToValAddrMap[*m.leaderId], *m.leaderId, m.Height, m.Round))
 	} else {
 		m.logPrefix = "REPLICA"
-		m.nodeLog(typesCons.ElectedNewLeader(m.idToValAddrMap[*m.LeaderId], *m.LeaderId, m.Height, m.Round))
+		m.nodeLog(typesCons.ElectedNewLeader(m.idToValAddrMap[*m.leaderId], *m.leaderId, m.Height, m.Round))
 	}
 
 	return nil
diff --git a/consensus/hotstuff_handler.go b/consensus/hotstuff_handler.go
index b27e65ba1..6624917ed 100644
--- a/consensus/hotstuff_handler.go
+++ b/consensus/hotstuff_handler.go
@@ -23,7 +23,7 @@ func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage)
 		// If a replica is not a leader for this round, but has already determined a leader,
 		// and continues to receive NewRound messages, we avoid logging the "message discard"
 		// because it creates unnecessary spam.
-		if !(m.LeaderId != nil && !m.isLeader() && step == NewRound) {
+		if !(m.leaderId != nil && !m.isLeader() && step == NewRound) {
 			m.nodeLog(typesCons.WarnDiscardHotstuffMessage(msg, err.Error()))
 		}
 		return err
@@ -47,5 +47,5 @@ func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage)
 
 func (m *ConsensusModule) shouldElectNextLeader() bool {
 	// Execute leader election if there is no leader and we are in a new round
-	return m.Step == NewRound && m.LeaderId == nil
+	return m.Step == NewRound && m.leaderId == nil
 }
diff --git a/consensus/module.go b/consensus/module.go
index ea17e5484..3b9bdbfa4 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -45,7 +45,7 @@ type ConsensusModule struct {
 	LockedQC      *typesCons.QuorumCertificate // Highest QC for which replica voted COMMIT
 
 	// Leader Election
-	LeaderId       *typesCons.NodeId
+	leaderId       *typesCons.NodeId
 	nodeId         typesCons.NodeId
 	valAddrToIdMap typesCons.ValAddrToIdMap // TODO: This needs to be updated every time the ValMap is modified
 	idToValAddrMap typesCons.IdToValAddrMap // TODO: This needs to be updated every time the ValMap is modified
@@ -118,7 +118,7 @@ func Create(configPath, genesisPath string, useRandomPK bool) (modules.Consensus
 		LockedQC:      nil,
 
 		nodeId:         valIdMap[address],
-		LeaderId:       nil,
+		leaderId:       nil,
 		valAddrToIdMap: valIdMap,
 		idToValAddrMap: idValMap,
 
diff --git a/consensus/pacemaker.go b/consensus/pacemaker.go
index c2655e315..0b9e5ae17 100644
--- a/consensus/pacemaker.go
+++ b/consensus/pacemaker.go
@@ -140,7 +140,7 @@ func (p *paceMaker) ValidateMessage(m *typesCons.HotstuffMessage) error {
 
 		// TODO(olshansky): Add tests for this. When we catch up to a later step, the leader is still the same.
 		// However, when we catch up to a later round, the leader at the same height will be different.
-		if p.consensusMod.Round != m.Round || p.consensusMod.LeaderId == nil {
+		if p.consensusMod.Round != m.Round || p.consensusMod.leaderId == nil {
 			p.consensusMod.electNextLeader(m)
 		}
 

From a5edce54132141bf6147fa6cea29591321cd95ec Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 28 Sep 2022 17:48:45 -0700
Subject: [PATCH 050/227] s/MessagePool/messagePool

---
 consensus/helpers.go         |  6 +++---
 consensus/hotstuff_leader.go | 14 +++++++-------
 consensus/module.go          |  4 ++--
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/consensus/helpers.go b/consensus/helpers.go
index b1d2a6569..8ca304851 100644
--- a/consensus/helpers.go
+++ b/consensus/helpers.go
@@ -42,7 +42,7 @@ var (
 // TODO: Add unit tests for quorumCert creation & validation.
 func (m *ConsensusModule) getQuorumCertificate(height uint64, step typesCons.HotstuffStep, round uint64) (*typesCons.QuorumCertificate, error) {
 	var pss []*typesCons.PartialSignature
-	for _, msg := range m.MessagePool[step] {
+	for _, msg := range m.messagePool[step] {
 		if msg.GetPartialSignature() == nil {
 			m.nodeLog(typesCons.WarnMissingPartialSig(msg))
 			continue
@@ -112,7 +112,7 @@ func isSignatureValid(msg *typesCons.HotstuffMessage, pubKeyString string, signa
 }
 
 func (m *ConsensusModule) didReceiveEnoughMessageForStep(step typesCons.HotstuffStep) error {
-	return m.isOptimisticThresholdMet(len(m.MessagePool[step]))
+	return m.isOptimisticThresholdMet(len(m.messagePool[step]))
 }
 
 func (m *ConsensusModule) isOptimisticThresholdMet(n int) error {
@@ -170,7 +170,7 @@ func (m *ConsensusModule) broadcastToNodes(msg *typesCons.HotstuffMessage) {
 // TECHDEBT: Integrate this with the `persistence` module or a real mempool.
 func (m *ConsensusModule) clearMessagesPool() {
 	for _, step := range HotstuffSteps {
-		m.MessagePool[step] = make([]*typesCons.HotstuffMessage, 0)
+		m.messagePool[step] = make([]*typesCons.HotstuffMessage, 0)
 	}
 }
 
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 8e948d5d8..9000e4135 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -47,7 +47,7 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusM
 
 	// Likely to be `nil` if blockchain is progressing well.
 	// TECHDEBT: How do we properly validate `highPrepareQC` here?
-	highPrepareQC := m.findHighQC(m.MessagePool[NewRound])
+	highPrepareQC := m.findHighQC(m.messagePool[NewRound])
 
 	// TODO: Add more unit tests for these checks...
 	if highPrepareQC == nil || highPrepareQC.Height < m.Height || highPrepareQC.Round < m.Round {
@@ -71,7 +71,7 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusM
 	}
 
 	m.Step = Prepare
-	m.MessagePool[NewRound] = nil
+	m.messagePool[NewRound] = nil
 
 	prepareProposeMessage, err := CreateProposeMessage(m.Height, m.Round, Prepare, m.Block, highPrepareQC)
 	if err != nil {
@@ -115,7 +115,7 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrepareMessage(m *ConsensusMo
 
 	m.Step = PreCommit
 	m.HighPrepareQC = prepareQC
-	m.MessagePool[Prepare] = nil
+	m.messagePool[Prepare] = nil
 
 	preCommitProposeMessage, err := CreateProposeMessage(m.Height, m.Round, PreCommit, m.Block, prepareQC)
 	if err != nil {
@@ -159,7 +159,7 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrecommitMessage(m *Consensus
 
 	m.Step = Commit
 	m.LockedQC = preCommitQC
-	m.MessagePool[PreCommit] = nil
+	m.messagePool[PreCommit] = nil
 
 	commitProposeMessage, err := CreateProposeMessage(m.Height, m.Round, Commit, m.Block, preCommitQC)
 	if err != nil {
@@ -202,7 +202,7 @@ func (handler *HotstuffLeaderMessageHandler) HandleCommitMessage(m *ConsensusMod
 	}
 
 	m.Step = Decide
-	m.MessagePool[Commit] = nil
+	m.messagePool[Commit] = nil
 
 	decideProposeMessage, err := CreateProposeMessage(m.Height, m.Round, Decide, m.Block, commitQC)
 	if err != nil {
@@ -309,14 +309,14 @@ func (m *ConsensusModule) validatePartialSignature(msg *typesCons.HotstuffMessag
 //       and does not recursively determine the size of all the underlying elements
 //       Add proper tests and implementation once the mempool is implemented.
 func (m *ConsensusModule) tempIndexHotstuffMessage(msg *typesCons.HotstuffMessage) {
-	if m.consCfg.GetMaxMempoolBytes() < uint64(unsafe.Sizeof(m.MessagePool)) {
+	if m.consCfg.GetMaxMempoolBytes() < uint64(unsafe.Sizeof(m.messagePool)) {
 		m.nodeLogError(typesCons.DisregardHotstuffMessage, typesCons.ErrConsensusMempoolFull)
 		return
 	}
 
 	// Only the leader needs to aggregate consensus related messages.
 	step := msg.GetStep()
-	m.MessagePool[step] = append(m.MessagePool[step], msg)
+	m.messagePool[step] = append(m.messagePool[step], msg)
 }
 
 // This is a helper function intended to be called by a leader/validator during a view change
diff --git a/consensus/module.go b/consensus/module.go
index 3b9bdbfa4..62cfa3d86 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -63,7 +63,7 @@ type ConsensusModule struct {
 	logPrefix string
 
 	// TECHDEBT: Move this over to use the txIndexer
-	MessagePool map[typesCons.HotstuffStep][]*typesCons.HotstuffMessage
+	messagePool map[typesCons.HotstuffStep][]*typesCons.HotstuffMessage
 }
 
 func Create(configPath, genesisPath string, useRandomPK bool) (modules.ConsensusModule, error) {
@@ -130,7 +130,7 @@ func Create(configPath, genesisPath string, useRandomPK bool) (modules.Consensus
 		leaderElectionMod: leaderElectionMod,
 
 		logPrefix:   DefaultLogPrefix,
-		MessagePool: make(map[typesCons.HotstuffStep][]*typesCons.HotstuffMessage),
+		messagePool: make(map[typesCons.HotstuffStep][]*typesCons.HotstuffMessage),
 	}
 
 	// TODO(olshansky): Look for a way to avoid doing this.

From 28f1ba011f46dd957cd4ce45047c5909d6669b52 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 28 Sep 2022 17:51:06 -0700
Subject: [PATCH 051/227] Only a few remaining exported fields in
 ConsensusModule based on reflections

---
 consensus/debugging.go        |  8 ++++----
 consensus/helpers.go          | 18 +++++++++---------
 consensus/hotstuff_handler.go |  4 ++--
 consensus/hotstuff_leader.go  |  4 ++--
 consensus/hotstuff_replica.go |  6 +++---
 consensus/module.go           | 12 ++++++------
 consensus/pacemaker.go        |  8 ++++----
 7 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/consensus/debugging.go b/consensus/debugging.go
index 94f09bf18..e233af946 100644
--- a/consensus/debugging.go
+++ b/consensus/debugging.go
@@ -27,8 +27,8 @@ func (m *ConsensusModule) HandleDebugMessage(debugMessage *debug.DebugMessage) e
 
 func (m *ConsensusModule) GetNodeState() typesCons.ConsensusNodeState {
 	leaderId := typesCons.NodeId(0)
-	if m.leaderId != nil {
-		leaderId = *m.leaderId
+	if m.LeaderId != nil {
+		leaderId = *m.LeaderId
 	}
 	return typesCons.ConsensusNodeState{
 		NodeId:   m.nodeId,
@@ -48,8 +48,8 @@ func (m *ConsensusModule) resetToGenesis(_ *debug.DebugMessage) {
 	m.Step = 0
 	m.Block = nil
 
-	m.HighPrepareQC = nil
-	m.LockedQC = nil
+	m.highPrepareQC = nil
+	m.lockedQC = nil
 
 	m.clearLeader()
 	m.clearMessagesPool()
diff --git a/consensus/helpers.go b/consensus/helpers.go
index 8ca304851..a81c60205 100644
--- a/consensus/helpers.go
+++ b/consensus/helpers.go
@@ -135,18 +135,18 @@ func protoHash(m proto.Message) string {
 
 func (m *ConsensusModule) sendToNode(msg *typesCons.HotstuffMessage) {
 	// TODO(olshansky): This can happen due to a race condition with the pacemaker.
-	if m.leaderId == nil {
+	if m.LeaderId == nil {
 		m.nodeLogError(typesCons.ErrNilLeaderId.Error(), nil)
 		return
 	}
 
-	m.nodeLog(typesCons.SendingMessage(msg, *m.leaderId))
+	m.nodeLog(typesCons.SendingMessage(msg, *m.LeaderId))
 	anyConsensusMessage, err := codec.GetCodec().ToAny(msg)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateConsensusMessage.Error(), err)
 		return
 	}
-	if err := m.GetBus().GetP2PModule().Send(cryptoPocket.AddressFromString(m.idToValAddrMap[*m.leaderId]), anyConsensusMessage, debug.PocketTopic_CONSENSUS_MESSAGE_TOPIC); err != nil {
+	if err := m.GetBus().GetP2PModule().Send(cryptoPocket.AddressFromString(m.idToValAddrMap[*m.LeaderId]), anyConsensusMessage, debug.PocketTopic_CONSENSUS_MESSAGE_TOPIC); err != nil {
 		m.nodeLogError(typesCons.ErrSendMessage.Error(), err)
 		return
 	}
@@ -177,7 +177,7 @@ func (m *ConsensusModule) clearMessagesPool() {
 /*** Leader Election Helpers ***/
 
 func (m *ConsensusModule) isLeader() bool {
-	return m.leaderId != nil && *m.leaderId == m.nodeId
+	return m.LeaderId != nil && *m.LeaderId == m.nodeId
 }
 
 func (m *ConsensusModule) isReplica() bool {
@@ -186,7 +186,7 @@ func (m *ConsensusModule) isReplica() bool {
 
 func (m *ConsensusModule) clearLeader() {
 	m.logPrefix = DefaultLogPrefix
-	m.leaderId = nil
+	m.LeaderId = nil
 }
 
 func (m *ConsensusModule) electNextLeader(message *typesCons.HotstuffMessage) error {
@@ -197,14 +197,14 @@ func (m *ConsensusModule) electNextLeader(message *typesCons.HotstuffMessage) er
 		return err
 	}
 
-	m.leaderId = &leaderId
+	m.LeaderId = &leaderId
 
-	if m.leaderId != nil && *m.leaderId == m.nodeId {
+	if m.LeaderId != nil && *m.LeaderId == m.nodeId {
 		m.logPrefix = "LEADER"
-		m.nodeLog(typesCons.ElectedSelfAsNewLeader(m.idToValAddrMap[*m.leaderId], *m.leaderId, m.Height, m.Round))
+		m.nodeLog(typesCons.ElectedSelfAsNewLeader(m.idToValAddrMap[*m.LeaderId], *m.LeaderId, m.Height, m.Round))
 	} else {
 		m.logPrefix = "REPLICA"
-		m.nodeLog(typesCons.ElectedNewLeader(m.idToValAddrMap[*m.leaderId], *m.leaderId, m.Height, m.Round))
+		m.nodeLog(typesCons.ElectedNewLeader(m.idToValAddrMap[*m.LeaderId], *m.LeaderId, m.Height, m.Round))
 	}
 
 	return nil
diff --git a/consensus/hotstuff_handler.go b/consensus/hotstuff_handler.go
index 6624917ed..b27e65ba1 100644
--- a/consensus/hotstuff_handler.go
+++ b/consensus/hotstuff_handler.go
@@ -23,7 +23,7 @@ func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage)
 		// If a replica is not a leader for this round, but has already determined a leader,
 		// and continues to receive NewRound messages, we avoid logging the "message discard"
 		// because it creates unnecessary spam.
-		if !(m.leaderId != nil && !m.isLeader() && step == NewRound) {
+		if !(m.LeaderId != nil && !m.isLeader() && step == NewRound) {
 			m.nodeLog(typesCons.WarnDiscardHotstuffMessage(msg, err.Error()))
 		}
 		return err
@@ -47,5 +47,5 @@ func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage)
 
 func (m *ConsensusModule) shouldElectNextLeader() bool {
 	// Execute leader election if there is no leader and we are in a new round
-	return m.Step == NewRound && m.leaderId == nil
+	return m.Step == NewRound && m.LeaderId == nil
 }
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 9000e4135..c985e9d15 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -114,7 +114,7 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrepareMessage(m *ConsensusMo
 	}
 
 	m.Step = PreCommit
-	m.HighPrepareQC = prepareQC
+	m.highPrepareQC = prepareQC
 	m.messagePool[Prepare] = nil
 
 	preCommitProposeMessage, err := CreateProposeMessage(m.Height, m.Round, PreCommit, m.Block, prepareQC)
@@ -158,7 +158,7 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrecommitMessage(m *Consensus
 	}
 
 	m.Step = Commit
-	m.LockedQC = preCommitQC
+	m.lockedQC = preCommitQC
 	m.messagePool[PreCommit] = nil
 
 	commitProposeMessage, err := CreateProposeMessage(m.Height, m.Round, Commit, m.Block, preCommitQC)
diff --git a/consensus/hotstuff_replica.go b/consensus/hotstuff_replica.go
index 4fb925bff..d0e5b7b9f 100644
--- a/consensus/hotstuff_replica.go
+++ b/consensus/hotstuff_replica.go
@@ -94,7 +94,7 @@ func (handler *HotstuffReplicaMessageHandler) HandlePrecommitMessage(m *Consensu
 	}
 
 	m.Step = Commit
-	m.HighPrepareQC = quorumCert // INVESTIGATE: Why are we never using this for validation?
+	m.highPrepareQC = quorumCert // INVESTIGATE: Why are we never using this for validation?
 
 	preCommitVoteMessage, err := CreateVoteMessage(m.Height, m.Round, PreCommit, m.Block, m.privateKey)
 	if err != nil {
@@ -123,7 +123,7 @@ func (handler *HotstuffReplicaMessageHandler) HandleCommitMessage(m *ConsensusMo
 	}
 
 	m.Step = Decide
-	m.LockedQC = quorumCert // DISCUSS: How does the replica recover if it's locked? Replica `formally` agrees on the QC while the rest of the network `verbally` agrees on the QC.
+	m.lockedQC = quorumCert // DISCUSS: How does the replica recover if it's locked? Replica `formally` agrees on the QC while the rest of the network `verbally` agrees on the QC.
 
 	commitVoteMessage, err := CreateVoteMessage(m.Height, m.Round, Commit, m.Block, m.privateKey)
 	if err != nil {
@@ -198,7 +198,7 @@ func (m *ConsensusModule) validateProposal(msg *typesCons.HotstuffMessage) error
 		}
 	}
 
-	lockedQC := m.LockedQC
+	lockedQC := m.lockedQC
 	justifyQC := quorumCert
 
 	// Safety: not locked
diff --git a/consensus/module.go b/consensus/module.go
index 62cfa3d86..6b5e5af42 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -41,11 +41,11 @@ type ConsensusModule struct {
 	Step   typesCons.HotstuffStep
 	Block  *typesCons.Block // The current block being proposed / voted on; it has not been committed to finality
 
-	HighPrepareQC *typesCons.QuorumCertificate // Highest QC for which replica voted PRECOMMIT
-	LockedQC      *typesCons.QuorumCertificate // Highest QC for which replica voted COMMIT
+	highPrepareQC *typesCons.QuorumCertificate // Highest QC for which replica voted PRECOMMIT
+	lockedQC      *typesCons.QuorumCertificate // Highest QC for which replica voted COMMIT
 
 	// Leader Election
-	leaderId       *typesCons.NodeId
+	LeaderId       *typesCons.NodeId
 	nodeId         typesCons.NodeId
 	valAddrToIdMap typesCons.ValAddrToIdMap // TODO: This needs to be updated every time the ValMap is modified
 	idToValAddrMap typesCons.IdToValAddrMap // TODO: This needs to be updated every time the ValMap is modified
@@ -114,11 +114,11 @@ func Create(configPath, genesisPath string, useRandomPK bool) (modules.Consensus
 		Step:   NewRound,
 		Block:  nil,
 
-		HighPrepareQC: nil,
-		LockedQC:      nil,
+		highPrepareQC: nil,
+		lockedQC:      nil,
 
 		nodeId:         valIdMap[address],
-		leaderId:       nil,
+		LeaderId:       nil,
 		valAddrToIdMap: valIdMap,
 		idToValAddrMap: idValMap,
 
diff --git a/consensus/pacemaker.go b/consensus/pacemaker.go
index 0b9e5ae17..9be4a6cb4 100644
--- a/consensus/pacemaker.go
+++ b/consensus/pacemaker.go
@@ -140,7 +140,7 @@ func (p *paceMaker) ValidateMessage(m *typesCons.HotstuffMessage) error {
 
 		// TODO(olshansky): Add tests for this. When we catch up to a later step, the leader is still the same.
 		// However, when we catch up to a later round, the leader at the same height will be different.
-		if p.consensusMod.Round != m.Round || p.consensusMod.leaderId == nil {
+		if p.consensusMod.Round != m.Round || p.consensusMod.LeaderId == nil {
 			p.consensusMod.electNextLeader(m)
 		}
 
@@ -178,7 +178,7 @@ func (p *paceMaker) InterruptRound() {
 	p.consensusMod.nodeLog(typesCons.PacemakerInterrupt(p.consensusMod.Height, p.consensusMod.Step, p.consensusMod.Round))
 
 	p.consensusMod.Round++
-	p.startNextView(p.consensusMod.HighPrepareQC, false)
+	p.startNextView(p.consensusMod.highPrepareQC, false)
 }
 
 func (p *paceMaker) NewHeight() {
@@ -188,8 +188,8 @@ func (p *paceMaker) NewHeight() {
 	p.consensusMod.Round = 0
 	p.consensusMod.Block = nil
 
-	p.consensusMod.HighPrepareQC = nil
-	p.consensusMod.LockedQC = nil
+	p.consensusMod.highPrepareQC = nil
+	p.consensusMod.lockedQC = nil
 
 	p.startNextView(nil, false) // TODO(design): We are omitting CommitQC and TimeoutQC here.
 

From a7207b980ce9e1cb0871d0b33810388966ca8a9d Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 28 Sep 2022 17:52:02 -0700
Subject: [PATCH 052/227] Add TODO in sequence diagram flow

---
 shared/docs/flows/AppHash.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/shared/docs/flows/AppHash.md b/shared/docs/flows/AppHash.md
index 51a1824b0..c17f3cd41 100644
--- a/shared/docs/flows/AppHash.md
+++ b/shared/docs/flows/AppHash.md
@@ -33,4 +33,8 @@ sequenceDiagram
 
 ## Block Application
 
+TODO(olshansky): Add a sequenceDiagram here.
+
 ## Block Commit
+
+TODO(olshansky): Add a sequenceDiagram here.

From a8e5f3dae04d54da3745c502e14ab27801578f69 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 28 Sep 2022 18:09:48 -0700
Subject: [PATCH 053/227] Added isNodeLockedOnPastQC

---
 consensus/hotstuff_replica.go | 24 +++++++++++++++++++++---
 consensus/types/errors.go     |  6 ++++--
 2 files changed, 25 insertions(+), 5 deletions(-)

diff --git a/consensus/hotstuff_replica.go b/consensus/hotstuff_replica.go
index d0e5b7b9f..752b7614b 100644
--- a/consensus/hotstuff_replica.go
+++ b/consensus/hotstuff_replica.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 
 	consensusTelemetry "github.com/pokt-network/pocket/consensus/telemetry"
+	"github.com/pokt-network/pocket/consensus/types"
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
 
@@ -214,10 +215,10 @@ func (m *ConsensusModule) validateProposal(msg *typesCons.HotstuffMessage) error
 		return nil
 	}
 
-	// Liveness: node is locked on a QC from the past.
+	// Liveness: is node is locked on a QC from the past?
 	// DISCUSS: Where should additional logic be added to unlock the node?
-	if justifyQC.Height > lockedQC.Height || (justifyQC.Height == lockedQC.Height && justifyQC.Round > lockedQC.Round) {
-		return typesCons.ErrNodeIsLockedOnPastQC
+	if isLocked, err := isNodeLockedOnPastQC(justifyQC, lockedQC); isLocked {
+		return err
 	}
 
 	return typesCons.ErrUnhandledProposalCase
@@ -280,6 +281,23 @@ func (m *ConsensusModule) validateQuorumCertificate(qc *typesCons.QuorumCertific
 	return nil
 }
 
+func isNodeLockedOnPastQC(justifyQC, lockedQC *types.QuorumCertificate) (bool, error) {
+	if isLockedOnPastHeight(justifyQC, lockedQC) {
+		return true, types.ErrNodeLockedPastHeight
+	} else if isLockedOnCurrHeightAndPastRound(justifyQC, lockedQC) {
+		return true, types.ErrNodeLockedPastHeight
+	}
+	return false, nil
+}
+
+func isLockedOnPastHeight(justifyQC, lockedQC *types.QuorumCertificate) bool {
+	return justifyQC.Height > lockedQC.Height
+}
+
+func isLockedOnCurrHeightAndPastRound(justifyQC, lockedQC *types.QuorumCertificate) bool {
+	return justifyQC.Height == lockedQC.Height && justifyQC.Round > lockedQC.Round
+}
+
 func qcToHotstuffMessage(qc *typesCons.QuorumCertificate) *typesCons.HotstuffMessage {
 	return &typesCons.HotstuffMessage{
 		Height: qc.Height,
diff --git a/consensus/types/errors.go b/consensus/types/errors.go
index faf9d7002..5368ee1bf 100644
--- a/consensus/types/errors.go
+++ b/consensus/types/errors.go
@@ -124,7 +124,8 @@ const (
 	nilBlockInQCError                           = "QC must contain a non nil block"
 	nilThresholdSigInQCError                    = "QC must contains a non nil threshold signature"
 	notEnoughSignaturesError                    = "did not receive enough partial signature"
-	nodeIsLockedOnPastQCError                   = "node is locked on a QC from the past"
+	nodeIsLockedOnPastHeightQCError             = "node is locked on a QC from a past height"
+	nodeIsLockedOnPastRoundQCError              = "node is locked on a QC from a past round"
 	unhandledProposalCaseError                  = "unhandled proposal validation check"
 	unnecessaryPartialSigForNewRoundError       = "newRound messages do not need a partial signature"
 	unnecessaryPartialSigForLeaderProposalError = "leader proposals do not need a partial signature"
@@ -163,7 +164,8 @@ var (
 	ErrNilBlockInQC                           = errors.New(nilBlockInQCError)
 	ErrNilThresholdSigInQC                    = errors.New(nilThresholdSigInQCError)
 	ErrNotEnoughSignatures                    = errors.New(notEnoughSignaturesError)
-	ErrNodeIsLockedOnPastQC                   = errors.New(nodeIsLockedOnPastQCError)
+	ErrNodeLockedPastHeight                   = errors.New(nodeIsLockedOnPastHeightQCError)
+	ErrNodeLockedPastRound                    = errors.New(nodeIsLockedOnPastRoundQCError)
 	ErrUnhandledProposalCase                  = errors.New(unhandledProposalCaseError)
 	ErrUnnecessaryPartialSigForNewRound       = errors.New(unnecessaryPartialSigForNewRoundError)
 	ErrUnnecessaryPartialSigForLeaderProposal = errors.New(unnecessaryPartialSigForLeaderProposalError)

From e39f0f8b17311bc6db86b66b0cb482898bc9914e Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 28 Sep 2022 18:11:33 -0700
Subject: [PATCH 054/227] Logging error when refreshUtilityContext fails

---
 consensus/hotstuff_leader.go  | 1 +
 consensus/hotstuff_replica.go | 1 +
 2 files changed, 2 insertions(+)

diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index c985e9d15..b7dad2466 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -42,6 +42,7 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusM
 
 	// Clear the previous utility context, if it exists, and create a new one
 	if err := m.refreshUtilityContext(); err != nil {
+		m.nodeLogError("Could not refresh utility context", err)
 		return
 	}
 
diff --git a/consensus/hotstuff_replica.go b/consensus/hotstuff_replica.go
index 752b7614b..9da379a61 100644
--- a/consensus/hotstuff_replica.go
+++ b/consensus/hotstuff_replica.go
@@ -35,6 +35,7 @@ func (handler *HotstuffReplicaMessageHandler) HandleNewRoundMessage(m *Consensus
 
 	// Clear the previous utility context, if it exists, and create a new one
 	if err := m.refreshUtilityContext(); err != nil {
+		m.nodeLogError("Could not refresh utility context", err)
 		return
 	}
 

From a6990d217861bfe25ea34d2ff643f1d8cace93fe Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 28 Sep 2022 18:23:56 -0700
Subject: [PATCH 055/227] Added shouldLogHotstuffDiscardMessage

---
 consensus/hotstuff_handler.go | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/consensus/hotstuff_handler.go b/consensus/hotstuff_handler.go
index b27e65ba1..536777a1c 100644
--- a/consensus/hotstuff_handler.go
+++ b/consensus/hotstuff_handler.go
@@ -20,10 +20,7 @@ func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage)
 
 	// Pacemaker - Liveness & safety checks
 	if err := m.paceMaker.ValidateMessage(msg); err != nil {
-		// If a replica is not a leader for this round, but has already determined a leader,
-		// and continues to receive NewRound messages, we avoid logging the "message discard"
-		// because it creates unnecessary spam.
-		if !(m.LeaderId != nil && !m.isLeader() && step == NewRound) {
+		if m.shouldLogHotstuffDiscardMessage() {
 			m.nodeLog(typesCons.WarnDiscardHotstuffMessage(msg, err.Error()))
 		}
 		return err
@@ -49,3 +46,10 @@ func (m *ConsensusModule) shouldElectNextLeader() bool {
 	// Execute leader election if there is no leader and we are in a new round
 	return m.Step == NewRound && m.LeaderId == nil
 }
+
+func (m *ConsensusModule) shouldLogHotstuffDiscardMessage(step typesCons.HotstuffStep) bool {
+	// If a replica is not a leader for this round, but has already determined a leader,
+	// and continues to receive NewRound messages, we avoid logging the "message discard"
+	// because it creates unnecessary spam.
+	return !(m.LeaderId != nil && !m.isLeader() && step == NewRound)
+}

From 8a41361cb93007896bfd8222782819bc415b2f37 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 28 Sep 2022 18:32:50 -0700
Subject: [PATCH 056/227] Added shouldPrepareNewBlock

---
 consensus/hotstuff_handler.go |  2 +-
 consensus/hotstuff_leader.go  | 22 +++++++++++++++++++++-
 2 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/consensus/hotstuff_handler.go b/consensus/hotstuff_handler.go
index 536777a1c..274a1b45b 100644
--- a/consensus/hotstuff_handler.go
+++ b/consensus/hotstuff_handler.go
@@ -20,7 +20,7 @@ func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage)
 
 	// Pacemaker - Liveness & safety checks
 	if err := m.paceMaker.ValidateMessage(msg); err != nil {
-		if m.shouldLogHotstuffDiscardMessage() {
+		if m.shouldLogHotstuffDiscardMessage(step) {
 			m.nodeLog(typesCons.WarnDiscardHotstuffMessage(msg, err.Error()))
 		}
 		return err
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index b7dad2466..1e1cefa7d 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -51,7 +51,7 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusM
 	highPrepareQC := m.findHighQC(m.messagePool[NewRound])
 
 	// TODO: Add more unit tests for these checks...
-	if highPrepareQC == nil || highPrepareQC.Height < m.Height || highPrepareQC.Round < m.Round {
+	if m.shouldPrepareNewBlock(highPrepareQC) {
 		// Leader prepares a new block if `highPrepareQC` is not applicable
 		block, err := m.prepareAndApplyBlock()
 		if err != nil {
@@ -362,3 +362,23 @@ func (m *ConsensusModule) prepareAndApplyBlock() (*typesCons.Block, error) {
 
 	return block, nil
 }
+
+// Return true if this node, the leader, should prepare a new block
+func (m *ConsensusModule) shouldPrepareNewBlock(highPrepareQC *typesCons.QuorumCertificate) bool {
+	if highPrepareQC == nil {
+		m.nodeLog("Preparing a new block - no highPrepareQC found")
+		return true
+	} else if m.isHighPrepareQCFromPast(highPrepareQC) {
+		m.nodeLog("Preparing a new block - highPrepareQC is from the past")
+		return true
+	} else if highPrepareQC.Block == nil {
+		m.nodeLog("[WARN] Preparing a new block - highPrepareQC SHOULD be used but block is nil")
+		return true
+	}
+	return false
+}
+
+// The `highPrepareQC` is from the past so we can safely ignore it
+func (m *ConsensusModule) isHighPrepareQCFromPast(highPrepareQC *typesCons.QuorumCertificate) bool {
+	return highPrepareQC.Height < m.Height || highPrepareQC.Round < m.Round
+}

From 7493dd39059f99ddf55e29e1d453456c93105bb8 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 28 Sep 2022 18:48:09 -0700
Subject: [PATCH 057/227] Added TODO for 256

---
 consensus/helpers.go | 2 +-
 consensus/module.go  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/consensus/helpers.go b/consensus/helpers.go
index a81c60205..a9b3b5caa 100644
--- a/consensus/helpers.go
+++ b/consensus/helpers.go
@@ -39,7 +39,7 @@ var (
 // ** Hotstuff Helpers ** //
 
 // IMPROVE: Avoid having the `ConsensusModule` be a receiver of this; making it more functional.
-// TODO: Add unit tests for quorumCert creation & validation.
+// TODO: Add unit tests for all quorumCert creation & validation logic...
 func (m *ConsensusModule) getQuorumCertificate(height uint64, step typesCons.HotstuffStep, round uint64) (*typesCons.QuorumCertificate, error) {
 	var pss []*typesCons.PartialSignature
 	for _, msg := range m.messagePool[step] {
diff --git a/consensus/module.go b/consensus/module.go
index 6b5e5af42..23a1fc881 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -27,7 +27,7 @@ var _ modules.PacemakerConfig = &typesCons.PacemakerConfig{}
 var _ modules.ConsensusConfig = &typesCons.ConsensusConfig{}
 var _ modules.ConsensusModule = &ConsensusModule{}
 
-// TODO: Do not export the `ConsensusModule` struct or the fields inside of it.
+// TODO(#256): Do not export the `ConsensusModule` struct or the fields inside of it.
 type ConsensusModule struct {
 	bus        modules.Bus
 	privateKey cryptoPocket.Ed25519PrivateKey

From 3f413bd06099802d568f6f54ad07cbf04f59648d Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 3 Oct 2022 20:56:55 -0700
Subject: [PATCH 058/227] Added SetUtilityMod and made utilityContext private

---
 consensus/block.go                          | 17 ++++++++--------
 consensus/consensus_tests/pacemaker_test.go | 22 +++++++++++----------
 consensus/consensus_tests/utils_test.go     |  8 ++++++--
 consensus/hotstuff_leader.go                |  4 ++--
 consensus/hotstuff_replica.go               |  2 +-
 consensus/module.go                         |  9 +++++++--
 6 files changed, 36 insertions(+), 26 deletions(-)

diff --git a/consensus/block.go b/consensus/block.go
index ae4ca7dca..a70c6cecc 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -4,7 +4,6 @@ import (
 	"log"
 	"unsafe"
 
-
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 	"github.com/pokt-network/pocket/shared/codec"
 )
@@ -30,12 +29,12 @@ func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 	}
 
 	// Commit and release the context
-	if err := m.UtilityContext.CommitPersistenceContext(); err != nil {
+	if err := m.utilityContext.CommitPersistenceContext(); err != nil {
 		return err
 	}
 
-	m.UtilityContext.ReleaseContext()
-	m.UtilityContext = nil
+	m.utilityContext.ReleaseContext()
+	m.utilityContext = nil
 
 	m.lastAppHash = block.BlockHeader.Hash
 
@@ -43,7 +42,7 @@ func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 }
 
 func (m *ConsensusModule) storeBlock(block *typesCons.Block, blockProtoBytes []byte) error {
-	store := m.UtilityContext.GetPersistenceContext()
+	store := m.utilityContext.GetPersistenceContext()
 	// Store in KV Store
 	if err := store.StoreBlock(blockProtoBytes); err != nil {
 		return err
@@ -88,10 +87,10 @@ func (m *ConsensusModule) validateBlockBasic(block *typesCons.Block) error {
 func (m *ConsensusModule) refreshUtilityContext() error {
 	// Catch-all structure to release the previous utility context if it wasn't properly cleaned up.
 	// Ideally, this should not be called.
-	if m.UtilityContext != nil {
+	if m.utilityContext != nil {
 		m.nodeLog(typesCons.NilUtilityContextWarning)
-		m.UtilityContext.ReleaseContext()
-		m.UtilityContext = nil
+		m.utilityContext.ReleaseContext()
+		m.utilityContext = nil
 	}
 
 	utilityContext, err := m.GetBus().GetUtilityModule().NewContext(int64(m.Height))
@@ -99,6 +98,6 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 		return err
 	}
 
-	m.UtilityContext = utilityContext
+	m.utilityContext = utilityContext
 	return nil
 }
diff --git a/consensus/consensus_tests/pacemaker_test.go b/consensus/consensus_tests/pacemaker_test.go
index 3090d24ca..80bf64fc4 100644
--- a/consensus/consensus_tests/pacemaker_test.go
+++ b/consensus/consensus_tests/pacemaker_test.go
@@ -157,7 +157,7 @@ func TestPacemakerCatchupSameStepDifferentRounds(t *testing.T) {
 		Transactions: emptyTxs,
 	}
 
-	leaderConsensusMod := GetConsensusModImplementation(leader)
+	leaderConsensusMod := GetConsensusModElem(leader)
 	leaderConsensusMod.FieldByName("Block").Set(reflect.ValueOf(block))
 
 	// Set all nodes to the same STEP and HEIGHT BUT different ROUNDS
@@ -166,18 +166,20 @@ func TestPacemakerCatchupSameStepDifferentRounds(t *testing.T) {
 		utilityContext, err := pocketNode.GetBus().GetUtilityModule().NewContext(int64(testHeight))
 		require.NoError(t, err)
 
-		consensusModImpl := GetConsensusModImplementation(pocketNode)
-		consensusModImpl.FieldByName("Height").SetUint(testHeight)
-		consensusModImpl.FieldByName("Step").SetInt(testStep)
-		consensusModImpl.FieldByName("LeaderId").Set(reflect.Zero(reflect.TypeOf(&leaderId))) // This is re-elected during paceMaker catchup
-		consensusModImpl.FieldByName("UtilityContext").Set(reflect.ValueOf(utilityContext))
+		consensusModElem := GetConsensusModElem(pocketNode)
+		consensusModElem.FieldByName("Height").SetUint(testHeight)
+		consensusModElem.FieldByName("Step").SetInt(testStep)
+		consensusModElem.FieldByName("LeaderId").Set(reflect.Zero(reflect.TypeOf(&leaderId))) // This is re-elected during paceMaker catchup
+
+		consensusModImpl := GetConsensusModImpl(pocketNode)
+		consensusModImpl.MethodByName("SetUtilityContext").Call([]reflect.Value{reflect.ValueOf(utilityContext)})
 	}
 
 	// Set the leader to be in the highest round.
-	GetConsensusModImplementation(pocketNodes[1]).FieldByName("Round").SetUint(uint64(leaderRound - 2))
-	GetConsensusModImplementation(pocketNodes[2]).FieldByName("Round").SetUint(uint64(leaderRound - 3))
-	GetConsensusModImplementation(pocketNodes[leaderId]).FieldByName("Round").SetUint(uint64(leaderRound))
-	GetConsensusModImplementation(pocketNodes[4]).FieldByName("Round").SetUint(uint64(leaderRound - 4))
+	GetConsensusModElem(pocketNodes[1]).FieldByName("Round").SetUint(uint64(leaderRound - 2))
+	GetConsensusModElem(pocketNodes[2]).FieldByName("Round").SetUint(uint64(leaderRound - 3))
+	GetConsensusModElem(pocketNodes[leaderId]).FieldByName("Round").SetUint(uint64(leaderRound))
+	GetConsensusModElem(pocketNodes[4]).FieldByName("Round").SetUint(uint64(leaderRound - 4))
 
 	prepareProposal := &typesCons.HotstuffMessage{
 		Type:          consensus.Propose,
diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 9a2473541..3bda5de07 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -181,13 +181,17 @@ func StartAllTestPocketNodes(t *testing.T, pocketNodes IdToNodeMapping) {
 // define the interfaces used for debug/development. The latter will probably scale more but will
 // require more effort and pollute the source code with debugging information.
 func GetConsensusNodeState(node *shared.Node) typesCons.ConsensusNodeState {
-	return reflect.ValueOf(node.GetBus().GetConsensusModule()).MethodByName("GetNodeState").Call([]reflect.Value{})[0].Interface().(typesCons.ConsensusNodeState)
+	return GetConsensusModImpl(node).MethodByName("GetNodeState").Call([]reflect.Value{})[0].Interface().(typesCons.ConsensusNodeState)
 }
 
-func GetConsensusModImplementation(node *shared.Node) reflect.Value {
+func GetConsensusModElem(node *shared.Node) reflect.Value {
 	return reflect.ValueOf(node.GetBus().GetConsensusModule()).Elem()
 }
 
+func GetConsensusModImpl(node *shared.Node) reflect.Value {
+	return reflect.ValueOf(node.GetBus().GetConsensusModule())
+}
+
 /*** Debug/Development Message Helpers ***/
 
 func TriggerNextView(t *testing.T, node *shared.Node) {
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 1e1cefa7d..54f41e0dd 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -334,14 +334,14 @@ func (m *ConsensusModule) prepareAndApplyBlock() (*typesCons.Block, error) {
 	lastByzValidators := make([][]byte, 0)
 
 	// Reap the mempool for transactions to be applied in this block
-	txs, err := m.UtilityContext.GetProposalTransactions(m.privateKey.Address(), maxTxBytes, lastByzValidators)
+	txs, err := m.utilityContext.GetProposalTransactions(m.privateKey.Address(), maxTxBytes, lastByzValidators)
 	if err != nil {
 		return nil, err
 	}
 
 	// OPTIMIZE: Determine if we can avoid the `ApplyBlock` call here
 	// Apply all the transactions in the block
-	appHash, err := m.UtilityContext.ApplyBlock(int64(m.Height), m.privateKey.Address(), txs, lastByzValidators)
+	appHash, err := m.utilityContext.ApplyBlock(int64(m.Height), m.privateKey.Address(), txs, lastByzValidators)
 	if err != nil {
 		return nil, err
 	}
diff --git a/consensus/hotstuff_replica.go b/consensus/hotstuff_replica.go
index 9da379a61..a71119307 100644
--- a/consensus/hotstuff_replica.go
+++ b/consensus/hotstuff_replica.go
@@ -231,7 +231,7 @@ func (m *ConsensusModule) applyBlock(block *typesCons.Block) error {
 	lastByzValidators := make([][]byte, 0)
 
 	// Apply all the transactions in the block and get the appHash
-	appHash, err := m.UtilityContext.ApplyBlock(int64(m.Height), block.BlockHeader.ProposerAddress, block.Transactions, lastByzValidators)
+	appHash, err := m.utilityContext.ApplyBlock(int64(m.Height), block.BlockHeader.ProposerAddress, block.Transactions, lastByzValidators)
 	if err != nil {
 		return err
 	}
diff --git a/consensus/module.go b/consensus/module.go
index 5259fc0cf..0f7f9f9f7 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -63,7 +63,7 @@ type ConsensusModule struct {
 	validatorMap typesCons.ValidatorMap
 
 	// Module Dependencies
-	UtilityContext    modules.UtilityContext
+	utilityContext    modules.UtilityContext
 	paceMaker         Pacemaker
 	leaderElectionMod leader_election.LeaderElectionModule
 
@@ -133,7 +133,7 @@ func Create(configPath, genesisPath string, useRandomPK bool) (modules.Consensus
 		lastAppHash:  "",
 		validatorMap: valMap,
 
-		UtilityContext:    nil,
+		utilityContext:    nil,
 		paceMaker:         paceMaker,
 		leaderElectionMod: leaderElectionMod,
 
@@ -262,6 +262,11 @@ func (m *ConsensusModule) ValidatorMap() modules.ValidatorMap {
 	return typesCons.ValidatorMapToModulesValidatorMap(m.validatorMap)
 }
 
+// TODO(#256): Currently only used for testing purposes
+func (m *ConsensusModule) SetUtilityContext(utilityContext modules.UtilityContext) {
+	m.utilityContext = utilityContext
+}
+
 // TODO: Populate the entire state from the persistence module: validator set, quorum cert, last block hash, etc...
 func (m *ConsensusModule) loadPersistedState() error {
 	persistenceContext, err := m.GetBus().GetPersistenceModule().NewReadContext(-1) // Unknown height

From 317e677fad6274b7cd20f3fd44bf2ed5afc7ab06 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 3 Oct 2022 21:30:10 -0700
Subject: [PATCH 059/227] Updated a comment

---
 consensus/hotstuff_replica.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/consensus/hotstuff_replica.go b/consensus/hotstuff_replica.go
index a71119307..e55e85585 100644
--- a/consensus/hotstuff_replica.go
+++ b/consensus/hotstuff_replica.go
@@ -216,7 +216,7 @@ func (m *ConsensusModule) validateProposal(msg *typesCons.HotstuffMessage) error
 		return nil
 	}
 
-	// Liveness: is node is locked on a QC from the past?
+	// Liveness: is node locked on a QC from the past?
 	// DISCUSS: Where should additional logic be added to unlock the node?
 	if isLocked, err := isNodeLockedOnPastQC(justifyQC, lockedQC); isLocked {
 		return err

From 070ba2a0b2ed05ef6231a0c6aeadd8a28e5fc352 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 4 Oct 2022 16:57:13 -0700
Subject: [PATCH 060/227] Added a TODO for 283

---
 consensus/module.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/consensus/module.go b/consensus/module.go
index 0f7f9f9f7..917cd88d4 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -63,6 +63,7 @@ type ConsensusModule struct {
 	validatorMap typesCons.ValidatorMap
 
 	// Module Dependencies
+	// TODO(#283): Improve how `utilityContext` is managed
 	utilityContext    modules.UtilityContext
 	paceMaker         Pacemaker
 	leaderElectionMod leader_election.LeaderElectionModule

From 6dafdeac3f1f596711c2fee35f3e88df16e00b6a Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 4 Oct 2022 17:33:46 -0700
Subject: [PATCH 061/227] Revert all changes back to main

---
 Makefile                                    |   4 +-
 consensus/CHANGELOG.md                      |  42 +---
 consensus/block.go                          | 146 +++++++++-----
 consensus/consensus_tests/pacemaker_test.go |  25 +--
 consensus/consensus_tests/utils_test.go     |  52 ++---
 consensus/debugging.go                      |   5 +-
 consensus/helpers.go                        |  79 ++++----
 consensus/hotstuff_handler.go               |  55 ------
 consensus/hotstuff_leader.go                | 200 ++++++--------------
 consensus/hotstuff_replica.go               | 139 +++++---------
 consensus/messages.go                       |  67 +++----
 consensus/module.go                         | 183 +++++++++++-------
 consensus/pacemaker.go                      |   2 +-
 consensus/types/errors.go                   |  27 ++-
 consensus/types/proto/block.proto           |   2 +-
 consensus/types/proto/hotstuff_types.proto  |   2 +-
 consensus/types/types.go                    |   4 +-
 shared/codec/codec.go                       |   4 -
 shared/modules/consensus_module.go          |   7 +-
 shared/modules/persistence_module.go        |  49 +++--
 shared/modules/utility_module.go            |   8 +-
 shared/test_artifacts/generator.go          |   5 +-
 22 files changed, 475 insertions(+), 632 deletions(-)
 delete mode 100644 consensus/hotstuff_handler.go

diff --git a/Makefile b/Makefile
index 79c1cda22..4cdc29a03 100644
--- a/Makefile
+++ b/Makefile
@@ -347,11 +347,9 @@ benchmark_p2p_addrbook:
 # HACK          - Like TECHDEBT, but much worse. This needs to be prioritized
 # REFACTOR      - Similar to TECHDEBT, but will require a substantial rewrite and change across the codebase
 # CONSIDERATION - A comment that involves extra work but was thoughts / considered as part of some implementation
-# CONSOLIDATE   - We likely have similar implementations/types of the same thing, and we should consolidate them.
-# DEPRECATE     - Code that should be removed in the future
 # DISCUSS_IN_THIS_COMMIT - SHOULD NEVER BE COMMITTED TO MASTER. It is a way for the reviewer of a PR to start / reply to a discussion.
 # TODO_IN_THIS_COMMIT    - SHOULD NEVER BE COMMITTED TO MASTER. It is a way to start the review process while non-critical changes are still in progress
-TODO_KEYWORDS = -e "TODO" -e "TECHDEBT" -e "IMPROVE" -e "DISCUSS" -e "INCOMPLETE" -e "INVESTIGATE" -e "CLEANUP" -e "HACK" -e "REFACTOR" -e "CONSIDERATION" -e "TODO_IN_THIS_COMMIT" -e "DISCUSS_IN_THIS_COMMIT" -e "CONSOLIDATE" -e "DEPRECATE"
+TODO_KEYWORDS = -e "TODO" -e "TECHDEBT" -e "IMPROVE" -e "DISCUSS" -e "INCOMPLETE" -e "INVESTIGATE" -e "CLEANUP" -e "HACK" -e "REFACTOR" -e "CONSIDERATION" -e "TODO_IN_THIS_COMMIT" -e "DISCUSS_IN_THIS_COMMIT"
 
 # How do I use TODOs?
 # 1. <KEYWORD>: <Description of follow up work>;
diff --git a/consensus/CHANGELOG.md b/consensus/CHANGELOG.md
index f51a52410..a41773b18 100644
--- a/consensus/CHANGELOG.md
+++ b/consensus/CHANGELOG.md
@@ -7,43 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.0.0.4] - 2022-09-28
-
+## [0.0.0.3] - 2022-09-28
 - `consensusModule` stores block directly to prevent shared structure in the `utilityModule`
 
-## [0.0.0.3] - 2022-09-26
-
-Consensus logic
-
-- Pass in a list of messages to `findHighQC` instead of a hotstuff step
-- Made `CreateProposeMessage` and `CreateVotemessage` accept explicit values, identifying some bugs along the way
-- Made sure to call `applyBlock` when using `highQC` from previous round
-- Moved business logic for `prepareAndApplyBlock` into `hotstuff_leader.go`
-- Removed `MaxBlockBytes` and storing the consensus genesis type locally as is
-
-Consensus cleanup
-
-- Using appropriate getters for protocol types in the hotstuff lifecycle
-- Replaced `proto.Marshal` with `codec.GetCodec().Marshal`
-- Reorganized and cleaned up the code in `consensus/block.go`
-- Consolidated & removed a few `TODO`s throughout the consensus module
-- Added TECHDEBT and TODOs that will be require for a real block lifecycle
-- Fixed typo in `hotstuff_types.proto`
-- Moved the hotstuff handler interface to `consensus/hotstuff_handler.go`
-
-Consensus testing
-
-- Improved mock module initialization in `consensus/consensus_tests/utils_test.go`
-
-General
-
-- Added a diagram for `AppHash` related `ContextInitialization`
-- Added `Makefile` keywords for `TODO`
-
 ## [0.0.0.2] - 2022-08-25
-
 **Encapsulate structures previously in shared [#163](github.com/pokt-network/pocket/issues/163)**
-
 - Ensured proto structures implement shared interfaces
 - `ConsensusConfig` uses shared interfaces in order to accept `MockConsensusConfig` in test_artifacts
 - `ConsensusGenesisState` uses shared interfaces in order to accept `MockConsensusGenesisState` in test_artifacts
@@ -51,7 +19,9 @@ General
 
 ## [0.0.0.1] - 2021-03-31
 
-### Added new libraries: HotPocket 1st iteration
+HotPocket 1st Iteration (https://github.com/pokt-network/pocket/pull/48)
+
+# Added
 
 - Initial implementation of Basic Hotstuff
 - Initial implementation Hotstuff Pacemaker
@@ -62,7 +32,9 @@ General
 
 ## [0.0.0.0] - 2021-03-31
 
-### Added new libraries: VRF & Cryptographic Sortition Libraries
+VRF & Cryptographic Sortition Libraries (https://github.com/pokt-network/pocket/pull/37/files)
+
+### Added
 
 - Tests with `make test_vrf` and `make test_sortition`
 - Benchmarking via `make benchmark_sortition`
diff --git a/consensus/block.go b/consensus/block.go
index a70c6cecc..536c3cc74 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -1,13 +1,107 @@
 package consensus
 
 import (
-	"log"
+	"encoding/hex"
 	"unsafe"
 
-	typesCons "github.com/pokt-network/pocket/consensus/types"
 	"github.com/pokt-network/pocket/shared/codec"
+
+	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
 
+// TODO(olshansky): Sync with Andrew on the type of validation we need here.
+func (m *ConsensusModule) validateBlock(block *typesCons.Block) error {
+	if block == nil {
+		return typesCons.ErrNilBlock
+	}
+	return nil
+}
+
+// This is a helper function intended to be called by a leader/validator during a view change
+func (m *ConsensusModule) prepareBlockAsLeader() (*typesCons.Block, error) {
+	if m.isReplica() {
+		return nil, typesCons.ErrReplicaPrepareBlock
+	}
+
+	if err := m.refreshUtilityContext(); err != nil {
+		return nil, err
+	}
+
+	txs, err := m.utilityContext.GetProposalTransactions(m.privateKey.Address(), maxTxBytes, lastByzValidators)
+	if err != nil {
+		return nil, err
+	}
+
+	appHash, err := m.utilityContext.ApplyBlock(int64(m.Height), m.privateKey.Address(), txs, lastByzValidators)
+	if err != nil {
+		return nil, err
+	}
+
+	blockHeader := &typesCons.BlockHeader{
+		Height:            int64(m.Height),
+		Hash:              hex.EncodeToString(appHash),
+		NumTxs:            uint32(len(txs)),
+		LastBlockHash:     m.appHash,
+		ProposerAddress:   m.privateKey.Address().Bytes(),
+		QuorumCertificate: []byte("HACK: Temporary placeholder"),
+	}
+
+	block := &typesCons.Block{
+		BlockHeader:  blockHeader,
+		Transactions: txs,
+	}
+
+	return block, nil
+}
+
+// This is a helper function intended to be called by a replica/voter during a view change
+func (m *ConsensusModule) applyBlockAsReplica(block *typesCons.Block) error {
+	if m.isLeader() {
+		return typesCons.ErrLeaderApplyBLock
+	}
+
+	// TODO(olshansky): Add unit tests to verify this.
+	if unsafe.Sizeof(*block) > uintptr(m.MaxBlockBytes) {
+		return typesCons.ErrInvalidBlockSize(uint64(unsafe.Sizeof(*block)), m.MaxBlockBytes)
+	}
+
+	if err := m.refreshUtilityContext(); err != nil {
+		return err
+	}
+
+	appHash, err := m.utilityContext.ApplyBlock(int64(m.Height), block.BlockHeader.ProposerAddress, block.Transactions, lastByzValidators)
+	if err != nil {
+		return err
+	}
+
+	// DISCUSS(drewsky): Is `ApplyBlock` going to return blockHash or appHash?
+	if block.BlockHeader.Hash != hex.EncodeToString(appHash) {
+		return typesCons.ErrInvalidAppHash(block.BlockHeader.Hash, hex.EncodeToString(appHash))
+	}
+
+	return nil
+}
+
+// Creates a new Utility context and clears/nullifies any previous contexts if they exist
+func (m *ConsensusModule) refreshUtilityContext() error {
+	// This is a catch-all to release the previous utility context if it wasn't cleaned up
+	// in the proper lifecycle (e.g. catch up, error, network partition, etc...). Ideally, this
+	// should not be called.
+	if m.utilityContext != nil {
+		m.nodeLog(typesCons.NilUtilityContextWarning)
+		m.utilityContext.ReleaseContext()
+		m.utilityContext = nil
+	}
+
+	utilityContext, err := m.GetBus().GetUtilityModule().NewContext(int64(m.Height))
+	if err != nil {
+		return err
+	}
+
+	m.utilityContext = utilityContext
+	return nil
+}
+
 func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
 
@@ -36,7 +130,7 @@ func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 	m.utilityContext.ReleaseContext()
 	m.utilityContext = nil
 
-	m.lastAppHash = block.BlockHeader.Hash
+	m.appHash = block.BlockHeader.Hash
 
 	return nil
 }
@@ -55,49 +149,3 @@ func (m *ConsensusModule) storeBlock(block *typesCons.Block, blockProtoBytes []b
 	}
 	return nil
 }
-
-// TODO: Add unit tests specific to block validation
-func (m *ConsensusModule) validateBlockBasic(block *typesCons.Block) error {
-	if block == nil && m.Step != NewRound {
-		return typesCons.ErrNilBlock
-	}
-
-	if block != nil && m.Step == NewRound {
-		return typesCons.ErrBlockExists
-	}
-
-	if block != nil && unsafe.Sizeof(*block) > uintptr(m.consGenesis.MaxBlockBytes) {
-		return typesCons.ErrInvalidBlockSize(uint64(unsafe.Sizeof(*block)), m.consGenesis.MaxBlockBytes)
-	}
-
-	// If the current block being processed (i.e. voted on) by consensus is non nil, we need to make
-	// sure that the data (height, round, step, txs, etc) is the same before we start validating the signatures
-	if m.Block != nil {
-		// DISCUSS: The only difference between blocks from one step to another is the QC, so we need
-		//          to determine where/how to validate this
-		if protoHash(m.Block) != protoHash(block) {
-			log.Println("[TECHDEBT][ERROR] The block being processed is not the same as that received by the consensus module ")
-		}
-	}
-
-	return nil
-}
-
-// Creates a new Utility context and clears/nullifies any previous contexts if they exist
-func (m *ConsensusModule) refreshUtilityContext() error {
-	// Catch-all structure to release the previous utility context if it wasn't properly cleaned up.
-	// Ideally, this should not be called.
-	if m.utilityContext != nil {
-		m.nodeLog(typesCons.NilUtilityContextWarning)
-		m.utilityContext.ReleaseContext()
-		m.utilityContext = nil
-	}
-
-	utilityContext, err := m.GetBus().GetUtilityModule().NewContext(int64(m.Height))
-	if err != nil {
-		return err
-	}
-
-	m.utilityContext = utilityContext
-	return nil
-}
diff --git a/consensus/consensus_tests/pacemaker_test.go b/consensus/consensus_tests/pacemaker_test.go
index 80bf64fc4..4134f17cc 100644
--- a/consensus/consensus_tests/pacemaker_test.go
+++ b/consensus/consensus_tests/pacemaker_test.go
@@ -157,29 +157,22 @@ func TestPacemakerCatchupSameStepDifferentRounds(t *testing.T) {
 		Transactions: emptyTxs,
 	}
 
-	leaderConsensusMod := GetConsensusModElem(leader)
+	leaderConsensusMod := GetConsensusModImplementation(leader)
 	leaderConsensusMod.FieldByName("Block").Set(reflect.ValueOf(block))
 
 	// Set all nodes to the same STEP and HEIGHT BUT different ROUNDS
 	for _, pocketNode := range pocketNodes {
-		// utilityContext is only set on new rounds, which is skipped in this test
-		utilityContext, err := pocketNode.GetBus().GetUtilityModule().NewContext(int64(testHeight))
-		require.NoError(t, err)
-
-		consensusModElem := GetConsensusModElem(pocketNode)
-		consensusModElem.FieldByName("Height").SetUint(testHeight)
-		consensusModElem.FieldByName("Step").SetInt(testStep)
-		consensusModElem.FieldByName("LeaderId").Set(reflect.Zero(reflect.TypeOf(&leaderId))) // This is re-elected during paceMaker catchup
-
-		consensusModImpl := GetConsensusModImpl(pocketNode)
-		consensusModImpl.MethodByName("SetUtilityContext").Call([]reflect.Value{reflect.ValueOf(utilityContext)})
+		consensusModImpl := GetConsensusModImplementation(pocketNode)
+		consensusModImpl.FieldByName("Height").SetUint(testHeight)
+		consensusModImpl.FieldByName("Step").SetInt(testStep)
+		consensusModImpl.FieldByName("LeaderId").Set(reflect.Zero(reflect.TypeOf(&leaderId))) // This is re-elected during paceMaker catchup
 	}
 
 	// Set the leader to be in the highest round.
-	GetConsensusModElem(pocketNodes[1]).FieldByName("Round").SetUint(uint64(leaderRound - 2))
-	GetConsensusModElem(pocketNodes[2]).FieldByName("Round").SetUint(uint64(leaderRound - 3))
-	GetConsensusModElem(pocketNodes[leaderId]).FieldByName("Round").SetUint(uint64(leaderRound))
-	GetConsensusModElem(pocketNodes[4]).FieldByName("Round").SetUint(uint64(leaderRound - 4))
+	GetConsensusModImplementation(pocketNodes[1]).FieldByName("Round").SetUint(uint64(leaderRound - 2))
+	GetConsensusModImplementation(pocketNodes[2]).FieldByName("Round").SetUint(uint64(leaderRound - 3))
+	GetConsensusModImplementation(pocketNodes[leaderId]).FieldByName("Round").SetUint(uint64(leaderRound))
+	GetConsensusModImplementation(pocketNodes[4]).FieldByName("Round").SetUint(uint64(leaderRound - 4))
 
 	prepareProposal := &typesCons.HotstuffMessage{
 		Type:          consensus.Propose,
diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 3bda5de07..4903a9abd 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -14,8 +14,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/pokt-network/pocket/shared/codec"
-
 	"github.com/benbjohnson/clock"
 	"github.com/golang/mock/gomock"
 	"github.com/pokt-network/pocket/consensus"
@@ -27,6 +25,7 @@ import (
 	modulesMock "github.com/pokt-network/pocket/shared/modules/mocks"
 	"github.com/pokt-network/pocket/shared/test_artifacts"
 	"github.com/stretchr/testify/require"
+	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/anypb"
 )
 
@@ -181,17 +180,13 @@ func StartAllTestPocketNodes(t *testing.T, pocketNodes IdToNodeMapping) {
 // define the interfaces used for debug/development. The latter will probably scale more but will
 // require more effort and pollute the source code with debugging information.
 func GetConsensusNodeState(node *shared.Node) typesCons.ConsensusNodeState {
-	return GetConsensusModImpl(node).MethodByName("GetNodeState").Call([]reflect.Value{})[0].Interface().(typesCons.ConsensusNodeState)
+	return reflect.ValueOf(node.GetBus().GetConsensusModule()).MethodByName("GetNodeState").Call([]reflect.Value{})[0].Interface().(typesCons.ConsensusNodeState)
 }
 
-func GetConsensusModElem(node *shared.Node) reflect.Value {
+func GetConsensusModImplementation(node *shared.Node) reflect.Value {
 	return reflect.ValueOf(node.GetBus().GetConsensusModule()).Elem()
 }
 
-func GetConsensusModImpl(node *shared.Node) reflect.Value {
-	return reflect.ValueOf(node.GetBus().GetConsensusModule())
-}
-
 /*** Debug/Development Message Helpers ***/
 
 func TriggerNextView(t *testing.T, node *shared.Node) {
@@ -235,12 +230,10 @@ func WaitForNetworkConsensusMessages(
 ) (messages []*anypb.Any, err error) {
 
 	includeFilter := func(m *anypb.Any) bool {
-		msg, err := codec.GetCodec().FromAny(m)
+		var hotstuffMessage typesCons.HotstuffMessage
+		err := anypb.UnmarshalTo(m, &hotstuffMessage, proto.UnmarshalOptions{})
 		require.NoError(t, err)
 
-		hotstuffMessage, ok := msg.(*typesCons.HotstuffMessage)
-		require.True(t, ok)
-
 		return hotstuffMessage.Type == hotstuffMsgType && hotstuffMessage.Step == step
 	}
 
@@ -355,7 +348,8 @@ func baseP2PMock(t *testing.T, testChannel modules.EventsChannel) *modulesMock.M
 func baseUtilityMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockUtilityModule {
 	ctrl := gomock.NewController(t)
 	utilityMock := modulesMock.NewMockUtilityModule(ctrl)
-	utilityContextMock := baseUtilityContextMock(t)
+	utilityContextMock := modulesMock.NewMockUtilityContext(ctrl)
+	persistenceContextMock := modulesMock.NewMockPersistenceRWContext(ctrl)
 
 	utilityMock.EXPECT().Start().Return(nil).AnyTimes()
 	utilityMock.EXPECT().SetBus(gomock.Any()).Do(func(modules.Bus) {}).AnyTimes()
@@ -364,14 +358,9 @@ func baseUtilityMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockUti
 		Return(utilityContextMock, nil).
 		MaxTimes(4)
 
-	return utilityMock
-}
-
-func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
-	ctrl := gomock.NewController(t)
-	utilityContextMock := modulesMock.NewMockUtilityContext(ctrl)
-	persistenceContextMock := modulesMock.NewMockPersistenceRWContext(ctrl)
-
+	utilityContextMock.EXPECT().GetPersistenceContext().Return(persistenceContextMock).AnyTimes()
+	utilityContextMock.EXPECT().CommitPersistenceContext().Return(nil).AnyTimes()
+	utilityContextMock.EXPECT().ReleaseContext().Return().AnyTimes()
 	utilityContextMock.EXPECT().
 		GetProposalTransactions(gomock.Any(), maxTxBytes, gomock.AssignableToTypeOf(emptyByzValidators)).
 		Return(make([][]byte, 0), nil).
@@ -380,15 +369,12 @@ func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 		ApplyBlock(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
 		Return(appHash, nil).
 		AnyTimes()
-	utilityContextMock.EXPECT().CommitPersistenceContext().Return(nil).AnyTimes()
-	utilityContextMock.EXPECT().ReleaseContext().Return().AnyTimes()
-	utilityContextMock.EXPECT().GetPersistenceContext().Return(persistenceContextMock).AnyTimes()
 
-	persistenceContextMock.EXPECT().StoreTransaction(gomock.Any()).Return(nil).AnyTimes()
-	persistenceContextMock.EXPECT().StoreBlock(gomock.Any()).Return(nil).AnyTimes()
+	persistenceContextMock.EXPECT().Commit().Return(nil).AnyTimes()
+	persistenceContextMock.EXPECT().StoreBlock(gomock.Any()).AnyTimes().Return(nil)
 	persistenceContextMock.EXPECT().InsertBlock(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes().Return(nil)
 
-	return utilityContextMock
+	return utilityMock
 }
 
 func baseTelemetryMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockTelemetryModule {
@@ -399,24 +385,26 @@ func baseTelemetryMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockT
 
 	telemetryMock.EXPECT().Start().Do(func() {}).AnyTimes()
 	telemetryMock.EXPECT().SetBus(gomock.Any()).Do(func(modules.Bus) {}).AnyTimes()
+
 	telemetryMock.EXPECT().GetTimeSeriesAgent().Return(timeSeriesAgentMock).AnyTimes()
+	timeSeriesAgentMock.EXPECT().CounterRegister(gomock.Any(), gomock.Any()).MaxTimes(1)
+	timeSeriesAgentMock.EXPECT().CounterIncrement(gomock.Any()).AnyTimes()
+
 	telemetryMock.EXPECT().GetEventMetricsAgent().Return(eventMetricsAgentMock).AnyTimes()
+	eventMetricsAgentMock.EXPECT().EmitEvent(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
 
 	return telemetryMock
 }
 
 func baseTelemetryTimeSeriesAgentMock(t *testing.T) *modulesMock.MockTimeSeriesAgent {
 	ctrl := gomock.NewController(t)
-	timeSeriesAgentMock := modulesMock.NewMockTimeSeriesAgent(ctrl)
-	timeSeriesAgentMock.EXPECT().CounterRegister(gomock.Any(), gomock.Any()).MaxTimes(1)
-	timeSeriesAgentMock.EXPECT().CounterIncrement(gomock.Any()).AnyTimes()
-	return timeSeriesAgentMock
+	timeseriesAgentMock := modulesMock.NewMockTimeSeriesAgent(ctrl)
+	return timeseriesAgentMock
 }
 
 func baseTelemetryEventMetricsAgentMock(t *testing.T) *modulesMock.MockEventMetricsAgent {
 	ctrl := gomock.NewController(t)
 	eventMetricsAgentMock := modulesMock.NewMockEventMetricsAgent(ctrl)
-	eventMetricsAgentMock.EXPECT().EmitEvent(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
 	return eventMetricsAgentMock
 }
 
diff --git a/consensus/debugging.go b/consensus/debugging.go
index a73dad40e..8d433db4d 100644
--- a/consensus/debugging.go
+++ b/consensus/debugging.go
@@ -3,8 +3,9 @@ package consensus
 import (
 	"log"
 
-	typesCons "github.com/pokt-network/pocket/consensus/types"
 	"github.com/pokt-network/pocket/shared/debug"
+
+	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
 
 func (m *ConsensusModule) HandleDebugMessage(debugMessage *debug.DebugMessage) error {
@@ -31,7 +32,7 @@ func (m *ConsensusModule) GetNodeState() typesCons.ConsensusNodeState {
 		leaderId = *m.LeaderId
 	}
 	return typesCons.ConsensusNodeState{
-		NodeId:   m.nodeId,
+		NodeId:   m.NodeId,
 		Height:   m.Height,
 		Round:    uint8(m.Round),
 		Step:     uint8(m.Step),
diff --git a/consensus/helpers.go b/consensus/helpers.go
index 364a9d26e..efd6dac16 100644
--- a/consensus/helpers.go
+++ b/consensus/helpers.go
@@ -1,21 +1,21 @@
 package consensus
 
-// TODO: Split this file into multiple helpers (e.g. signatures.go, hotstuff_helpers.go, etc...)
 import (
 	"encoding/base64"
 	"log"
 
-	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/debug"
 
 	"google.golang.org/protobuf/proto"
 
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 	cryptoPocket "github.com/pokt-network/pocket/shared/crypto"
+	"google.golang.org/protobuf/types/known/anypb"
 )
 
 // These constants and variables are wrappers around the autogenerated protobuf types and were
 // added to simply make the code in the `consensus` module more readable.
+
 const (
 	NewRound  = typesCons.HotstuffStep_HOTSTUFF_STEP_NEWROUND
 	Prepare   = typesCons.HotstuffStep_HOTSTUFF_STEP_PREPARE
@@ -23,36 +23,37 @@ const (
 	Commit    = typesCons.HotstuffStep_HOTSTUFF_STEP_COMMIT
 	Decide    = typesCons.HotstuffStep_HOTSTUFF_STEP_DECIDE
 
-	Propose = typesCons.HotstuffMessageType_HOTSTUFF_MESSAGE_PROPOSE
-	Vote    = typesCons.HotstuffMessageType_HOTSTUFF_MESSAGE_VOTE
-
 	ByzantineThreshold = float64(2) / float64(3)
-
-	HotstuffMessage = "consensus.HotstuffMessage"
-	UtilityMessage  = "consensus.UtilityMessage"
+	HotstuffMessage    = "consensus.HotstuffMessage"
+	UtilityMessage     = "consensus.UtilityMessage"
+	Propose            = typesCons.HotstuffMessageType_HOTSTUFF_MESAGE_PROPOSE
+	Vote               = typesCons.HotstuffMessageType_HOTSTUFF_MESSAGE_VOTE
 )
 
 var (
 	HotstuffSteps = [...]typesCons.HotstuffStep{NewRound, Prepare, PreCommit, Commit, Decide}
+
+	maxTxBytes        = 90000             // TODO(olshansky): Move this to config.json.
+	lastByzValidators = make([][]byte, 0) // TODO(olshansky): Retrieve this from persistence
 )
 
 // ** Hotstuff Helpers ** //
 
-// IMPROVE: Avoid having the `ConsensusModule` be a receiver of this; making it more functional.
-// TODO: Add unit tests for all quorumCert creation & validation logic...
 func (m *ConsensusModule) getQuorumCertificate(height uint64, step typesCons.HotstuffStep, round uint64) (*typesCons.QuorumCertificate, error) {
 	var pss []*typesCons.PartialSignature
-	for _, msg := range m.messagePool[step] {
+	for _, msg := range m.MessagePool[step] {
+		// TODO(olshansky): Add tests for this
 		if msg.GetPartialSignature() == nil {
 			m.nodeLog(typesCons.WarnMissingPartialSig(msg))
 			continue
 		}
-		if msg.GetHeight() != height || msg.GetStep() != step || msg.GetRound() != round {
+		// TODO(olshansky): Add tests for this
+		if msg.Height != height || msg.Step != step || msg.Round != round {
 			m.nodeLog(typesCons.WarnUnexpectedMessageInPool(msg, height, step, round))
 			continue
 		}
-
 		ps := msg.GetPartialSignature()
+
 		if ps.Signature == nil || len(ps.Address) == 0 {
 			m.nodeLog(typesCons.WarnIncompletePartialSig(ps, msg))
 			continue
@@ -70,16 +71,16 @@ func (m *ConsensusModule) getQuorumCertificate(height uint64, step typesCons.Hot
 	}
 
 	return &typesCons.QuorumCertificate{
-		Height:             height,
+		Height:             m.Height,
 		Step:               step,
-		Round:              round,
+		Round:              m.Round,
 		Block:              m.Block,
 		ThresholdSignature: thresholdSig,
 	}, nil
 }
 
-func (m *ConsensusModule) findHighQC(msgs []*typesCons.HotstuffMessage) (qc *typesCons.QuorumCertificate) {
-	for _, m := range msgs {
+func (m *ConsensusModule) findHighQC(step typesCons.HotstuffStep) (qc *typesCons.QuorumCertificate) {
+	for _, m := range m.MessagePool[step] {
 		if m.GetQuorumCertificate() == nil {
 			continue
 		}
@@ -90,20 +91,21 @@ func (m *ConsensusModule) findHighQC(msgs []*typesCons.HotstuffMessage) (qc *typ
 	return
 }
 
-func getThresholdSignature(partialSigs []*typesCons.PartialSignature) (*typesCons.ThresholdSignature, error) {
+func getThresholdSignature(
+	partialSigs []*typesCons.PartialSignature) (*typesCons.ThresholdSignature, error) {
 	thresholdSig := new(typesCons.ThresholdSignature)
 	thresholdSig.Signatures = make([]*typesCons.PartialSignature, len(partialSigs))
 	copy(thresholdSig.Signatures, partialSigs)
 	return thresholdSig, nil
 }
 
-func isSignatureValid(msg *typesCons.HotstuffMessage, pubKeyString string, signature []byte) bool {
+func isSignatureValid(m *typesCons.HotstuffMessage, pubKeyString string, signature []byte) bool {
 	pubKey, err := cryptoPocket.NewPublicKey(pubKeyString)
 	if err != nil {
 		log.Println("[WARN] Error getting PublicKey from bytes:", err)
 		return false
 	}
-	bytesToVerify, err := getSignableBytes(msg)
+	bytesToVerify, err := getSignableBytes(m)
 	if err != nil {
 		log.Println("[WARN] Error getting bytes to verify:", err)
 		return false
@@ -112,7 +114,7 @@ func isSignatureValid(msg *typesCons.HotstuffMessage, pubKeyString string, signa
 }
 
 func (m *ConsensusModule) didReceiveEnoughMessageForStep(step typesCons.HotstuffStep) error {
-	return m.isOptimisticThresholdMet(len(m.messagePool[step]))
+	return m.isOptimisticThresholdMet(len(m.MessagePool[step]))
 }
 
 func (m *ConsensusModule) isOptimisticThresholdMet(n int) error {
@@ -126,12 +128,12 @@ func (m *ConsensusModule) isOptimisticThresholdMet(n int) error {
 func (m *ConsensusModule) resetForNewHeight() {
 	m.Round = 0
 	m.Block = nil
-	m.highPrepareQC = nil
-	m.lockedQC = nil
+	m.HighPrepareQC = nil
+	m.LockedQC = nil
 }
 
 func protoHash(m proto.Message) string {
-	b, err := codec.GetCodec().Marshal(m)
+	b, err := proto.Marshal(m)
 	if err != nil {
 		log.Fatalf("Could not marshal proto message: %v", err)
 	}
@@ -148,12 +150,13 @@ func (m *ConsensusModule) sendToNode(msg *typesCons.HotstuffMessage) {
 	}
 
 	m.nodeLog(typesCons.SendingMessage(msg, *m.LeaderId))
-	anyConsensusMessage, err := codec.GetCodec().ToAny(msg)
+	anyConsensusMessage, err := anypb.New(msg)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateConsensusMessage.Error(), err)
 		return
 	}
-	if err := m.GetBus().GetP2PModule().Send(cryptoPocket.AddressFromString(m.idToValAddrMap[*m.LeaderId]), anyConsensusMessage, debug.PocketTopic_CONSENSUS_MESSAGE_TOPIC); err != nil {
+
+	if err := m.GetBus().GetP2PModule().Send(cryptoPocket.AddressFromString(m.IdToValAddrMap[*m.LeaderId]), anyConsensusMessage, debug.PocketTopic_CONSENSUS_MESSAGE_TOPIC); err != nil {
 		m.nodeLogError(typesCons.ErrSendMessage.Error(), err)
 		return
 	}
@@ -161,11 +164,12 @@ func (m *ConsensusModule) sendToNode(msg *typesCons.HotstuffMessage) {
 
 func (m *ConsensusModule) broadcastToNodes(msg *typesCons.HotstuffMessage) {
 	m.nodeLog(typesCons.BroadcastingMessage(msg))
-	anyConsensusMessage, err := codec.GetCodec().ToAny(msg)
+	anyConsensusMessage, err := anypb.New(msg)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateConsensusMessage.Error(), err)
 		return
 	}
+
 	if err := m.GetBus().GetP2PModule().Broadcast(anyConsensusMessage, debug.PocketTopic_CONSENSUS_MESSAGE_TOPIC); err != nil {
 		m.nodeLogError(typesCons.ErrBroadcastMessage.Error(), err)
 		return
@@ -174,10 +178,9 @@ func (m *ConsensusModule) broadcastToNodes(msg *typesCons.HotstuffMessage) {
 
 /*** Persistence Helpers ***/
 
-// TECHDEBT: Integrate this with the `persistence` module or a real mempool.
 func (m *ConsensusModule) clearMessagesPool() {
 	for _, step := range HotstuffSteps {
-		m.messagePool[step] = make([]*typesCons.HotstuffMessage, 0)
+		m.MessagePool[step] = make([]*typesCons.HotstuffMessage, 0)
 	}
 }
 
@@ -188,7 +191,7 @@ func (m *ConsensusModule) isLeaderUnknown() bool {
 }
 
 func (m *ConsensusModule) isLeader() bool {
-	return m.LeaderId != nil && *m.LeaderId == m.nodeId
+	return m.LeaderId != nil && *m.LeaderId == m.NodeId
 }
 
 func (m *ConsensusModule) isReplica() bool {
@@ -200,37 +203,33 @@ func (m *ConsensusModule) clearLeader() {
 	m.LeaderId = nil
 }
 
-func (m *ConsensusModule) electNextLeader(message *typesCons.HotstuffMessage) error {
+func (m *ConsensusModule) electNextLeader(message *typesCons.HotstuffMessage) {
 	leaderId, err := m.leaderElectionMod.ElectNextLeader(message)
 	if err != nil || leaderId == 0 {
 		m.nodeLogError(typesCons.ErrLeaderElection(message).Error(), err)
 		m.clearLeader()
-		return err
+		return
 	}
 
 	m.LeaderId = &leaderId
 
 	if m.isLeader() {
 		m.setLogPrefix("LEADER")
-		m.nodeLog(typesCons.ElectedSelfAsNewLeader(m.idToValAddrMap[*m.LeaderId], *m.LeaderId, m.Height, m.Round))
+		m.nodeLog(typesCons.ElectedSelfAsNewLeader(m.IdToValAddrMap[*m.LeaderId], *m.LeaderId, m.Height, m.Round))
 	} else {
 		m.setLogPrefix("REPLICA")
-		m.nodeLog(typesCons.ElectedNewLeader(m.idToValAddrMap[*m.LeaderId], *m.LeaderId, m.Height, m.Round))
+		m.nodeLog(typesCons.ElectedNewLeader(m.IdToValAddrMap[*m.LeaderId], *m.LeaderId, m.Height, m.Round))
 	}
-
-	return nil
 }
 
 /*** General Infrastructure Helpers ***/
 
-// TODO(#164): Remove this once we have a proper logging system.
 func (m *ConsensusModule) nodeLog(s string) {
-	log.Printf("[%s][%d] %s\n", m.logPrefix, m.nodeId, s)
+	log.Printf("[%s][%d] %s\n", m.logPrefix, m.NodeId, s)
 }
 
-// TODO(#164): Remove this once we have a proper logging system.
 func (m *ConsensusModule) nodeLogError(s string, err error) {
-	log.Printf("[ERROR][%s][%d] %s: %v\n", m.logPrefix, m.nodeId, s, err)
+	log.Printf("[ERROR][%s][%d] %s: %v\n", m.logPrefix, m.NodeId, s, err)
 }
 
 func (m *ConsensusModule) setLogPrefix(logPrefix string) {
diff --git a/consensus/hotstuff_handler.go b/consensus/hotstuff_handler.go
deleted file mode 100644
index 274a1b45b..000000000
--- a/consensus/hotstuff_handler.go
+++ /dev/null
@@ -1,55 +0,0 @@
-package consensus
-
-import (
-	typesCons "github.com/pokt-network/pocket/consensus/types"
-)
-
-// DISCUSS: Should these functions return an error?
-type HotstuffMessageHandler interface {
-	HandleNewRoundMessage(*ConsensusModule, *typesCons.HotstuffMessage)
-	HandlePrepareMessage(*ConsensusModule, *typesCons.HotstuffMessage)
-	HandlePrecommitMessage(*ConsensusModule, *typesCons.HotstuffMessage)
-	HandleCommitMessage(*ConsensusModule, *typesCons.HotstuffMessage)
-	HandleDecideMessage(*ConsensusModule, *typesCons.HotstuffMessage)
-}
-
-func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage) error {
-	m.nodeLog(typesCons.DebugHandlingHotstuffMessage(msg))
-
-	step := msg.GetStep()
-
-	// Pacemaker - Liveness & safety checks
-	if err := m.paceMaker.ValidateMessage(msg); err != nil {
-		if m.shouldLogHotstuffDiscardMessage(step) {
-			m.nodeLog(typesCons.WarnDiscardHotstuffMessage(msg, err.Error()))
-		}
-		return err
-	}
-
-	if m.shouldElectNextLeader() {
-		if err := m.electNextLeader(msg); err != nil {
-			return err
-		}
-	}
-
-	// Hotstuff - Handle message
-	if m.isReplica() {
-		replicaHandlers[step](m, msg)
-	}
-	// Note that the leader also acts as a replica, but this logic is implemented in the underlying code.
-	leaderHandlers[step](m, msg)
-
-	return nil
-}
-
-func (m *ConsensusModule) shouldElectNextLeader() bool {
-	// Execute leader election if there is no leader and we are in a new round
-	return m.Step == NewRound && m.LeaderId == nil
-}
-
-func (m *ConsensusModule) shouldLogHotstuffDiscardMessage(step typesCons.HotstuffStep) bool {
-	// If a replica is not a leader for this round, but has already determined a leader,
-	// and continues to receive NewRound messages, we avoid logging the "message discard"
-	// because it creates unnecessary spam.
-	return !(m.LeaderId != nil && !m.isLeader() && step == NewRound)
-}
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 54f41e0dd..d691ebc0c 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -1,15 +1,12 @@
 package consensus
 
 import (
-	"encoding/hex"
 	"unsafe"
 
 	consensusTelemetry "github.com/pokt-network/pocket/consensus/telemetry"
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
 
-type HotstuffLeaderMessageHandler struct{}
-
 var (
 	LeaderMessageHandler HotstuffMessageHandler = &HotstuffLeaderMessageHandler{}
 	leaderHandlers                              = map[typesCons.HotstuffStep]func(*ConsensusModule, *typesCons.HotstuffMessage){
@@ -21,39 +18,32 @@ var (
 	}
 )
 
+type HotstuffLeaderMessageHandler struct{}
+
 /*** Prepare Step ***/
 
 func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	defer m.paceMaker.RestartTimer()
 	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-
-	// DISCUSS: Do we need to pause for `MinBlockFreqMSec` here to let more transactions or should we stick with optimistic responsiveness?
-
+	// TODO(olshansky): add step specific validation
 	if err := m.didReceiveEnoughMessageForStep(NewRound); err != nil {
 		m.nodeLog(typesCons.OptimisticVoteCountWaiting(NewRound, err.Error()))
 		return
 	}
-	m.nodeLog(typesCons.OptimisticVoteCountPassed(NewRound))
 
-	// Clear the previous utility context, if it exists, and create a new one
-	if err := m.refreshUtilityContext(); err != nil {
-		m.nodeLogError("Could not refresh utility context", err)
-		return
-	}
+	// TODO(olshansky): Do we need to pause for `MinBlockFreqMSec` here to let more transactions come in?
+	m.nodeLog(typesCons.OptimisticVoteCountPassed(NewRound))
 
 	// Likely to be `nil` if blockchain is progressing well.
-	// TECHDEBT: How do we properly validate `highPrepareQC` here?
-	highPrepareQC := m.findHighQC(m.messagePool[NewRound])
+	highPrepareQC := m.findHighQC(NewRound)
 
-	// TODO: Add more unit tests for these checks...
-	if m.shouldPrepareNewBlock(highPrepareQC) {
-		// Leader prepares a new block if `highPrepareQC` is not applicable
-		block, err := m.prepareAndApplyBlock()
+	// TODO(olshansky): Add more unit tests for these checks...
+	if highPrepareQC == nil || highPrepareQC.Height < m.Height || highPrepareQC.Round < m.Round {
+		block, err := m.prepareBlockAsLeader()
 		if err != nil {
 			m.nodeLogError(typesCons.ErrPrepareBlock.Error(), err)
 			m.paceMaker.InterruptRound()
@@ -61,20 +51,15 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusM
 		}
 		m.Block = block
 	} else {
-		// DISCUSS: Do we need to call `validateProposal` here?
-		// Leader acts like a replica if `highPrepareQC` is not `nil`
-		if err := m.applyBlock(highPrepareQC.Block); err != nil {
-			m.nodeLogError(typesCons.ErrApplyBlock.Error(), err)
-			m.paceMaker.InterruptRound()
-			return
-		}
+		// TODO(discuss): Do we need to validate highPrepareQC here?
 		m.Block = highPrepareQC.Block
 	}
 
 	m.Step = Prepare
-	m.messagePool[NewRound] = nil
+	m.MessagePool[NewRound] = nil
+	m.paceMaker.RestartTimer()
 
-	prepareProposeMessage, err := CreateProposeMessage(m.Height, m.Round, Prepare, m.Block, highPrepareQC)
+	prepareProposeMessage, err := CreateProposeMessage(m, Prepare, highPrepareQC)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateProposeMessage(Prepare).Error(), err)
 		m.paceMaker.InterruptRound()
@@ -83,10 +68,10 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusM
 	m.broadcastToNodes(prepareProposeMessage)
 
 	// Leader also acts like a replica
-	prepareVoteMessage, err := CreateVoteMessage(m.Height, m.Round, Prepare, m.Block, m.privateKey)
+	prepareVoteMessage, err := CreateVoteMessage(m, Prepare, m.Block)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(Prepare).Error(), err)
-		return
+		return // TODO(olshansky): Should we interrupt the round here?
 	}
 	m.sendToNode(prepareVoteMessage)
 }
@@ -94,14 +79,13 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusM
 /*** PreCommit Step ***/
 
 func (handler *HotstuffLeaderMessageHandler) HandlePrepareMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	defer m.paceMaker.RestartTimer()
 	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-
+	// TODO(olshansky): add step specific validation
 	if err := m.didReceiveEnoughMessageForStep(Prepare); err != nil {
 		m.nodeLog(typesCons.OptimisticVoteCountWaiting(Prepare, err.Error()))
 		return
@@ -115,22 +99,23 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrepareMessage(m *ConsensusMo
 	}
 
 	m.Step = PreCommit
-	m.highPrepareQC = prepareQC
-	m.messagePool[Prepare] = nil
+	m.HighPrepareQC = prepareQC
+	m.MessagePool[Prepare] = nil
+	m.paceMaker.RestartTimer()
 
-	preCommitProposeMessage, err := CreateProposeMessage(m.Height, m.Round, PreCommit, m.Block, prepareQC)
+	precommitProposeMessages, err := CreateProposeMessage(m, PreCommit, prepareQC)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateProposeMessage(PreCommit).Error(), err)
 		m.paceMaker.InterruptRound()
 		return
 	}
-	m.broadcastToNodes(preCommitProposeMessage)
+	m.broadcastToNodes(precommitProposeMessages)
 
 	// Leader also acts like a replica
-	precommitVoteMessage, err := CreateVoteMessage(m.Height, m.Round, PreCommit, m.Block, m.privateKey)
+	precommitVoteMessage, err := CreateVoteMessage(m, PreCommit, m.Block)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(PreCommit).Error(), err)
-		return
+		return // TODO(olshansky): Should we interrupt the round here?
 	}
 	m.sendToNode(precommitVoteMessage)
 }
@@ -138,14 +123,13 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrepareMessage(m *ConsensusMo
 /*** Commit Step ***/
 
 func (handler *HotstuffLeaderMessageHandler) HandlePrecommitMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	defer m.paceMaker.RestartTimer()
 	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-
+	// TODO(olshansky): add step specific validation
 	if err := m.didReceiveEnoughMessageForStep(PreCommit); err != nil {
 		m.nodeLog(typesCons.OptimisticVoteCountWaiting(PreCommit, err.Error()))
 		return
@@ -159,10 +143,11 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrecommitMessage(m *Consensus
 	}
 
 	m.Step = Commit
-	m.lockedQC = preCommitQC
-	m.messagePool[PreCommit] = nil
+	m.LockedQC = preCommitQC
+	m.MessagePool[PreCommit] = nil
+	m.paceMaker.RestartTimer()
 
-	commitProposeMessage, err := CreateProposeMessage(m.Height, m.Round, Commit, m.Block, preCommitQC)
+	commitProposeMessage, err := CreateProposeMessage(m, Commit, preCommitQC)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateProposeMessage(Commit).Error(), err)
 		m.paceMaker.InterruptRound()
@@ -171,10 +156,10 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrecommitMessage(m *Consensus
 	m.broadcastToNodes(commitProposeMessage)
 
 	// Leader also acts like a replica
-	commitVoteMessage, err := CreateVoteMessage(m.Height, m.Round, Commit, m.Block, m.privateKey)
+	commitVoteMessage, err := CreateVoteMessage(m, Commit, m.Block)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(Commit).Error(), err)
-		return
+		return // TODO(olshansky): Should we interrupt the round here?
 	}
 	m.sendToNode(commitVoteMessage)
 }
@@ -182,14 +167,13 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrecommitMessage(m *Consensus
 /*** Decide Step ***/
 
 func (handler *HotstuffLeaderMessageHandler) HandleCommitMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	defer m.paceMaker.RestartTimer()
 	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-
+	// TODO(olshansky): add step specific validation
 	if err := m.didReceiveEnoughMessageForStep(Commit); err != nil {
 		m.nodeLog(typesCons.OptimisticVoteCountWaiting(Commit, err.Error()))
 		return
@@ -203,9 +187,10 @@ func (handler *HotstuffLeaderMessageHandler) HandleCommitMessage(m *ConsensusMod
 	}
 
 	m.Step = Decide
-	m.messagePool[Commit] = nil
+	m.MessagePool[Commit] = nil
+	m.paceMaker.RestartTimer()
 
-	decideProposeMessage, err := CreateProposeMessage(m.Height, m.Round, Decide, m.Block, commitQC)
+	decideProposeMessage, err := CreateProposeMessage(m, Decide, commitQC)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateProposeMessage(Decide).Error(), err)
 		m.paceMaker.InterruptRound()
@@ -219,7 +204,7 @@ func (handler *HotstuffLeaderMessageHandler) HandleCommitMessage(m *ConsensusMod
 		return
 	}
 
-	// There is no "replica behavior" to imitate here because the leader already committed the block proposal.
+	// There is no "replica behavior" to imitate here
 
 	m.paceMaker.NewHeight()
 	m.GetBus().
@@ -231,7 +216,6 @@ func (handler *HotstuffLeaderMessageHandler) HandleCommitMessage(m *ConsensusMod
 }
 
 func (handler *HotstuffLeaderMessageHandler) HandleDecideMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	defer m.paceMaker.RestartTimer()
 	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
@@ -242,19 +226,10 @@ func (handler *HotstuffLeaderMessageHandler) HandleDecideMessage(m *ConsensusMod
 
 // anteHandle is the general handler called for every before every specific HotstuffLeaderMessageHandler handler
 func (handler *HotstuffLeaderMessageHandler) anteHandle(m *ConsensusModule, msg *typesCons.HotstuffMessage) error {
-	// Basic block metadata validation
-
-	if err := m.validateBlockBasic(msg.GetBlock()); err != nil {
-		return err
-	}
-
-	// Discard messages with invalid partial signatures before storing it in the leader's consensus mempool
-	if err := m.validatePartialSignature(msg); err != nil {
+	if err := handler.validateBasic(m, msg); err != nil {
 		return err
 	}
-
-	// TECHDEBT: Until we integrate with the real mempool, this is a makeshift solution
-	m.tempIndexHotstuffMessage(msg)
+	m.aggregateMessage(msg)
 	return nil
 }
 
@@ -271,13 +246,22 @@ func (handler *HotstuffLeaderMessageHandler) emitTelemetryEvent(m *ConsensusModu
 		)
 }
 
+// ValidateBasic general validation checks that apply to every HotstuffLeaderMessage
+func (handler *HotstuffLeaderMessageHandler) validateBasic(m *ConsensusModule, msg *typesCons.HotstuffMessage) error {
+	// Discard messages with invalid partial signatures before storing it in the leader's consensus mempool
+	if err := m.validatePartialSignature(msg); err != nil {
+		return err
+	}
+	return nil
+}
+
 func (m *ConsensusModule) validatePartialSignature(msg *typesCons.HotstuffMessage) error {
-	if msg.GetStep() == NewRound {
+	if msg.Step == NewRound {
 		m.nodeLog(typesCons.ErrUnnecessaryPartialSigForNewRound.Error())
 		return nil
 	}
 
-	if msg.GetType() == Propose {
+	if msg.Type == Propose {
 		m.nodeLog(typesCons.ErrUnnecessaryPartialSigForLeaderProposal.Error())
 		return nil
 	}
@@ -285,100 +269,34 @@ func (m *ConsensusModule) validatePartialSignature(msg *typesCons.HotstuffMessag
 	if msg.GetPartialSignature() == nil {
 		return typesCons.ErrNilPartialSig
 	}
-	partialSig := msg.GetPartialSignature()
 
-	if partialSig.Signature == nil || len(partialSig.GetAddress()) == 0 {
+	if msg.GetPartialSignature().Signature == nil || len(msg.GetPartialSignature().Address) == 0 {
 		return typesCons.ErrNilPartialSigOrSourceNotSpecified
 	}
 
-	address := partialSig.GetAddress()
+	address := msg.GetPartialSignature().Address
 	validator, ok := m.validatorMap[address]
 	if !ok {
-		return typesCons.ErrMissingValidator(address, m.valAddrToIdMap[address])
+		return typesCons.ErrMissingValidator(address, m.ValAddrToIdMap[address])
 	}
 	pubKey := validator.GetPublicKey()
-	if isSignatureValid(msg, pubKey, partialSig.GetSignature()) {
+	if isSignatureValid(msg, pubKey, msg.GetPartialSignature().Signature) {
 		return nil
 	}
 
 	return typesCons.ErrValidatingPartialSig(
-		address, m.valAddrToIdMap[address], msg, pubKey)
+		address, m.ValAddrToIdMap[address], msg, pubKey)
 }
 
-// TODO: This is just a placeholder at the moment for indexing hotstuff messages ONLY.
-//       It doesn't actually work because SizeOf returns the size of the map pointer,
-//       and does not recursively determine the size of all the underlying elements
-//       Add proper tests and implementation once the mempool is implemented.
-func (m *ConsensusModule) tempIndexHotstuffMessage(msg *typesCons.HotstuffMessage) {
-	if m.consCfg.GetMaxMempoolBytes() < uint64(unsafe.Sizeof(m.messagePool)) {
+func (m *ConsensusModule) aggregateMessage(msg *typesCons.HotstuffMessage) {
+	// TODO(olshansky): Add proper tests for this when we figure out where the mempool should live.
+	// NOTE: This is just a placeholder at the moment. It doesn't actually work because SizeOf returns
+	// the size of the map pointer, and does not recursively determine the size of all the underlying elements.
+	if m.consCfg.GetMaxMempoolBytes() < uint64(unsafe.Sizeof(m.MessagePool)) {
 		m.nodeLogError(typesCons.DisregardHotstuffMessage, typesCons.ErrConsensusMempoolFull)
 		return
 	}
 
 	// Only the leader needs to aggregate consensus related messages.
-	step := msg.GetStep()
-	m.messagePool[step] = append(m.messagePool[step], msg)
-}
-
-// This is a helper function intended to be called by a leader/validator during a view change
-// to prepare a new block that is applied to the new underlying context.
-func (m *ConsensusModule) prepareAndApplyBlock() (*typesCons.Block, error) {
-	if m.isReplica() {
-		return nil, typesCons.ErrReplicaPrepareBlock
-	}
-
-	// TECHDEBT: Retrieve this from consensus consensus config
-	maxTxBytes := 90000
-
-	// TECHDEBT: Retrieve this from persistence
-	lastByzValidators := make([][]byte, 0)
-
-	// Reap the mempool for transactions to be applied in this block
-	txs, err := m.utilityContext.GetProposalTransactions(m.privateKey.Address(), maxTxBytes, lastByzValidators)
-	if err != nil {
-		return nil, err
-	}
-
-	// OPTIMIZE: Determine if we can avoid the `ApplyBlock` call here
-	// Apply all the transactions in the block
-	appHash, err := m.utilityContext.ApplyBlock(int64(m.Height), m.privateKey.Address(), txs, lastByzValidators)
-	if err != nil {
-		return nil, err
-	}
-
-	// Construct the block
-	blockHeader := &typesCons.BlockHeader{
-		Height:            int64(m.Height),
-		Hash:              hex.EncodeToString(appHash),
-		NumTxs:            uint32(len(txs)),
-		LastBlockHash:     m.lastAppHash,
-		ProposerAddress:   m.privateKey.Address().Bytes(),
-		QuorumCertificate: []byte("HACK: Temporary placeholder"),
-	}
-	block := &typesCons.Block{
-		BlockHeader:  blockHeader,
-		Transactions: txs,
-	}
-
-	return block, nil
-}
-
-// Return true if this node, the leader, should prepare a new block
-func (m *ConsensusModule) shouldPrepareNewBlock(highPrepareQC *typesCons.QuorumCertificate) bool {
-	if highPrepareQC == nil {
-		m.nodeLog("Preparing a new block - no highPrepareQC found")
-		return true
-	} else if m.isHighPrepareQCFromPast(highPrepareQC) {
-		m.nodeLog("Preparing a new block - highPrepareQC is from the past")
-		return true
-	} else if highPrepareQC.Block == nil {
-		m.nodeLog("[WARN] Preparing a new block - highPrepareQC SHOULD be used but block is nil")
-		return true
-	}
-	return false
-}
-
-// The `highPrepareQC` is from the past so we can safely ignore it
-func (m *ConsensusModule) isHighPrepareQCFromPast(highPrepareQC *typesCons.QuorumCertificate) bool {
-	return highPrepareQC.Height < m.Height || highPrepareQC.Round < m.Round
+	m.MessagePool[msg.Step] = append(m.MessagePool[msg.Step], msg)
 }
diff --git a/consensus/hotstuff_replica.go b/consensus/hotstuff_replica.go
index e55e85585..25041c766 100644
--- a/consensus/hotstuff_replica.go
+++ b/consensus/hotstuff_replica.go
@@ -1,11 +1,10 @@
 package consensus
 
 import (
-	"encoding/hex"
 	"fmt"
+	"log"
 
 	consensusTelemetry "github.com/pokt-network/pocket/consensus/telemetry"
-	"github.com/pokt-network/pocket/consensus/types"
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
 
@@ -25,54 +24,46 @@ var (
 /*** NewRound Step ***/
 
 func (handler *HotstuffReplicaMessageHandler) HandleNewRoundMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	defer m.paceMaker.RestartTimer()
 	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-
-	// Clear the previous utility context, if it exists, and create a new one
-	if err := m.refreshUtilityContext(); err != nil {
-		m.nodeLogError("Could not refresh utility context", err)
-		return
-	}
-
+	// TODO(olshansky): add step specific validation
+	m.paceMaker.RestartTimer()
 	m.Step = Prepare
 }
 
 /*** Prepare Step ***/
 
 func (handler *HotstuffReplicaMessageHandler) HandlePrepareMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	defer m.paceMaker.RestartTimer()
 	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-
+	// TODO(olshansky): add step specific validation
 	if err := m.validateProposal(msg); err != nil {
 		m.nodeLogError(fmt.Sprintf("Invalid proposal in %s message", Prepare), err)
 		m.paceMaker.InterruptRound()
 		return
 	}
 
-	block := msg.GetBlock()
-	if err := m.applyBlock(block); err != nil {
+	if err := m.applyBlockAsReplica(msg.Block); err != nil {
 		m.nodeLogError(typesCons.ErrApplyBlock.Error(), err)
 		m.paceMaker.InterruptRound()
 		return
 	}
-	m.Block = block
 
 	m.Step = PreCommit
+	m.paceMaker.RestartTimer()
 
-	prepareVoteMessage, err := CreateVoteMessage(m.Height, m.Round, Prepare, m.Block, m.privateKey)
+	prepareVoteMessage, err := CreateVoteMessage(m, Prepare, msg.Block)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(Prepare).Error(), err)
-		return // Not interrupting the round because liveness could continue with one failed vote
+		return // TODO(olshansky): Should we interrupt the round here?
 	}
 	m.sendToNode(prepareVoteMessage)
 }
@@ -80,28 +71,27 @@ func (handler *HotstuffReplicaMessageHandler) HandlePrepareMessage(m *ConsensusM
 /*** PreCommit Step ***/
 
 func (handler *HotstuffReplicaMessageHandler) HandlePrecommitMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	defer m.paceMaker.RestartTimer()
 	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-
-	quorumCert := msg.GetQuorumCertificate()
-	if err := m.validateQuorumCertificate(quorumCert); err != nil {
+	// TODO(olshansky): add step specific validation
+	if err := m.validateQuorumCertificate(msg.GetQuorumCertificate()); err != nil {
 		m.nodeLogError(typesCons.ErrQCInvalid(PreCommit).Error(), err)
 		m.paceMaker.InterruptRound()
 		return
 	}
 
 	m.Step = Commit
-	m.highPrepareQC = quorumCert // INVESTIGATE: Why are we never using this for validation?
+	m.HighPrepareQC = msg.GetQuorumCertificate() // TODO(discuss): Why are we never using this for validation?
+	m.paceMaker.RestartTimer()
 
-	preCommitVoteMessage, err := CreateVoteMessage(m.Height, m.Round, PreCommit, m.Block, m.privateKey)
+	preCommitVoteMessage, err := CreateVoteMessage(m, PreCommit, msg.Block)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(PreCommit).Error(), err)
-		return // Not interrupting the round because liveness could continue with one failed vote
+		return // TODO(olshansky): Should we interrupt the round here?
 	}
 	m.sendToNode(preCommitVoteMessage)
 }
@@ -109,28 +99,27 @@ func (handler *HotstuffReplicaMessageHandler) HandlePrecommitMessage(m *Consensu
 /*** Commit Step ***/
 
 func (handler *HotstuffReplicaMessageHandler) HandleCommitMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	defer m.paceMaker.RestartTimer()
 	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-
-	quorumCert := msg.GetQuorumCertificate()
-	if err := m.validateQuorumCertificate(quorumCert); err != nil {
+	// TODO(olshansky): add step specific validation
+	if err := m.validateQuorumCertificate(msg.GetQuorumCertificate()); err != nil {
 		m.nodeLogError(typesCons.ErrQCInvalid(Commit).Error(), err)
 		m.paceMaker.InterruptRound()
 		return
 	}
 
 	m.Step = Decide
-	m.lockedQC = quorumCert // DISCUSS: How does the replica recover if it's locked? Replica `formally` agrees on the QC while the rest of the network `verbally` agrees on the QC.
+	m.LockedQC = msg.GetQuorumCertificate() // TODO(discuss): How do the replica recover if it's locked? Replica `formally` agrees on the QC while the rest of the network `verbally` agrees on the QC.
+	m.paceMaker.RestartTimer()
 
-	commitVoteMessage, err := CreateVoteMessage(m.Height, m.Round, Commit, m.Block, m.privateKey)
+	commitVoteMessage, err := CreateVoteMessage(m, Commit, msg.Block)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(Commit).Error(), err)
-		return // Not interrupting the round because liveness could continue with one failed vote
+		return // TODO(olshansky): Should we interrupt the round here?
 	}
 	m.sendToNode(commitVoteMessage)
 }
@@ -138,22 +127,20 @@ func (handler *HotstuffReplicaMessageHandler) HandleCommitMessage(m *ConsensusMo
 /*** Decide Step ***/
 
 func (handler *HotstuffReplicaMessageHandler) HandleDecideMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	defer m.paceMaker.RestartTimer()
 	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-
-	quorumCert := msg.GetQuorumCertificate()
-	if err := m.validateQuorumCertificate(quorumCert); err != nil {
+	// TODO(olshansky): add step specific validation
+	if err := m.validateQuorumCertificate(msg.GetQuorumCertificate()); err != nil {
 		m.nodeLogError(typesCons.ErrQCInvalid(Decide).Error(), err)
 		m.paceMaker.InterruptRound()
 		return
 	}
 
-	if err := m.commitBlock(m.Block); err != nil {
+	if err := m.commitBlock(msg.Block); err != nil {
 		m.nodeLogError("Could not commit block", err)
 		m.paceMaker.InterruptRound()
 		return
@@ -164,11 +151,7 @@ func (handler *HotstuffReplicaMessageHandler) HandleDecideMessage(m *ConsensusMo
 
 // anteHandle is the handler called on every replica message before specific handler
 func (handler *HotstuffReplicaMessageHandler) anteHandle(m *ConsensusModule, msg *typesCons.HotstuffMessage) error {
-	// Basic block metadata validation
-	if err := m.validateBlockBasic(msg.GetBlock()); err != nil {
-		return err
-	}
-
+	log.Println("TODO: Hotstuff replica ante handle not implemented yet")
 	return nil
 }
 
@@ -186,22 +169,24 @@ func (handler *HotstuffReplicaMessageHandler) emitTelemetryEvent(m *ConsensusMod
 }
 
 func (m *ConsensusModule) validateProposal(msg *typesCons.HotstuffMessage) error {
-	// Check if node should be accepting proposals
-	if !(msg.GetType() == Propose && msg.GetStep() == Prepare) {
+	if !(msg.Type == Propose && msg.Step == Prepare) {
 		return typesCons.ErrProposalNotValidInPrepare
 	}
 
-	quorumCert := msg.GetQuorumCertificate()
-	// A nil QC implies a successful CommitQC or TimeoutQC, which have been omitted intentionally
-	// since they are not needed for consensus validity. However, if a QC is specified, it must be valid.
-	if quorumCert != nil {
-		if err := m.validateQuorumCertificate(quorumCert); err != nil {
+	if err := m.validateBlock(msg.Block); err != nil {
+		return err
+	}
+
+	// TODO(discuss): A nil QC implies a successfull CommitQC or TimeoutQC, which have been omitted intentionally since
+	// they are not needed for consensus validity. However, if a QC is specified, it must be valid.
+	if msg.GetQuorumCertificate() != nil {
+		if err := m.validateQuorumCertificate(msg.GetQuorumCertificate()); err != nil {
 			return err
 		}
 	}
 
-	lockedQC := m.lockedQC
-	justifyQC := quorumCert
+	lockedQC := m.LockedQC
+	justifyQC := msg.GetQuorumCertificate()
 
 	// Safety: not locked
 	if lockedQC == nil {
@@ -210,40 +195,20 @@ func (m *ConsensusModule) validateProposal(msg *typesCons.HotstuffMessage) error
 	}
 
 	// Safety: check the hash of the locked QC
-	// The equivalent of `lockedQC.Block.ExtendsFrom(justifyQC.Block)` in the hotstuff whitepaper is done in `applyBlock` below.
-	if protoHash(lockedQC.GetBlock()) == protoHash(justifyQC.Block) {
+	// TODO(olshansky): Extend implementation to adopt `ExtendsFrom` as described in the Hotstuff whitepaper.
+	if protoHash(lockedQC.Block) == protoHash(justifyQC.Block) { // && lockedQC.Block.ExtendsFrom(justifyQC.Block)
 		m.nodeLog(typesCons.ProposalBlockExtends)
 		return nil
 	}
 
-	// Liveness: is node locked on a QC from the past?
-	// DISCUSS: Where should additional logic be added to unlock the node?
-	if isLocked, err := isNodeLockedOnPastQC(justifyQC, lockedQC); isLocked {
-		return err
+	// Liveness: node is locked on a QC from the past. [TODO]: Do we want to set `m.LockedQC = nil` here or something else?
+	if justifyQC.Height > lockedQC.Height || (justifyQC.Height == lockedQC.Height && justifyQC.Round > lockedQC.Round) {
+		return typesCons.ErrNodeIsLockedOnPastQC
 	}
 
 	return typesCons.ErrUnhandledProposalCase
 }
 
-// This helper applies the block metadata to the utility & persistence layers
-func (m *ConsensusModule) applyBlock(block *typesCons.Block) error {
-	// TECHDEBT: Retrieve this from persistence
-	lastByzValidators := make([][]byte, 0)
-
-	// Apply all the transactions in the block and get the appHash
-	appHash, err := m.utilityContext.ApplyBlock(int64(m.Height), block.BlockHeader.ProposerAddress, block.Transactions, lastByzValidators)
-	if err != nil {
-		return err
-	}
-
-	// CONSOLIDATE: Terminology of `blockHash`, `appHash` and `stateHash`
-	if block.BlockHeader.Hash != hex.EncodeToString(appHash) {
-		return typesCons.ErrInvalidAppHash(block.BlockHeader.Hash, hex.EncodeToString(appHash))
-	}
-
-	return nil
-}
-
 func (m *ConsensusModule) validateQuorumCertificate(qc *typesCons.QuorumCertificate) error {
 	if qc == nil {
 		return typesCons.ErrNilQC
@@ -259,22 +224,21 @@ func (m *ConsensusModule) validateQuorumCertificate(qc *typesCons.QuorumCertific
 
 	msgToJustify := qcToHotstuffMessage(qc)
 	numValid := 0
-
-	// TODO(#109): Aggregate signatures once BLS or DKG is implemented
 	for _, partialSig := range qc.ThresholdSignature.Signatures {
 		validator, ok := m.validatorMap[partialSig.Address]
 		if !ok {
-			m.nodeLogError(typesCons.ErrMissingValidator(partialSig.Address, m.valAddrToIdMap[partialSig.Address]).Error(), nil)
+			m.nodeLogError(typesCons.ErrMissingValidator(partialSig.Address, m.ValAddrToIdMap[partialSig.Address]).Error(), nil)
 			continue
 		}
 		// TODO(olshansky): Every call to `IsSignatureValid` does a serialization and should be optimized. We can
 		// just serialize `Message` once and verify each signature without re-serializing every time.
 		if !isSignatureValid(msgToJustify, validator.GetPublicKey(), partialSig.Signature) {
-			m.nodeLog(typesCons.WarnInvalidPartialSigInQC(partialSig.Address, m.valAddrToIdMap[partialSig.Address]))
+			m.nodeLog(typesCons.WarnInvalidPartialSigInQC(partialSig.Address, m.ValAddrToIdMap[partialSig.Address]))
 			continue
 		}
 		numValid++
 	}
+
 	if err := m.isOptimisticThresholdMet(numValid); err != nil {
 		return err
 	}
@@ -282,23 +246,6 @@ func (m *ConsensusModule) validateQuorumCertificate(qc *typesCons.QuorumCertific
 	return nil
 }
 
-func isNodeLockedOnPastQC(justifyQC, lockedQC *types.QuorumCertificate) (bool, error) {
-	if isLockedOnPastHeight(justifyQC, lockedQC) {
-		return true, types.ErrNodeLockedPastHeight
-	} else if isLockedOnCurrHeightAndPastRound(justifyQC, lockedQC) {
-		return true, types.ErrNodeLockedPastHeight
-	}
-	return false, nil
-}
-
-func isLockedOnPastHeight(justifyQC, lockedQC *types.QuorumCertificate) bool {
-	return justifyQC.Height > lockedQC.Height
-}
-
-func isLockedOnCurrHeightAndPastRound(justifyQC, lockedQC *types.QuorumCertificate) bool {
-	return justifyQC.Height == lockedQC.Height && justifyQC.Round > lockedQC.Round
-}
-
 func qcToHotstuffMessage(qc *typesCons.QuorumCertificate) *typesCons.HotstuffMessage {
 	return &typesCons.HotstuffMessage{
 		Height: qc.Height,
diff --git a/consensus/messages.go b/consensus/messages.go
index b2a06013e..4fd09cea5 100644
--- a/consensus/messages.go
+++ b/consensus/messages.go
@@ -4,38 +4,35 @@ import (
 	"log"
 
 	typesCons "github.com/pokt-network/pocket/consensus/types"
-	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/crypto"
+	"google.golang.org/protobuf/proto"
 )
 
 func CreateProposeMessage(
-	height uint64,
-	round uint64,
-	step typesCons.HotstuffStep,
-	block *typesCons.Block,
+	m *ConsensusModule,
+	step typesCons.HotstuffStep, // step can be taken from `m` but is specified explicitly via interface to avoid ambiguity
 	qc *typesCons.QuorumCertificate,
 ) (*typesCons.HotstuffMessage, error) {
-	if block == nil {
-		return nil, typesCons.ErrNilBlockVote
+	if m.Block == nil {
+		return nil, typesCons.ErrNilBlockProposal
 	}
 
 	msg := &typesCons.HotstuffMessage{
 		Type:          Propose,
-		Height:        height,
+		Height:        m.Height,
 		Step:          step,
-		Round:         round,
-		Block:         block,
+		Round:         m.Round,
+		Block:         m.Block,
 		Justification: nil, // QC is set below if it is non-nil
 	}
 
-	// TODO: Add unit tests for this
+	// TODO(olshansky): Add unit tests for this
 	if qc == nil && step != Prepare {
 		return nil, typesCons.ErrNilQCProposal
 	}
 
-	// TODO: Add unit tests for this
-	// QC may be nil during NEWROUND if following happy hotstuff path
-	if qc != nil {
+	// TODO(olshansky): Add unit tests for this
+	if qc != nil { // QC may optionally be nil for NEWROUND steps when everything is progressing smoothly
 		msg.Justification = &typesCons.HotstuffMessage_QuorumCertificate{
 			QuorumCertificate: qc,
 		}
@@ -45,11 +42,9 @@ func CreateProposeMessage(
 }
 
 func CreateVoteMessage(
-	height uint64,
-	round uint64,
-	step typesCons.HotstuffStep,
+	m *ConsensusModule,
+	step typesCons.HotstuffStep, // step can be taken from `m` but is specified explicitly via interface to avoid ambiguity
 	block *typesCons.Block,
-	privKey crypto.PrivateKey, // used to sign the vote
 ) (*typesCons.HotstuffMessage, error) {
 	if block == nil {
 		return nil, typesCons.ErrNilBlockVote
@@ -57,50 +52,44 @@ func CreateVoteMessage(
 
 	msg := &typesCons.HotstuffMessage{
 		Type:          Vote,
-		Height:        height,
+		Height:        m.Height,
 		Step:          step,
-		Round:         round,
+		Round:         m.Round,
 		Block:         block,
 		Justification: nil, // signature is computed below
 	}
 
 	msg.Justification = &typesCons.HotstuffMessage_PartialSignature{
 		PartialSignature: &typesCons.PartialSignature{
-			Signature: getMessageSignature(msg, privKey),
-			Address:   privKey.PublicKey().Address().String(),
+			Signature: getMessageSignature(msg, m.privateKey),
+			Address:   m.privateKey.PublicKey().Address().String(),
 		},
 	}
 
 	return msg, nil
 }
 
-// Returns "partial" signature of the hotstuff message from one of the validators.
-// If there is an error signing the bytes, nil is returned instead.
-func getMessageSignature(msg *typesCons.HotstuffMessage, privKey crypto.PrivateKey) []byte {
-	bytesToSign, err := getSignableBytes(msg)
+// Returns a "partial" signature of the hotstuff message from one of the validators
+func getMessageSignature(m *typesCons.HotstuffMessage, privKey crypto.PrivateKey) []byte {
+	bytesToSign, err := getSignableBytes(m)
 	if err != nil {
-		log.Printf("[WARN] error getting bytes to sign: %v\n", err)
 		return nil
 	}
-
 	signature, err := privKey.Sign(bytesToSign)
 	if err != nil {
-		log.Printf("[WARN] error signing message: %v\n", err)
+		log.Fatalf("Error signing message: %v", err)
 		return nil
 	}
-
 	return signature
 }
 
-// Signature only over subset of fields in HotstuffMessage
-// For reference, see section 4.3 of the the hotstuff whitepaper, partial signatures are
-// computed over `tsignr(hm.type, m.viewNumber , m.nodei)`. https://arxiv.org/pdf/1803.05069.pdf
-func getSignableBytes(msg *typesCons.HotstuffMessage) ([]byte, error) {
+// Signature should only be over a subset of the fields in a HotstuffMessage
+func getSignableBytes(m *typesCons.HotstuffMessage) ([]byte, error) {
 	msgToSign := &typesCons.HotstuffMessage{
-		Height: msg.GetHeight(),
-		Step:   msg.GetStep(),
-		Round:  msg.GetRound(),
-		Block:  msg.GetBlock(),
+		Height: m.Height,
+		Step:   m.Step,
+		Round:  m.Round,
+		Block:  m.Block,
 	}
-	return codec.GetCodec().Marshal(msgToSign)
+	return proto.Marshal(msgToSign)
 }
diff --git a/consensus/module.go b/consensus/module.go
index 917cd88d4..c6e240d3d 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -9,9 +9,9 @@ import (
 
 	"github.com/pokt-network/pocket/consensus/leader_election"
 	typesCons "github.com/pokt-network/pocket/consensus/types"
-	"github.com/pokt-network/pocket/shared/codec"
 	cryptoPocket "github.com/pokt-network/pocket/shared/crypto"
 	"github.com/pokt-network/pocket/shared/test_artifacts"
+	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/anypb"
 
 	consensusTelemetry "github.com/pokt-network/pocket/consensus/telemetry"
@@ -19,7 +19,7 @@ import (
 )
 
 const (
-	DefaultLogPrefix    = "NODE" // TODO(#164): Make implicit when logging is standardized
+	DefaultLogPrefix    = "NODE" // Just a default that'll be replaced during consensus operations.
 	ConsensusModuleName = "consensus"
 )
 
@@ -28,13 +28,12 @@ var _ modules.PacemakerConfig = &typesCons.PacemakerConfig{}
 var _ modules.ConsensusConfig = &typesCons.ConsensusConfig{}
 var _ modules.ConsensusModule = &ConsensusModule{}
 
-// TODO(#256): Do not export the `ConsensusModule` struct or the fields inside of it.
+// TODO(olshansky): Any reason to make all of these attributes local only (i.e. not exposed outside the struct)?
+// TODO(olshansky): Look for a way to not externalize the `ConsensusModule` struct
 type ConsensusModule struct {
 	bus        modules.Bus
 	privateKey cryptoPocket.Ed25519PrivateKey
-
-	consCfg     *typesCons.ConsensusConfig
-	consGenesis *typesCons.ConsensusGenesisState
+	consCfg    modules.ConsensusConfig
 
 	// m is a mutex used to control synchronization when multiple goroutines are accessing the struct and its fields / properties.
 	//
@@ -47,32 +46,31 @@ type ConsensusModule struct {
 	Height uint64
 	Round  uint64
 	Step   typesCons.HotstuffStep
-	Block  *typesCons.Block // The current block being proposed / voted on; it has not been committed to finality
+	Block  *typesCons.Block // The current block being voted on prior to committing to finality
 
-	highPrepareQC *typesCons.QuorumCertificate // Highest QC for which replica voted PRECOMMIT
-	lockedQC      *typesCons.QuorumCertificate // Highest QC for which replica voted COMMIT
+	HighPrepareQC *typesCons.QuorumCertificate // Highest QC for which replica voted PRECOMMIT
+	LockedQC      *typesCons.QuorumCertificate // Highest QC for which replica voted COMMIT
 
 	// Leader Election
 	LeaderId       *typesCons.NodeId
-	nodeId         typesCons.NodeId
-	valAddrToIdMap typesCons.ValAddrToIdMap // TODO: This needs to be updated every time the ValMap is modified
-	idToValAddrMap typesCons.IdToValAddrMap // TODO: This needs to be updated every time the ValMap is modified
+	NodeId         typesCons.NodeId
+	ValAddrToIdMap typesCons.ValAddrToIdMap // TODO(design): This needs to be updated every time the ValMap is modified
+	IdToValAddrMap typesCons.IdToValAddrMap // TODO(design): This needs to be updated every time the ValMap is modified
 
 	// Consensus State
-	lastAppHash  string // TODO: Always retrieve this variable from the persistence module and simplify this struct
+	appHash      string
 	validatorMap typesCons.ValidatorMap
 
 	// Module Dependencies
-	// TODO(#283): Improve how `utilityContext` is managed
 	utilityContext    modules.UtilityContext
 	paceMaker         Pacemaker
 	leaderElectionMod leader_election.LeaderElectionModule
 
-	// DEPRECATE: Remove later when we build a shared/proper/injected logger
-	logPrefix string
-
-	// TECHDEBT: Move this over to use the txIndexer
-	messagePool map[typesCons.HotstuffStep][]*typesCons.HotstuffMessage
+	logPrefix   string                                                  // TODO(design): Remove later when we build a shared/proper/injected logger
+	MessagePool map[typesCons.HotstuffStep][]*typesCons.HotstuffMessage // TODO(design): Move this over to the persistence module or elsewhere?
+	// TODO(andrew): Explain (or remove) why have an explicit `MaxBlockBytes` if we are already storing a reference to `consCfg` above?
+	// TODO(andrew): This needs to be updated every time the utility module changes this value. It can be accessed via the "application specific bus" (mimicking the intermodule interface in ABCI)
+	MaxBlockBytes uint64
 }
 
 func Create(configPath, genesisPath string, useRandomPK bool) (modules.ConsensusModule, error) {
@@ -114,32 +112,32 @@ func Create(configPath, genesisPath string, useRandomPK bool) (modules.Consensus
 	m := &ConsensusModule{
 		bus: nil,
 
-		privateKey:  privateKey.(cryptoPocket.Ed25519PrivateKey),
-		consCfg:     cfg,
-		consGenesis: genesis,
+		privateKey: privateKey.(cryptoPocket.Ed25519PrivateKey),
+		consCfg:    cfg,
 
 		Height: 0,
 		Round:  0,
 		Step:   NewRound,
 		Block:  nil,
 
-		highPrepareQC: nil,
-		lockedQC:      nil,
+		HighPrepareQC: nil,
+		LockedQC:      nil,
 
-		nodeId:         valIdMap[address],
+		NodeId:         valIdMap[address],
 		LeaderId:       nil,
-		valAddrToIdMap: valIdMap,
-		idToValAddrMap: idValMap,
+		ValAddrToIdMap: valIdMap,
+		IdToValAddrMap: idValMap,
 
-		lastAppHash:  "",
+		appHash:      "",
 		validatorMap: valMap,
 
 		utilityContext:    nil,
 		paceMaker:         paceMaker,
 		leaderElectionMod: leaderElectionMod,
 
-		logPrefix:   DefaultLogPrefix,
-		messagePool: make(map[typesCons.HotstuffStep][]*typesCons.HotstuffMessage),
+		logPrefix:     DefaultLogPrefix,
+		MessagePool:   make(map[typesCons.HotstuffStep][]*typesCons.HotstuffMessage),
+		MaxBlockBytes: genesis.GetMaxBlockBytes(),
 	}
 
 	// TODO(olshansky): Look for a way to avoid doing this.
@@ -226,22 +224,70 @@ func (m *ConsensusModule) SetBus(pocketBus modules.Bus) {
 	m.leaderElectionMod.SetBus(pocketBus)
 }
 
+func (m *ConsensusModule) loadPersistedState() error {
+	persistenceContext, err := m.GetBus().GetPersistenceModule().NewReadContext(-1) // Unknown height
+	if err != nil {
+		return nil
+	}
+	defer persistenceContext.Close()
+
+	latestHeight, err := persistenceContext.GetLatestBlockHeight()
+	if err != nil || latestHeight == 0 {
+		m.nodeLog("TODO: State sync not implement")
+		return nil
+	}
+
+	appHash, err := persistenceContext.GetBlockHash(int64(latestHeight))
+	if err != nil {
+		return fmt.Errorf("error getting block hash for height %d even though it's in the database: %s", latestHeight, err)
+	}
+
+	// TODO: Populate the rest of the state from the persistence module: validator set, quorum cert, last block hash, etc...
+	m.Height = uint64(latestHeight) + 1 // +1 because the height of the consensus module is where it is actively participating in consensus
+	m.appHash = string(appHash)
+
+	m.nodeLog(fmt.Sprintf("Starting node at height %d", latestHeight))
+	return nil
+}
+
+// TODO(discuss): Low priority design: think of a way to make `hotstuff_*` files be a sub-package under consensus.
+// This is currently not possible because functions tied to the `ConsensusModule`
+// struct (implementing the ConsensusModule module), which spans multiple files.
+/*
+TODO(discuss): The reason we do not assign both the leader and the replica handlers
+to the leader (which should also act as a replica when it is a leader) is because it
+can create a weird inconsistent state (e.g. both the replica and leader try to restart
+the Pacemaker timeout). This requires additional "replica-like" logic in the leader
+handler which has both pros and cons:
+	Pros:
+		* The leader can short-circuit and optimize replica related logic
+		* Avoids additional code flowing through the P2P pipeline
+		* Allows for micro-optimizations
+	Cons:
+		* The leader's "replica related logic" requires an additional code path
+		* Code is less "generalizable" and therefore potentially more error prone
+*/
+
+// TODO(olshansky): Should we just make these singletons or embed them directly in the ConsensusModule?
+type HotstuffMessageHandler interface {
+	HandleNewRoundMessage(*ConsensusModule, *typesCons.HotstuffMessage)
+	HandlePrepareMessage(*ConsensusModule, *typesCons.HotstuffMessage)
+	HandlePrecommitMessage(*ConsensusModule, *typesCons.HotstuffMessage)
+	HandleCommitMessage(*ConsensusModule, *typesCons.HotstuffMessage)
+	HandleDecideMessage(*ConsensusModule, *typesCons.HotstuffMessage)
+}
+
 func (m *ConsensusModule) HandleMessage(message *anypb.Any) error {
 	m.m.Lock()
 	defer m.m.Unlock()
 	switch message.MessageName() {
 	case HotstuffMessage:
-		msg, err := codec.GetCodec().FromAny(message)
+		var hotstuffMessage typesCons.HotstuffMessage
+		err := anypb.UnmarshalTo(message, &hotstuffMessage, proto.UnmarshalOptions{})
 		if err != nil {
 			return err
 		}
-		hotstuffMessage, ok := msg.(*typesCons.HotstuffMessage)
-		if !ok {
-			return fmt.Errorf("failed to cast message to HotstuffMessage")
-		}
-		if err := m.handleHotstuffMessage(hotstuffMessage); err != nil {
-			return err
-		}
+		m.handleHotstuffMessage(&hotstuffMessage)
 	case UtilityMessage:
 		panic("[WARN] UtilityMessage handling is not implemented by consensus yet...")
 	default:
@@ -251,8 +297,36 @@ func (m *ConsensusModule) HandleMessage(message *anypb.Any) error {
 	return nil
 }
 
+func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage) {
+	m.nodeLog(typesCons.DebugHandlingHotstuffMessage(msg))
+
+	// Liveness & safety checks
+	if err := m.paceMaker.ValidateMessage(msg); err != nil {
+		// If a replica is not a leader for this round, but has already determined a leader,
+		// and continues to receive NewRound messages, we avoid logging the "message discard"
+		// because it creates unnecessary spam.
+		if !(m.LeaderId != nil && !m.isLeader() && msg.Step == NewRound) {
+			m.nodeLog(typesCons.WarnDiscardHotstuffMessage(msg, err.Error()))
+		}
+		return
+	}
+
+	// Need to execute leader election if there is no leader and we are in a new round.
+	if m.Step == NewRound && m.isLeaderUnknown() {
+		m.electNextLeader(msg)
+	}
+
+	if m.isReplica() {
+		replicaHandlers[msg.Step](m, msg)
+		return
+	}
+
+	// Note that the leader also acts as a replica, but this logic is implemented in the underlying code.
+	leaderHandlers[msg.Step](m, msg)
+}
+
 func (m *ConsensusModule) AppHash() string {
-	return m.lastAppHash
+	return m.appHash
 }
 
 func (m *ConsensusModule) CurrentHeight() uint64 {
@@ -262,34 +336,3 @@ func (m *ConsensusModule) CurrentHeight() uint64 {
 func (m *ConsensusModule) ValidatorMap() modules.ValidatorMap {
 	return typesCons.ValidatorMapToModulesValidatorMap(m.validatorMap)
 }
-
-// TODO(#256): Currently only used for testing purposes
-func (m *ConsensusModule) SetUtilityContext(utilityContext modules.UtilityContext) {
-	m.utilityContext = utilityContext
-}
-
-// TODO: Populate the entire state from the persistence module: validator set, quorum cert, last block hash, etc...
-func (m *ConsensusModule) loadPersistedState() error {
-	persistenceContext, err := m.GetBus().GetPersistenceModule().NewReadContext(-1) // Unknown height
-	if err != nil {
-		return nil
-	}
-	defer persistenceContext.Close()
-
-	latestHeight, err := persistenceContext.GetLatestBlockHeight()
-	if err != nil || latestHeight == 0 {
-		m.nodeLog("TODO: State sync not implemented yet")
-		return nil
-	}
-
-	appHash, err := persistenceContext.GetBlockHash(int64(latestHeight))
-	if err != nil {
-		return fmt.Errorf("error getting block hash for height %d even though it's in the database: %s", latestHeight, err)
-	}
-
-	m.Height = uint64(latestHeight) + 1 // +1 because the height of the consensus module is where it is actively participating in consensus
-	m.lastAppHash = string(appHash)
-
-	m.nodeLog(fmt.Sprintf("Starting node at height %d", latestHeight))
-	return nil
-}
diff --git a/consensus/pacemaker.go b/consensus/pacemaker.go
index ba4202897..21abdbdab 100644
--- a/consensus/pacemaker.go
+++ b/consensus/pacemaker.go
@@ -183,7 +183,7 @@ func (p *paceMaker) InterruptRound() {
 	p.consensusMod.nodeLog(typesCons.PacemakerInterrupt(p.consensusMod.CurrentHeight(), p.consensusMod.Step, p.consensusMod.Round))
 
 	p.consensusMod.Round++
-	p.startNextView(p.consensusMod.highPrepareQC, false)
+	p.startNextView(p.consensusMod.HighPrepareQC, false)
 }
 
 func (p *paceMaker) NewHeight() {
diff --git a/consensus/types/errors.go b/consensus/types/errors.go
index 5368ee1bf..e3f4d3987 100644
--- a/consensus/types/errors.go
+++ b/consensus/types/errors.go
@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/pokt-network/pocket/shared/codec"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -72,11 +71,11 @@ func ElectedSelfAsNewLeader(address string, nodeId NodeId, height, round uint64)
 }
 
 func SendingMessage(msg *HotstuffMessage, nodeId NodeId) string {
-	return fmt.Sprintf("Sending %s message to %d", StepToString[msg.GetStep()], nodeId)
+	return fmt.Sprintf("Sending %s message to %d", StepToString[msg.Step], nodeId)
 }
 
 func BroadcastingMessage(msg *HotstuffMessage) string {
-	return fmt.Sprintf("Broadcasting message for %s step", StepToString[msg.GetStep()])
+	return fmt.Sprintf("Broadcasting message for %s step", StepToString[msg.Step])
 }
 
 func WarnInvalidPartialSigInQC(address string, nodeId NodeId) string {
@@ -84,7 +83,7 @@ func WarnInvalidPartialSigInQC(address string, nodeId NodeId) string {
 }
 
 func WarnMissingPartialSig(msg *HotstuffMessage) string {
-	return fmt.Sprintf("[WARN] No partial signature found for step %s which should not happen...", StepToString[msg.GetStep()])
+	return fmt.Sprintf("[WARN] No partial signature found for step %s which should not happen...", StepToString[msg.Step])
 }
 
 func WarnDiscardHotstuffMessage(_ *HotstuffMessage, reason string) string {
@@ -96,7 +95,7 @@ func WarnUnexpectedMessageInPool(_ *HotstuffMessage, height uint64, step Hotstuf
 }
 
 func WarnIncompletePartialSig(ps *PartialSignature, msg *HotstuffMessage) string {
-	return fmt.Sprintf("[WARN] Partial signature is incomplete for step %s which should not happen...", StepToString[msg.GetStep()])
+	return fmt.Sprintf("[WARN] Partial signature is incomplete for step %s which should not happen...", StepToString[msg.Step])
 }
 
 func DebugTogglePacemakerManualMode(mode string) string {
@@ -109,13 +108,12 @@ func DebugNodeState(state ConsensusNodeState) string {
 
 func DebugHandlingHotstuffMessage(msg *HotstuffMessage) string {
 	// TODO(olshansky): Add source and destination NodeId of message here
-	return fmt.Sprintf("[DEBUG] Handling message w/ Height: %d; Type: %s; Round: %d.", msg.Height, StepToString[msg.GetStep()], msg.Round)
+	return fmt.Sprintf("[DEBUG] Handling message w/ Height: %d; Type: %s; Round: %d.", msg.Height, StepToString[msg.Step], msg.Round)
 }
 
 // Errors
 const (
 	nilBLockError                               = "block is nil"
-	blockExistsError                            = "block exists but should be nil"
 	nilBLockProposalError                       = "block should never be nil when creating a proposal message"
 	nilBLockVoteError                           = "block should never be nil when creating a vote message for a proposal"
 	proposalNotValidInPrepareError              = "proposal is not valid in the PREPARE step"
@@ -124,8 +122,7 @@ const (
 	nilBlockInQCError                           = "QC must contain a non nil block"
 	nilThresholdSigInQCError                    = "QC must contains a non nil threshold signature"
 	notEnoughSignaturesError                    = "did not receive enough partial signature"
-	nodeIsLockedOnPastHeightQCError             = "node is locked on a QC from a past height"
-	nodeIsLockedOnPastRoundQCError              = "node is locked on a QC from a past round"
+	nodeIsLockedOnPastQCError                   = "node is locked on a QC from the past"
 	unhandledProposalCaseError                  = "unhandled proposal validation check"
 	unnecessaryPartialSigForNewRoundError       = "newRound messages do not need a partial signature"
 	unnecessaryPartialSigForLeaderProposalError = "leader proposals do not need a partial signature"
@@ -145,6 +142,7 @@ const (
 	prepareBlockError                           = "could not prepare block"
 	commitBlockError                            = "could not commit block"
 	replicaPrepareBlockError                    = "node should not call `prepareBlock` if it is not a leader"
+	leaderErrApplyBlock                         = "node should not call `applyBlock` if it is leader"
 	blockSizeTooLargeError                      = "block size is too large"
 	sendMessageError                            = "error sending message"
 	broadcastMessageError                       = "error broadcasting message"
@@ -155,7 +153,6 @@ const (
 
 var (
 	ErrNilBlock                               = errors.New(nilBLockError)
-	ErrBlockExists                            = errors.New(blockExistsError)
 	ErrNilBlockProposal                       = errors.New(nilBLockProposalError)
 	ErrNilBlockVote                           = errors.New(nilBLockVoteError)
 	ErrProposalNotValidInPrepare              = errors.New(proposalNotValidInPrepareError)
@@ -164,8 +161,7 @@ var (
 	ErrNilBlockInQC                           = errors.New(nilBlockInQCError)
 	ErrNilThresholdSigInQC                    = errors.New(nilThresholdSigInQCError)
 	ErrNotEnoughSignatures                    = errors.New(notEnoughSignaturesError)
-	ErrNodeLockedPastHeight                   = errors.New(nodeIsLockedOnPastHeightQCError)
-	ErrNodeLockedPastRound                    = errors.New(nodeIsLockedOnPastRoundQCError)
+	ErrNodeIsLockedOnPastQC                   = errors.New(nodeIsLockedOnPastQCError)
 	ErrUnhandledProposalCase                  = errors.New(unhandledProposalCaseError)
 	ErrUnnecessaryPartialSigForNewRound       = errors.New(unnecessaryPartialSigForNewRoundError)
 	ErrUnnecessaryPartialSigForLeaderProposal = errors.New(unnecessaryPartialSigForLeaderProposalError)
@@ -181,6 +177,7 @@ var (
 	ErrPrepareBlock                           = errors.New(prepareBlockError)
 	ErrCommitBlock                            = errors.New(commitBlockError)
 	ErrReplicaPrepareBlock                    = errors.New(replicaPrepareBlockError)
+	ErrLeaderApplyBLock                       = errors.New(leaderErrApplyBlock)
 	ErrSendMessage                            = errors.New(sendMessageError)
 	ErrBroadcastMessage                       = errors.New(broadcastMessageError)
 	ErrCreateConsensusMessage                 = errors.New(createConsensusMessageError)
@@ -206,7 +203,7 @@ func ErrMissingValidator(address string, nodeId NodeId) error {
 
 func ErrValidatingPartialSig(senderAddr string, senderNodeId NodeId, msg *HotstuffMessage, pubKey string) error {
 	return fmt.Errorf("%s: Sender: %s (%d); Height: %d; Step: %s; Round: %d; SigHash: %s; BlockHash: %s; PubKey: %s",
-		invalidPartialSignatureError, senderAddr, senderNodeId, msg.Height, StepToString[msg.GetStep()], msg.Round, string(msg.GetPartialSignature().Signature), protoHash(msg.Block), pubKey)
+		invalidPartialSignatureError, senderAddr, senderNodeId, msg.Height, StepToString[msg.Step], msg.Round, string(msg.GetPartialSignature().Signature), protoHash(msg.Block), pubKey)
 }
 
 func ErrPacemakerUnexpectedMessageHeight(err error, heightCurrent, heightMessage uint64) error {
@@ -214,7 +211,7 @@ func ErrPacemakerUnexpectedMessageHeight(err error, heightCurrent, heightMessage
 }
 
 func ErrPacemakerUnexpectedMessageStepRound(err error, step HotstuffStep, round uint64, msg *HotstuffMessage) error {
-	return fmt.Errorf("%s: Current (step, round): (%s, %d); Message (step, round): (%s, %d)", err, StepToString[step], round, StepToString[msg.GetStep()], msg.Round)
+	return fmt.Errorf("%s: Current (step, round): (%s, %d); Message (step, round): (%s, %d)", err, StepToString[step], round, StepToString[msg.Step], msg.Round)
 }
 
 func ErrUnknownConsensusMessageType(msg interface{}) error {
@@ -238,7 +235,7 @@ func ErrLeaderElection(msg *HotstuffMessage) error {
 }
 
 func protoHash(m proto.Message) string {
-	b, err := codec.GetCodec().Marshal(m)
+	b, err := proto.Marshal(m)
 	if err != nil {
 		log.Fatalf("Could not marshal proto message: %v", err)
 	}
diff --git a/consensus/types/proto/block.proto b/consensus/types/proto/block.proto
index b18d8dfa7..6024bcea4 100644
--- a/consensus/types/proto/block.proto
+++ b/consensus/types/proto/block.proto
@@ -5,7 +5,7 @@ option go_package = "github.com/pokt-network/pocket/consensus/types";
 
 import "google/protobuf/timestamp.proto";
 
-// TECHDEBT: Re-evaluate some tendermint legacy fields
+// TODO (Team) Discuss all tendermint legacy
 message BlockHeader {
   int64 height = 1;
   string hash = 2;
diff --git a/consensus/types/proto/hotstuff_types.proto b/consensus/types/proto/hotstuff_types.proto
index c289694c8..b1f7c9b4d 100644
--- a/consensus/types/proto/hotstuff_types.proto
+++ b/consensus/types/proto/hotstuff_types.proto
@@ -18,7 +18,7 @@ enum HotstuffStep {
 
 enum HotstuffMessageType {
     HOTSTUFF_MESSAGE_UNKNOWN = 0;
-    HOTSTUFF_MESSAGE_PROPOSE = 1;
+    HOTSTUFF_MESAGE_PROPOSE = 1;
     HOTSTUFF_MESSAGE_VOTE = 2;
 }
 
diff --git a/consensus/types/types.go b/consensus/types/types.go
index 86b9a0624..36896cfaf 100644
--- a/consensus/types/types.go
+++ b/consensus/types/types.go
@@ -1,10 +1,8 @@
 package types
 
-// TODO: Split this file into multiple types files.
 import (
-	"sort"
-
 	"github.com/pokt-network/pocket/shared/modules"
+	"sort"
 )
 
 type NodeId uint64
diff --git a/shared/codec/codec.go b/shared/codec/codec.go
index a41fe2e0b..ac7765673 100644
--- a/shared/codec/codec.go
+++ b/shared/codec/codec.go
@@ -5,8 +5,6 @@ import (
 	"google.golang.org/protobuf/types/known/anypb"
 )
 
-// TODO: Use generics in place of `proto.Message` in the interface below
-//       so every caller does not need to do in place casting.
 type Codec interface { // TODO (Team) move to shared. Possibly rename
 	Marshal(proto.Message) ([]byte, error)
 	Unmarshal([]byte, proto.Message) error
@@ -16,8 +14,6 @@ type Codec interface { // TODO (Team) move to shared. Possibly rename
 
 var _ Codec = &ProtoCodec{}
 
-// TODO: Need to define a type like `type ProtoAny anypb.Any` so that we are
-//       mixing protobufs and a centralized codec structure throughout the codebase.
 type ProtoCodec struct{}
 
 func (p *ProtoCodec) Marshal(message proto.Message) ([]byte, error) {
diff --git a/shared/modules/consensus_module.go b/shared/modules/consensus_module.go
index 62a87c368..c6c6213ed 100644
--- a/shared/modules/consensus_module.go
+++ b/shared/modules/consensus_module.go
@@ -7,8 +7,7 @@ import (
 	"google.golang.org/protobuf/types/known/anypb"
 )
 
-// TODO(olshansky): deprecate ValidatorMap or populate from persistence module
-type ValidatorMap map[string]Actor
+type ValidatorMap map[string]Actor // TODO (Drewsky) deprecate Validator map or populate from persistence module
 
 // NOTE: Consensus is the core of the replicated state machine and is driven by various asynchronous events.
 // Consider adding a mutex lock to your implementation that is acquired at the beginning of each entrypoint/function implemented in this interface.
@@ -16,11 +15,11 @@ type ValidatorMap map[string]Actor
 type ConsensusModule interface {
 	Module
 
-	// Consensus Engine Handlers
+	// Consensus Engine
 	HandleMessage(*anypb.Any) error
 	HandleDebugMessage(*debug.DebugMessage) error
 
-	// Consensus State Accessors
+	// Consensus State
 	CurrentHeight() uint64
 	AppHash() string            // DISCUSS: Why not call this a BlockHash or StateHash? Should it be a []byte or string?
 	ValidatorMap() ValidatorMap // TODO: This needs to be dynamically updated during various operations and network changes.
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index 9379f6362..5f4a6718c 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -3,19 +3,21 @@ package modules
 //go:generate mockgen -source=$GOFILE -destination=./mocks/persistence_module_mock.go -aux_files=github.com/pokt-network/pocket/shared/modules=module.go
 
 import (
-	"github.com/pokt-network/pocket/persistence/kvstore" // Should be moved to shared
+	"github.com/pokt-network/pocket/persistence/kvstore"
 	"github.com/pokt-network/pocket/shared/debug"
 )
 
 type PersistenceModule interface {
 	Module
-
-	// Context interface
 	NewRWContext(height int64) (PersistenceRWContext, error)
 	NewReadContext(height int64) (PersistenceReadContext, error)
-	ReleaseWriteContext() error // Only one write context can exist at a time
 
-	// BlockStore interface
+	// TODO(drewsky): Make this a context function only and do not expose it at the module level.
+	//                The reason `Olshansky` originally made it a module level function is because
+	//                the module was responsible for maintaining a single write context and assuring
+	//                that a second can't be created (or a previous one is cleaned up) but there is
+	//                likely a better and cleaner approach that simplifies the interface.
+	ResetContext() error
 	GetBlockStore() kvstore.KVStore
 
 	// Debugging / development only
@@ -36,31 +38,40 @@ type PersistenceRWContext interface {
 	PersistenceWriteContext
 }
 
-// TODO (andrew) convert address and public key to string not bytes #149
-// TODO: Simplify the interface (reference - https://dave.cheney.net/practical-go/presentations/gophercon-israel.html#_prefer_single_method_interfaces)
-// - Add general purpose methods such as `ActorOperation(enum_actor_type, ...)` which can be use like so: `Insert(FISHERMAN, ...)`
-// - Use general purpose parameter methods such as `Set(enum_gov_type, ...)` such as `Set(STAKING_ADJUSTMENT, ...)`
-
 // NOTE: There's not really a use case for a write only interface,
-//       but it abstracts and contrasts nicely against the read only context
+// but it abstracts and contrasts nicely against the read only context
+// TODO (andrew) convert address and public key to string not bytes #149
 type PersistenceWriteContext interface {
+	// TODO: Simplify the interface (reference - https://dave.cheney.net/practical-go/presentations/gophercon-israel.html#_prefer_single_method_interfaces)
+	// - Add general purpose methods such as `ActorOperation(enum_actor_type, ...)` which can be use like so: `Insert(FISHERMAN, ...)`
+	// - Use general purpose parameter methods such as `Set(enum_gov_type, ...)` such as `Set(STAKING_ADJUSTMENT, ...)`
 	// Context Operations
 	NewSavePoint([]byte) error
 	RollbackToSavePoint([]byte) error
 
+	Reset() error
+	Commit() error
 	Release() error
 
-	// Block / indexer operations
-	UpdateAppHash() ([]byte, error)
-	// Commits the current context (height, hash, transactions, etc...) to finality.
-	Commit(proposerAddr []byte, quorumCert []byte) error
-	// Indexes the transaction
-	StoreTransaction(transactionProtoBytes []byte) error // Stores a transaction
+	AppHash() ([]byte, error)
+
+	// Block Operations
+
+	// Indexer Operations
+	StoreTransaction(transactionProtoBytes []byte) error
+
+	// Block Operations
+	// TODO_TEMPORARY: Including two functions for the SQL and KV Store as an interim solution
+	//                 until we include the schema as part of the SQL Store because persistence
+	//                 currently has no access to the protobuf schema which is the source of truth.
+	StoreBlock(blockProtoBytes []byte) error                                              // Store the block in the KV Store
+	InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error // Writes the block in the SQL database
 
 	// Pool Operations
 	AddPoolAmount(name string, amount string) error
 	SubtractPoolAmount(name string, amount string) error
 	SetPoolAmount(name string, amount string) error
+
 	InsertPool(name string, address []byte, amount string) error // TODO (Andrew) remove address from pool #149
 
 	// Account Operations
@@ -102,6 +113,8 @@ type PersistenceWriteContext interface {
 	SetValidatorPauseHeightAndMissedBlocks(address []byte, pauseHeight int64, missedBlocks int) error
 	SetValidatorMissedBlocks(address []byte, missedBlocks int) error
 
+	/* TODO(olshansky): review/revisit this in more details */
+
 	// Param Operations
 	InitParams() error
 	SetParam(paramName string, value interface{}) error
@@ -176,6 +189,8 @@ type PersistenceReadContext interface {
 	GetValidatorOutputAddress(operator []byte, height int64) (output []byte, err error)
 	GetValidatorMissedBlocks(address []byte, height int64) (int, error)
 
+	/* TODO(olshansky): review/revisit this in more details */
+
 	// Params
 	GetIntParam(paramName string, height int64) (int, error)
 	GetStringParam(paramName string, height int64) (string, error)
diff --git a/shared/modules/utility_module.go b/shared/modules/utility_module.go
index 37729fba1..edfbc94ee 100644
--- a/shared/modules/utility_module.go
+++ b/shared/modules/utility_module.go
@@ -14,15 +14,13 @@ type UtilityModule interface {
 // operations.
 type UtilityContext interface {
 	// Block operations
-
-	// Reaps the mempool for transactions that are ready to be proposed in a new block
 	GetProposalTransactions(proposer []byte, maxTransactionBytes int, lastBlockByzantineValidators [][]byte) (transactions [][]byte, err error)
-	// Applies the transactions to an ephemeral state in the utility & underlying persistence context;similar to `SafeNode` in the Hotstuff whitepaper.
 	ApplyBlock(height int64, proposer []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) (appHash []byte, err error)
 
 	// Context operations
-	Release() error
-	Commit(quorumCert []byte) error
+	ReleaseContext()
+	GetPersistenceContext() PersistenceRWContext
+	CommitPersistenceContext() error
 
 	// Validation operations
 	CheckTransaction(tx []byte) error
diff --git a/shared/test_artifacts/generator.go b/shared/test_artifacts/generator.go
index a48fbc7a3..6d6923d32 100644
--- a/shared/test_artifacts/generator.go
+++ b/shared/test_artifacts/generator.go
@@ -2,12 +2,11 @@ package test_artifacts
 
 import (
 	"fmt"
-	"math/big"
-	"strconv"
-
 	typesPersistence "github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 	"github.com/pokt-network/pocket/utility/types"
+	"math/big"
+	"strconv"
 
 	"github.com/pokt-network/pocket/shared/crypto"
 	"google.golang.org/protobuf/types/known/timestamppb"

From 66bd48390cd63a3547776edeea00881824c6afc2 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 4 Oct 2022 17:37:18 -0700
Subject: [PATCH 062/227] Updated base to main for simplicity

---
 shared/docs/flows/AppHash.md         | 35 ++------------------
 shared/modules/persistence_module.go | 49 ++++++++++------------------
 shared/modules/utility_module.go     |  8 +++--
 3 files changed, 24 insertions(+), 68 deletions(-)

diff --git a/shared/docs/flows/AppHash.md b/shared/docs/flows/AppHash.md
index 61b3eb79b..f905328fa 100644
--- a/shared/docs/flows/AppHash.md
+++ b/shared/docs/flows/AppHash.md
@@ -1,37 +1,6 @@
 # AppHash
 
-## Context Initialization
-
-```mermaid
-sequenceDiagram
-    %% autonumber
-    participant N as Node
-    participant C as Consensus
-    participant U as Utility
-    participant P as Persistence
-    participant PP as Persistence (PostgresDB)
-    participant PM as Persistence (MerkleTree)
-    participant P2P as P2P
-
-    %% Should this be P2P?
-    N-->>C: HandleMessage(anypb.Any)
-    critical NewRound Message
-        C->>+U: NewContext(height)
-        U->>P: NewRWContext(height)
-        P->>U: PersistenceRWContext
-        U->>U: Store persistenceContext
-        U->>-C: UtilityContext
-        C->>C: Store utilityContext
-        Note over C, PM: See 'Block Application'
-    end
-    Note over N, P2P: Hotstuff lifecycle
-    N-->>C: HandleMessage(anypb.Any)
-    critical Decide Message
-        Note over C, PM: See 'Block Commit'
-    end
-```
-
-### Block Application
+## Block Application
 
 ```mermaid
 sequenceDiagram
@@ -74,7 +43,7 @@ sequenceDiagram
     end
 ```
 
-### Block Commit
+## Block Commit
 
 ```mermaid
 sequenceDiagram
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index 5f4a6718c..9379f6362 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -3,21 +3,19 @@ package modules
 //go:generate mockgen -source=$GOFILE -destination=./mocks/persistence_module_mock.go -aux_files=github.com/pokt-network/pocket/shared/modules=module.go
 
 import (
-	"github.com/pokt-network/pocket/persistence/kvstore"
+	"github.com/pokt-network/pocket/persistence/kvstore" // Should be moved to shared
 	"github.com/pokt-network/pocket/shared/debug"
 )
 
 type PersistenceModule interface {
 	Module
+
+	// Context interface
 	NewRWContext(height int64) (PersistenceRWContext, error)
 	NewReadContext(height int64) (PersistenceReadContext, error)
+	ReleaseWriteContext() error // Only one write context can exist at a time
 
-	// TODO(drewsky): Make this a context function only and do not expose it at the module level.
-	//                The reason `Olshansky` originally made it a module level function is because
-	//                the module was responsible for maintaining a single write context and assuring
-	//                that a second can't be created (or a previous one is cleaned up) but there is
-	//                likely a better and cleaner approach that simplifies the interface.
-	ResetContext() error
+	// BlockStore interface
 	GetBlockStore() kvstore.KVStore
 
 	// Debugging / development only
@@ -38,40 +36,31 @@ type PersistenceRWContext interface {
 	PersistenceWriteContext
 }
 
-// NOTE: There's not really a use case for a write only interface,
-// but it abstracts and contrasts nicely against the read only context
 // TODO (andrew) convert address and public key to string not bytes #149
+// TODO: Simplify the interface (reference - https://dave.cheney.net/practical-go/presentations/gophercon-israel.html#_prefer_single_method_interfaces)
+// - Add general purpose methods such as `ActorOperation(enum_actor_type, ...)` which can be use like so: `Insert(FISHERMAN, ...)`
+// - Use general purpose parameter methods such as `Set(enum_gov_type, ...)` such as `Set(STAKING_ADJUSTMENT, ...)`
+
+// NOTE: There's not really a use case for a write only interface,
+//       but it abstracts and contrasts nicely against the read only context
 type PersistenceWriteContext interface {
-	// TODO: Simplify the interface (reference - https://dave.cheney.net/practical-go/presentations/gophercon-israel.html#_prefer_single_method_interfaces)
-	// - Add general purpose methods such as `ActorOperation(enum_actor_type, ...)` which can be use like so: `Insert(FISHERMAN, ...)`
-	// - Use general purpose parameter methods such as `Set(enum_gov_type, ...)` such as `Set(STAKING_ADJUSTMENT, ...)`
 	// Context Operations
 	NewSavePoint([]byte) error
 	RollbackToSavePoint([]byte) error
 
-	Reset() error
-	Commit() error
 	Release() error
 
-	AppHash() ([]byte, error)
-
-	// Block Operations
-
-	// Indexer Operations
-	StoreTransaction(transactionProtoBytes []byte) error
-
-	// Block Operations
-	// TODO_TEMPORARY: Including two functions for the SQL and KV Store as an interim solution
-	//                 until we include the schema as part of the SQL Store because persistence
-	//                 currently has no access to the protobuf schema which is the source of truth.
-	StoreBlock(blockProtoBytes []byte) error                                              // Store the block in the KV Store
-	InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error // Writes the block in the SQL database
+	// Block / indexer operations
+	UpdateAppHash() ([]byte, error)
+	// Commits the current context (height, hash, transactions, etc...) to finality.
+	Commit(proposerAddr []byte, quorumCert []byte) error
+	// Indexes the transaction
+	StoreTransaction(transactionProtoBytes []byte) error // Stores a transaction
 
 	// Pool Operations
 	AddPoolAmount(name string, amount string) error
 	SubtractPoolAmount(name string, amount string) error
 	SetPoolAmount(name string, amount string) error
-
 	InsertPool(name string, address []byte, amount string) error // TODO (Andrew) remove address from pool #149
 
 	// Account Operations
@@ -113,8 +102,6 @@ type PersistenceWriteContext interface {
 	SetValidatorPauseHeightAndMissedBlocks(address []byte, pauseHeight int64, missedBlocks int) error
 	SetValidatorMissedBlocks(address []byte, missedBlocks int) error
 
-	/* TODO(olshansky): review/revisit this in more details */
-
 	// Param Operations
 	InitParams() error
 	SetParam(paramName string, value interface{}) error
@@ -189,8 +176,6 @@ type PersistenceReadContext interface {
 	GetValidatorOutputAddress(operator []byte, height int64) (output []byte, err error)
 	GetValidatorMissedBlocks(address []byte, height int64) (int, error)
 
-	/* TODO(olshansky): review/revisit this in more details */
-
 	// Params
 	GetIntParam(paramName string, height int64) (int, error)
 	GetStringParam(paramName string, height int64) (string, error)
diff --git a/shared/modules/utility_module.go b/shared/modules/utility_module.go
index edfbc94ee..37729fba1 100644
--- a/shared/modules/utility_module.go
+++ b/shared/modules/utility_module.go
@@ -14,13 +14,15 @@ type UtilityModule interface {
 // operations.
 type UtilityContext interface {
 	// Block operations
+
+	// Reaps the mempool for transactions that are ready to be proposed in a new block
 	GetProposalTransactions(proposer []byte, maxTransactionBytes int, lastBlockByzantineValidators [][]byte) (transactions [][]byte, err error)
+	// Applies the transactions to an ephemeral state in the utility & underlying persistence context;similar to `SafeNode` in the Hotstuff whitepaper.
 	ApplyBlock(height int64, proposer []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) (appHash []byte, err error)
 
 	// Context operations
-	ReleaseContext()
-	GetPersistenceContext() PersistenceRWContext
-	CommitPersistenceContext() error
+	Release() error
+	Commit(quorumCert []byte) error
 
 	// Validation operations
 	CheckTransaction(tx []byte) error

From 655d5d5a405b2b62c7b6aca90e50068f53a7505c Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 4 Oct 2022 17:47:53 -0700
Subject: [PATCH 063/227] Updated shared changelog

---
 shared/CHANGELOG.md | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/shared/CHANGELOG.md b/shared/CHANGELOG.md
index 758de960a..75ac655c4 100644
--- a/shared/CHANGELOG.md
+++ b/shared/CHANGELOG.md
@@ -7,8 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.0.2] - 2022-10-04
+
+- Updates to the `PersistenceModule` interface
+  - Added `ReleaseWriteContext`
+  - Removed `ResetContext`
+- Updates to the `PersistenceContext` interface
+  - Removed `Reset`
+  - Changed `AppHash` `UpdateAppHash`
+  - Changed `Commit()` to `Commit(proposerAddr, quorumCert)`
+- Updates to the `UtilityContext` interface
+  - Change `ReleaseContext` to `Release`
+  - Removed `GetPersistenceContext`
+  - Changed `CommitPersistenceContext()` to `Commit(quorumCert)`
+
+## [0.0.0.1] - 2022-09-24
 
-## [0.0.1] - 2022-09-24
 - Add unit test for `SharedCodec()`
 - Added `TestProtoStructure` for testing
 - Flaky tests troubleshooting - https://github.com/pokt-network/pocket/issues/192

From 9ff0ddbfd8c236e09290dada25573cde20ae9fc4 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 4 Oct 2022 19:00:20 -0700
Subject: [PATCH 064/227] Checkout main again

---
 Makefile                                    |   4 +-
 consensus/CHANGELOG.md                      |  42 +---
 consensus/block.go                          | 126 +++++++++---
 consensus/consensus_tests/pacemaker_test.go |  25 +--
 consensus/consensus_tests/utils_test.go     |  55 ++----
 consensus/debugging.go                      |   5 +-
 consensus/helpers.go                        |  79 ++++----
 consensus/hotstuff_leader.go                | 200 ++++++--------------
 consensus/hotstuff_replica.go               | 139 +++++---------
 consensus/messages.go                       |  67 +++----
 consensus/module.go                         | 183 +++++++++++-------
 consensus/pacemaker.go                      |   2 +-
 consensus/types/errors.go                   |  27 ++-
 consensus/types/proto/block.proto           |   2 +-
 consensus/types/proto/hotstuff_types.proto  |   2 +-
 consensus/types/types.go                    |   4 +-
 go.mod                                      |   3 +-
 go.sum                                      |   2 -
 persistence/application.go                  |  51 -----
 persistence/block.go                        |  42 +---
 persistence/context.go                      |  26 +--
 persistence/db.go                           |   8 -
 persistence/debug.go                        |   2 +-
 persistence/genesis.go                      |   4 +-
 persistence/kvstore/kvstore.go              |  35 +---
 persistence/module.go                       |  31 +--
 persistence/shared_sql.go                   |  40 +---
 persistence/test/module_test.go             |   4 +-
 persistence/types/base_actor.go             |   7 +-
 persistence/types/protocol_actor.go         |   3 -
 persistence/types/shared_sql.go             |   5 -
 shared/indexer/indexer.go                   |   3 +-
 shared/modules/consensus_module.go          |   7 +-
 shared/modules/persistence_module.go        |  79 ++------
 shared/modules/utility_module.go            |   8 +-
 utility/block.go                            |  27 ++-
 utility/context.go                          |  28 ++-
 utility/test/block_test.go                  |  19 +-
 38 files changed, 539 insertions(+), 857 deletions(-)

diff --git a/Makefile b/Makefile
index 79c1cda22..4cdc29a03 100644
--- a/Makefile
+++ b/Makefile
@@ -347,11 +347,9 @@ benchmark_p2p_addrbook:
 # HACK          - Like TECHDEBT, but much worse. This needs to be prioritized
 # REFACTOR      - Similar to TECHDEBT, but will require a substantial rewrite and change across the codebase
 # CONSIDERATION - A comment that involves extra work but was thoughts / considered as part of some implementation
-# CONSOLIDATE   - We likely have similar implementations/types of the same thing, and we should consolidate them.
-# DEPRECATE     - Code that should be removed in the future
 # DISCUSS_IN_THIS_COMMIT - SHOULD NEVER BE COMMITTED TO MASTER. It is a way for the reviewer of a PR to start / reply to a discussion.
 # TODO_IN_THIS_COMMIT    - SHOULD NEVER BE COMMITTED TO MASTER. It is a way to start the review process while non-critical changes are still in progress
-TODO_KEYWORDS = -e "TODO" -e "TECHDEBT" -e "IMPROVE" -e "DISCUSS" -e "INCOMPLETE" -e "INVESTIGATE" -e "CLEANUP" -e "HACK" -e "REFACTOR" -e "CONSIDERATION" -e "TODO_IN_THIS_COMMIT" -e "DISCUSS_IN_THIS_COMMIT" -e "CONSOLIDATE" -e "DEPRECATE"
+TODO_KEYWORDS = -e "TODO" -e "TECHDEBT" -e "IMPROVE" -e "DISCUSS" -e "INCOMPLETE" -e "INVESTIGATE" -e "CLEANUP" -e "HACK" -e "REFACTOR" -e "CONSIDERATION" -e "TODO_IN_THIS_COMMIT" -e "DISCUSS_IN_THIS_COMMIT"
 
 # How do I use TODOs?
 # 1. <KEYWORD>: <Description of follow up work>;
diff --git a/consensus/CHANGELOG.md b/consensus/CHANGELOG.md
index f51a52410..a41773b18 100644
--- a/consensus/CHANGELOG.md
+++ b/consensus/CHANGELOG.md
@@ -7,43 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.0.0.4] - 2022-09-28
-
+## [0.0.0.3] - 2022-09-28
 - `consensusModule` stores block directly to prevent shared structure in the `utilityModule`
 
-## [0.0.0.3] - 2022-09-26
-
-Consensus logic
-
-- Pass in a list of messages to `findHighQC` instead of a hotstuff step
-- Made `CreateProposeMessage` and `CreateVotemessage` accept explicit values, identifying some bugs along the way
-- Made sure to call `applyBlock` when using `highQC` from previous round
-- Moved business logic for `prepareAndApplyBlock` into `hotstuff_leader.go`
-- Removed `MaxBlockBytes` and storing the consensus genesis type locally as is
-
-Consensus cleanup
-
-- Using appropriate getters for protocol types in the hotstuff lifecycle
-- Replaced `proto.Marshal` with `codec.GetCodec().Marshal`
-- Reorganized and cleaned up the code in `consensus/block.go`
-- Consolidated & removed a few `TODO`s throughout the consensus module
-- Added TECHDEBT and TODOs that will be require for a real block lifecycle
-- Fixed typo in `hotstuff_types.proto`
-- Moved the hotstuff handler interface to `consensus/hotstuff_handler.go`
-
-Consensus testing
-
-- Improved mock module initialization in `consensus/consensus_tests/utils_test.go`
-
-General
-
-- Added a diagram for `AppHash` related `ContextInitialization`
-- Added `Makefile` keywords for `TODO`
-
 ## [0.0.0.2] - 2022-08-25
-
 **Encapsulate structures previously in shared [#163](github.com/pokt-network/pocket/issues/163)**
-
 - Ensured proto structures implement shared interfaces
 - `ConsensusConfig` uses shared interfaces in order to accept `MockConsensusConfig` in test_artifacts
 - `ConsensusGenesisState` uses shared interfaces in order to accept `MockConsensusGenesisState` in test_artifacts
@@ -51,7 +19,9 @@ General
 
 ## [0.0.0.1] - 2021-03-31
 
-### Added new libraries: HotPocket 1st iteration
+HotPocket 1st Iteration (https://github.com/pokt-network/pocket/pull/48)
+
+# Added
 
 - Initial implementation of Basic Hotstuff
 - Initial implementation Hotstuff Pacemaker
@@ -62,7 +32,9 @@ General
 
 ## [0.0.0.0] - 2021-03-31
 
-### Added new libraries: VRF & Cryptographic Sortition Libraries
+VRF & Cryptographic Sortition Libraries (https://github.com/pokt-network/pocket/pull/37/files)
+
+### Added
 
 - Tests with `make test_vrf` and `make test_sortition`
 - Benchmarking via `make benchmark_sortition`
diff --git a/consensus/block.go b/consensus/block.go
index 3e392f527..536c3cc74 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -1,34 +1,82 @@
 package consensus
 
 import (
-	"log"
+	"encoding/hex"
 	"unsafe"
 
+	"github.com/pokt-network/pocket/shared/codec"
+
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
 
-// TODO: Add unit tests specific to block validation
-func (m *ConsensusModule) validateBlockBasic(block *typesCons.Block) error {
-	if block == nil && m.Step != NewRound {
+// TODO(olshansky): Sync with Andrew on the type of validation we need here.
+func (m *ConsensusModule) validateBlock(block *typesCons.Block) error {
+	if block == nil {
 		return typesCons.ErrNilBlock
 	}
+	return nil
+}
+
+// This is a helper function intended to be called by a leader/validator during a view change
+func (m *ConsensusModule) prepareBlockAsLeader() (*typesCons.Block, error) {
+	if m.isReplica() {
+		return nil, typesCons.ErrReplicaPrepareBlock
+	}
+
+	if err := m.refreshUtilityContext(); err != nil {
+		return nil, err
+	}
+
+	txs, err := m.utilityContext.GetProposalTransactions(m.privateKey.Address(), maxTxBytes, lastByzValidators)
+	if err != nil {
+		return nil, err
+	}
+
+	appHash, err := m.utilityContext.ApplyBlock(int64(m.Height), m.privateKey.Address(), txs, lastByzValidators)
+	if err != nil {
+		return nil, err
+	}
+
+	blockHeader := &typesCons.BlockHeader{
+		Height:            int64(m.Height),
+		Hash:              hex.EncodeToString(appHash),
+		NumTxs:            uint32(len(txs)),
+		LastBlockHash:     m.appHash,
+		ProposerAddress:   m.privateKey.Address().Bytes(),
+		QuorumCertificate: []byte("HACK: Temporary placeholder"),
+	}
+
+	block := &typesCons.Block{
+		BlockHeader:  blockHeader,
+		Transactions: txs,
+	}
+
+	return block, nil
+}
+
+// This is a helper function intended to be called by a replica/voter during a view change
+func (m *ConsensusModule) applyBlockAsReplica(block *typesCons.Block) error {
+	if m.isLeader() {
+		return typesCons.ErrLeaderApplyBLock
+	}
 
-	if block != nil && m.Step == NewRound {
-		return typesCons.ErrBlockExists
+	// TODO(olshansky): Add unit tests to verify this.
+	if unsafe.Sizeof(*block) > uintptr(m.MaxBlockBytes) {
+		return typesCons.ErrInvalidBlockSize(uint64(unsafe.Sizeof(*block)), m.MaxBlockBytes)
 	}
 
-	if block != nil && unsafe.Sizeof(*block) > uintptr(m.consGenesis.MaxBlockBytes) {
-		return typesCons.ErrInvalidBlockSize(uint64(unsafe.Sizeof(*block)), m.consGenesis.MaxBlockBytes)
+	if err := m.refreshUtilityContext(); err != nil {
+		return err
+	}
+
+	appHash, err := m.utilityContext.ApplyBlock(int64(m.Height), block.BlockHeader.ProposerAddress, block.Transactions, lastByzValidators)
+	if err != nil {
+		return err
 	}
 
-	// If the current block being processed (i.e. voted on) by consensus is non nil, we need to make
-	// sure that the data (height, round, step, txs, etc) is the same before we start validating the signatures
-	if m.Block != nil {
-		// DISCUSS: The only difference between blocks from one step to another is the QC, so we need
-		//          to determine where/how to validate this
-		if protoHash(m.Block) != protoHash(block) {
-			log.Println("[TECHDEBT][ERROR] The block being processed is not the same as that received by the consensus module ")
-		}
+	// DISCUSS(drewsky): Is `ApplyBlock` going to return blockHash or appHash?
+	if block.BlockHeader.Hash != hex.EncodeToString(appHash) {
+		return typesCons.ErrInvalidAppHash(block.BlockHeader.Hash, hex.EncodeToString(appHash))
 	}
 
 	return nil
@@ -36,8 +84,9 @@ func (m *ConsensusModule) validateBlockBasic(block *typesCons.Block) error {
 
 // Creates a new Utility context and clears/nullifies any previous contexts if they exist
 func (m *ConsensusModule) refreshUtilityContext() error {
-	// Catch-all structure to release the previous utility context if it wasn't properly cleaned up.
-	// Ideally, this should not be called.
+	// This is a catch-all to release the previous utility context if it wasn't cleaned up
+	// in the proper lifecycle (e.g. catch up, error, network partition, etc...). Ideally, this
+	// should not be called.
 	if m.utilityContext != nil {
 		m.nodeLog(typesCons.NilUtilityContextWarning)
 		m.utilityContext.ReleaseContext()
@@ -56,14 +105,47 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
 
+	// Store the block in the KV store
+	codec := codec.GetCodec()
+	blockProtoBytes, err := codec.Marshal(block)
+	if err != nil {
+		return err
+	}
+
+	// IMPROVE(olshansky): temporary solution. `ApplyBlock` above applies the
+	// transactions to the postgres database, and this stores it in the KV store upon commitment.
+	// Instead of calling this directly, an alternative solution is to store the block metadata in
+	// the persistence context and have `CommitPersistenceContext` do this under the hood. However,
+	// additional `Block` metadata will need to be passed through and may change when we merkle the
+	// state hash.
+	if err := m.storeBlock(block, blockProtoBytes); err != nil {
+		return err
+	}
+
 	// Commit and release the context
-	if err := m.UtilityContext.CommitContext(block.BlockHeader.QuorumCertificate); err != nil {
+	if err := m.utilityContext.CommitPersistenceContext(); err != nil {
 		return err
 	}
-	m.UtilityContext.ReleaseContext()
-	m.UtilityContext = nil
 
-	m.lastAppHash = block.BlockHeader.Hash
+	m.utilityContext.ReleaseContext()
+	m.utilityContext = nil
+
+	m.appHash = block.BlockHeader.Hash
+
+	return nil
+}
+
+func (m *ConsensusModule) storeBlock(block *typesCons.Block, blockProtoBytes []byte) error {
+	store := m.utilityContext.GetPersistenceContext()
+	// Store in KV Store
+	if err := store.StoreBlock(blockProtoBytes); err != nil {
+		return err
+	}
 
+	// Store in SQL Store
+	header := block.BlockHeader
+	if err := store.InsertBlock(uint64(header.Height), header.Hash, header.ProposerAddress, header.QuorumCertificate); err != nil {
+		return err
+	}
 	return nil
 }
diff --git a/consensus/consensus_tests/pacemaker_test.go b/consensus/consensus_tests/pacemaker_test.go
index 80bf64fc4..4134f17cc 100644
--- a/consensus/consensus_tests/pacemaker_test.go
+++ b/consensus/consensus_tests/pacemaker_test.go
@@ -157,29 +157,22 @@ func TestPacemakerCatchupSameStepDifferentRounds(t *testing.T) {
 		Transactions: emptyTxs,
 	}
 
-	leaderConsensusMod := GetConsensusModElem(leader)
+	leaderConsensusMod := GetConsensusModImplementation(leader)
 	leaderConsensusMod.FieldByName("Block").Set(reflect.ValueOf(block))
 
 	// Set all nodes to the same STEP and HEIGHT BUT different ROUNDS
 	for _, pocketNode := range pocketNodes {
-		// utilityContext is only set on new rounds, which is skipped in this test
-		utilityContext, err := pocketNode.GetBus().GetUtilityModule().NewContext(int64(testHeight))
-		require.NoError(t, err)
-
-		consensusModElem := GetConsensusModElem(pocketNode)
-		consensusModElem.FieldByName("Height").SetUint(testHeight)
-		consensusModElem.FieldByName("Step").SetInt(testStep)
-		consensusModElem.FieldByName("LeaderId").Set(reflect.Zero(reflect.TypeOf(&leaderId))) // This is re-elected during paceMaker catchup
-
-		consensusModImpl := GetConsensusModImpl(pocketNode)
-		consensusModImpl.MethodByName("SetUtilityContext").Call([]reflect.Value{reflect.ValueOf(utilityContext)})
+		consensusModImpl := GetConsensusModImplementation(pocketNode)
+		consensusModImpl.FieldByName("Height").SetUint(testHeight)
+		consensusModImpl.FieldByName("Step").SetInt(testStep)
+		consensusModImpl.FieldByName("LeaderId").Set(reflect.Zero(reflect.TypeOf(&leaderId))) // This is re-elected during paceMaker catchup
 	}
 
 	// Set the leader to be in the highest round.
-	GetConsensusModElem(pocketNodes[1]).FieldByName("Round").SetUint(uint64(leaderRound - 2))
-	GetConsensusModElem(pocketNodes[2]).FieldByName("Round").SetUint(uint64(leaderRound - 3))
-	GetConsensusModElem(pocketNodes[leaderId]).FieldByName("Round").SetUint(uint64(leaderRound))
-	GetConsensusModElem(pocketNodes[4]).FieldByName("Round").SetUint(uint64(leaderRound - 4))
+	GetConsensusModImplementation(pocketNodes[1]).FieldByName("Round").SetUint(uint64(leaderRound - 2))
+	GetConsensusModImplementation(pocketNodes[2]).FieldByName("Round").SetUint(uint64(leaderRound - 3))
+	GetConsensusModImplementation(pocketNodes[leaderId]).FieldByName("Round").SetUint(uint64(leaderRound))
+	GetConsensusModImplementation(pocketNodes[4]).FieldByName("Round").SetUint(uint64(leaderRound - 4))
 
 	prepareProposal := &typesCons.HotstuffMessage{
 		Type:          consensus.Propose,
diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 40fb777d9..4903a9abd 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -14,8 +14,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/pokt-network/pocket/shared/codec"
-
 	"github.com/benbjohnson/clock"
 	"github.com/golang/mock/gomock"
 	"github.com/pokt-network/pocket/consensus"
@@ -27,6 +25,7 @@ import (
 	modulesMock "github.com/pokt-network/pocket/shared/modules/mocks"
 	"github.com/pokt-network/pocket/shared/test_artifacts"
 	"github.com/stretchr/testify/require"
+	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/anypb"
 )
 
@@ -181,17 +180,13 @@ func StartAllTestPocketNodes(t *testing.T, pocketNodes IdToNodeMapping) {
 // define the interfaces used for debug/development. The latter will probably scale more but will
 // require more effort and pollute the source code with debugging information.
 func GetConsensusNodeState(node *shared.Node) typesCons.ConsensusNodeState {
-	return GetConsensusModImpl(node).MethodByName("GetNodeState").Call([]reflect.Value{})[0].Interface().(typesCons.ConsensusNodeState)
+	return reflect.ValueOf(node.GetBus().GetConsensusModule()).MethodByName("GetNodeState").Call([]reflect.Value{})[0].Interface().(typesCons.ConsensusNodeState)
 }
 
-func GetConsensusModElem(node *shared.Node) reflect.Value {
+func GetConsensusModImplementation(node *shared.Node) reflect.Value {
 	return reflect.ValueOf(node.GetBus().GetConsensusModule()).Elem()
 }
 
-func GetConsensusModImpl(node *shared.Node) reflect.Value {
-	return reflect.ValueOf(node.GetBus().GetConsensusModule())
-}
-
 /*** Debug/Development Message Helpers ***/
 
 func TriggerNextView(t *testing.T, node *shared.Node) {
@@ -235,12 +230,10 @@ func WaitForNetworkConsensusMessages(
 ) (messages []*anypb.Any, err error) {
 
 	includeFilter := func(m *anypb.Any) bool {
-		msg, err := codec.GetCodec().FromAny(m)
+		var hotstuffMessage typesCons.HotstuffMessage
+		err := anypb.UnmarshalTo(m, &hotstuffMessage, proto.UnmarshalOptions{})
 		require.NoError(t, err)
 
-		hotstuffMessage, ok := msg.(*typesCons.HotstuffMessage)
-		require.True(t, ok)
-
 		return hotstuffMessage.Type == hotstuffMsgType && hotstuffMessage.Step == step
 	}
 
@@ -355,7 +348,8 @@ func baseP2PMock(t *testing.T, testChannel modules.EventsChannel) *modulesMock.M
 func baseUtilityMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockUtilityModule {
 	ctrl := gomock.NewController(t)
 	utilityMock := modulesMock.NewMockUtilityModule(ctrl)
-	utilityContextMock := baseUtilityContextMock(t)
+	utilityContextMock := modulesMock.NewMockUtilityContext(ctrl)
+	persistenceContextMock := modulesMock.NewMockPersistenceRWContext(ctrl)
 
 	utilityMock.EXPECT().Start().Return(nil).AnyTimes()
 	utilityMock.EXPECT().SetBus(gomock.Any()).Do(func(modules.Bus) {}).AnyTimes()
@@ -364,14 +358,9 @@ func baseUtilityMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockUti
 		Return(utilityContextMock, nil).
 		MaxTimes(4)
 
-	return utilityMock
-}
-
-func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
-	ctrl := gomock.NewController(t)
-	utilityContextMock := modulesMock.NewMockUtilityContext(ctrl)
-	// persistenceContextMock := modulesMock.NewMockPersistenceRWContext(ctrl)
-
+	utilityContextMock.EXPECT().GetPersistenceContext().Return(persistenceContextMock).AnyTimes()
+	utilityContextMock.EXPECT().CommitPersistenceContext().Return(nil).AnyTimes()
+	utilityContextMock.EXPECT().ReleaseContext().Return().AnyTimes()
 	utilityContextMock.EXPECT().
 		GetProposalTransactions(gomock.Any(), maxTxBytes, gomock.AssignableToTypeOf(emptyByzValidators)).
 		Return(make([][]byte, 0), nil).
@@ -381,15 +370,11 @@ func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 		Return(appHash, nil).
 		AnyTimes()
 
-	// utilityContextMock.EXPECT().CommitPersistenceContext().Return(nil).AnyTimes()
-	// utilityContextMock.EXPECT().ReleaseContext().Return().AnyTimes()
-	// utilityContextMock.EXPECT().GetPersistenceContext().Return(persistenceContextMock).AnyTimes()
-
-	// persistenceContextMock.EXPECT().StoreTransaction(gomock.Any()).Return(nil).AnyTimes()
-	// persistenceContextMock.EXPECT().StoreBlock(gomock.Any()).Return(nil).AnyTimes()
-	// persistenceContextMock.EXPECT().InsertBlock(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes().Return(nil)
+	persistenceContextMock.EXPECT().Commit().Return(nil).AnyTimes()
+	persistenceContextMock.EXPECT().StoreBlock(gomock.Any()).AnyTimes().Return(nil)
+	persistenceContextMock.EXPECT().InsertBlock(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes().Return(nil)
 
-	return utilityContextMock
+	return utilityMock
 }
 
 func baseTelemetryMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockTelemetryModule {
@@ -400,24 +385,26 @@ func baseTelemetryMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockT
 
 	telemetryMock.EXPECT().Start().Do(func() {}).AnyTimes()
 	telemetryMock.EXPECT().SetBus(gomock.Any()).Do(func(modules.Bus) {}).AnyTimes()
+
 	telemetryMock.EXPECT().GetTimeSeriesAgent().Return(timeSeriesAgentMock).AnyTimes()
+	timeSeriesAgentMock.EXPECT().CounterRegister(gomock.Any(), gomock.Any()).MaxTimes(1)
+	timeSeriesAgentMock.EXPECT().CounterIncrement(gomock.Any()).AnyTimes()
+
 	telemetryMock.EXPECT().GetEventMetricsAgent().Return(eventMetricsAgentMock).AnyTimes()
+	eventMetricsAgentMock.EXPECT().EmitEvent(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
 
 	return telemetryMock
 }
 
 func baseTelemetryTimeSeriesAgentMock(t *testing.T) *modulesMock.MockTimeSeriesAgent {
 	ctrl := gomock.NewController(t)
-	timeSeriesAgentMock := modulesMock.NewMockTimeSeriesAgent(ctrl)
-	timeSeriesAgentMock.EXPECT().CounterRegister(gomock.Any(), gomock.Any()).MaxTimes(1)
-	timeSeriesAgentMock.EXPECT().CounterIncrement(gomock.Any()).AnyTimes()
-	return timeSeriesAgentMock
+	timeseriesAgentMock := modulesMock.NewMockTimeSeriesAgent(ctrl)
+	return timeseriesAgentMock
 }
 
 func baseTelemetryEventMetricsAgentMock(t *testing.T) *modulesMock.MockEventMetricsAgent {
 	ctrl := gomock.NewController(t)
 	eventMetricsAgentMock := modulesMock.NewMockEventMetricsAgent(ctrl)
-	eventMetricsAgentMock.EXPECT().EmitEvent(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
 	return eventMetricsAgentMock
 }
 
diff --git a/consensus/debugging.go b/consensus/debugging.go
index a73dad40e..8d433db4d 100644
--- a/consensus/debugging.go
+++ b/consensus/debugging.go
@@ -3,8 +3,9 @@ package consensus
 import (
 	"log"
 
-	typesCons "github.com/pokt-network/pocket/consensus/types"
 	"github.com/pokt-network/pocket/shared/debug"
+
+	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
 
 func (m *ConsensusModule) HandleDebugMessage(debugMessage *debug.DebugMessage) error {
@@ -31,7 +32,7 @@ func (m *ConsensusModule) GetNodeState() typesCons.ConsensusNodeState {
 		leaderId = *m.LeaderId
 	}
 	return typesCons.ConsensusNodeState{
-		NodeId:   m.nodeId,
+		NodeId:   m.NodeId,
 		Height:   m.Height,
 		Round:    uint8(m.Round),
 		Step:     uint8(m.Step),
diff --git a/consensus/helpers.go b/consensus/helpers.go
index 364a9d26e..efd6dac16 100644
--- a/consensus/helpers.go
+++ b/consensus/helpers.go
@@ -1,21 +1,21 @@
 package consensus
 
-// TODO: Split this file into multiple helpers (e.g. signatures.go, hotstuff_helpers.go, etc...)
 import (
 	"encoding/base64"
 	"log"
 
-	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/debug"
 
 	"google.golang.org/protobuf/proto"
 
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 	cryptoPocket "github.com/pokt-network/pocket/shared/crypto"
+	"google.golang.org/protobuf/types/known/anypb"
 )
 
 // These constants and variables are wrappers around the autogenerated protobuf types and were
 // added to simply make the code in the `consensus` module more readable.
+
 const (
 	NewRound  = typesCons.HotstuffStep_HOTSTUFF_STEP_NEWROUND
 	Prepare   = typesCons.HotstuffStep_HOTSTUFF_STEP_PREPARE
@@ -23,36 +23,37 @@ const (
 	Commit    = typesCons.HotstuffStep_HOTSTUFF_STEP_COMMIT
 	Decide    = typesCons.HotstuffStep_HOTSTUFF_STEP_DECIDE
 
-	Propose = typesCons.HotstuffMessageType_HOTSTUFF_MESSAGE_PROPOSE
-	Vote    = typesCons.HotstuffMessageType_HOTSTUFF_MESSAGE_VOTE
-
 	ByzantineThreshold = float64(2) / float64(3)
-
-	HotstuffMessage = "consensus.HotstuffMessage"
-	UtilityMessage  = "consensus.UtilityMessage"
+	HotstuffMessage    = "consensus.HotstuffMessage"
+	UtilityMessage     = "consensus.UtilityMessage"
+	Propose            = typesCons.HotstuffMessageType_HOTSTUFF_MESAGE_PROPOSE
+	Vote               = typesCons.HotstuffMessageType_HOTSTUFF_MESSAGE_VOTE
 )
 
 var (
 	HotstuffSteps = [...]typesCons.HotstuffStep{NewRound, Prepare, PreCommit, Commit, Decide}
+
+	maxTxBytes        = 90000             // TODO(olshansky): Move this to config.json.
+	lastByzValidators = make([][]byte, 0) // TODO(olshansky): Retrieve this from persistence
 )
 
 // ** Hotstuff Helpers ** //
 
-// IMPROVE: Avoid having the `ConsensusModule` be a receiver of this; making it more functional.
-// TODO: Add unit tests for all quorumCert creation & validation logic...
 func (m *ConsensusModule) getQuorumCertificate(height uint64, step typesCons.HotstuffStep, round uint64) (*typesCons.QuorumCertificate, error) {
 	var pss []*typesCons.PartialSignature
-	for _, msg := range m.messagePool[step] {
+	for _, msg := range m.MessagePool[step] {
+		// TODO(olshansky): Add tests for this
 		if msg.GetPartialSignature() == nil {
 			m.nodeLog(typesCons.WarnMissingPartialSig(msg))
 			continue
 		}
-		if msg.GetHeight() != height || msg.GetStep() != step || msg.GetRound() != round {
+		// TODO(olshansky): Add tests for this
+		if msg.Height != height || msg.Step != step || msg.Round != round {
 			m.nodeLog(typesCons.WarnUnexpectedMessageInPool(msg, height, step, round))
 			continue
 		}
-
 		ps := msg.GetPartialSignature()
+
 		if ps.Signature == nil || len(ps.Address) == 0 {
 			m.nodeLog(typesCons.WarnIncompletePartialSig(ps, msg))
 			continue
@@ -70,16 +71,16 @@ func (m *ConsensusModule) getQuorumCertificate(height uint64, step typesCons.Hot
 	}
 
 	return &typesCons.QuorumCertificate{
-		Height:             height,
+		Height:             m.Height,
 		Step:               step,
-		Round:              round,
+		Round:              m.Round,
 		Block:              m.Block,
 		ThresholdSignature: thresholdSig,
 	}, nil
 }
 
-func (m *ConsensusModule) findHighQC(msgs []*typesCons.HotstuffMessage) (qc *typesCons.QuorumCertificate) {
-	for _, m := range msgs {
+func (m *ConsensusModule) findHighQC(step typesCons.HotstuffStep) (qc *typesCons.QuorumCertificate) {
+	for _, m := range m.MessagePool[step] {
 		if m.GetQuorumCertificate() == nil {
 			continue
 		}
@@ -90,20 +91,21 @@ func (m *ConsensusModule) findHighQC(msgs []*typesCons.HotstuffMessage) (qc *typ
 	return
 }
 
-func getThresholdSignature(partialSigs []*typesCons.PartialSignature) (*typesCons.ThresholdSignature, error) {
+func getThresholdSignature(
+	partialSigs []*typesCons.PartialSignature) (*typesCons.ThresholdSignature, error) {
 	thresholdSig := new(typesCons.ThresholdSignature)
 	thresholdSig.Signatures = make([]*typesCons.PartialSignature, len(partialSigs))
 	copy(thresholdSig.Signatures, partialSigs)
 	return thresholdSig, nil
 }
 
-func isSignatureValid(msg *typesCons.HotstuffMessage, pubKeyString string, signature []byte) bool {
+func isSignatureValid(m *typesCons.HotstuffMessage, pubKeyString string, signature []byte) bool {
 	pubKey, err := cryptoPocket.NewPublicKey(pubKeyString)
 	if err != nil {
 		log.Println("[WARN] Error getting PublicKey from bytes:", err)
 		return false
 	}
-	bytesToVerify, err := getSignableBytes(msg)
+	bytesToVerify, err := getSignableBytes(m)
 	if err != nil {
 		log.Println("[WARN] Error getting bytes to verify:", err)
 		return false
@@ -112,7 +114,7 @@ func isSignatureValid(msg *typesCons.HotstuffMessage, pubKeyString string, signa
 }
 
 func (m *ConsensusModule) didReceiveEnoughMessageForStep(step typesCons.HotstuffStep) error {
-	return m.isOptimisticThresholdMet(len(m.messagePool[step]))
+	return m.isOptimisticThresholdMet(len(m.MessagePool[step]))
 }
 
 func (m *ConsensusModule) isOptimisticThresholdMet(n int) error {
@@ -126,12 +128,12 @@ func (m *ConsensusModule) isOptimisticThresholdMet(n int) error {
 func (m *ConsensusModule) resetForNewHeight() {
 	m.Round = 0
 	m.Block = nil
-	m.highPrepareQC = nil
-	m.lockedQC = nil
+	m.HighPrepareQC = nil
+	m.LockedQC = nil
 }
 
 func protoHash(m proto.Message) string {
-	b, err := codec.GetCodec().Marshal(m)
+	b, err := proto.Marshal(m)
 	if err != nil {
 		log.Fatalf("Could not marshal proto message: %v", err)
 	}
@@ -148,12 +150,13 @@ func (m *ConsensusModule) sendToNode(msg *typesCons.HotstuffMessage) {
 	}
 
 	m.nodeLog(typesCons.SendingMessage(msg, *m.LeaderId))
-	anyConsensusMessage, err := codec.GetCodec().ToAny(msg)
+	anyConsensusMessage, err := anypb.New(msg)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateConsensusMessage.Error(), err)
 		return
 	}
-	if err := m.GetBus().GetP2PModule().Send(cryptoPocket.AddressFromString(m.idToValAddrMap[*m.LeaderId]), anyConsensusMessage, debug.PocketTopic_CONSENSUS_MESSAGE_TOPIC); err != nil {
+
+	if err := m.GetBus().GetP2PModule().Send(cryptoPocket.AddressFromString(m.IdToValAddrMap[*m.LeaderId]), anyConsensusMessage, debug.PocketTopic_CONSENSUS_MESSAGE_TOPIC); err != nil {
 		m.nodeLogError(typesCons.ErrSendMessage.Error(), err)
 		return
 	}
@@ -161,11 +164,12 @@ func (m *ConsensusModule) sendToNode(msg *typesCons.HotstuffMessage) {
 
 func (m *ConsensusModule) broadcastToNodes(msg *typesCons.HotstuffMessage) {
 	m.nodeLog(typesCons.BroadcastingMessage(msg))
-	anyConsensusMessage, err := codec.GetCodec().ToAny(msg)
+	anyConsensusMessage, err := anypb.New(msg)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateConsensusMessage.Error(), err)
 		return
 	}
+
 	if err := m.GetBus().GetP2PModule().Broadcast(anyConsensusMessage, debug.PocketTopic_CONSENSUS_MESSAGE_TOPIC); err != nil {
 		m.nodeLogError(typesCons.ErrBroadcastMessage.Error(), err)
 		return
@@ -174,10 +178,9 @@ func (m *ConsensusModule) broadcastToNodes(msg *typesCons.HotstuffMessage) {
 
 /*** Persistence Helpers ***/
 
-// TECHDEBT: Integrate this with the `persistence` module or a real mempool.
 func (m *ConsensusModule) clearMessagesPool() {
 	for _, step := range HotstuffSteps {
-		m.messagePool[step] = make([]*typesCons.HotstuffMessage, 0)
+		m.MessagePool[step] = make([]*typesCons.HotstuffMessage, 0)
 	}
 }
 
@@ -188,7 +191,7 @@ func (m *ConsensusModule) isLeaderUnknown() bool {
 }
 
 func (m *ConsensusModule) isLeader() bool {
-	return m.LeaderId != nil && *m.LeaderId == m.nodeId
+	return m.LeaderId != nil && *m.LeaderId == m.NodeId
 }
 
 func (m *ConsensusModule) isReplica() bool {
@@ -200,37 +203,33 @@ func (m *ConsensusModule) clearLeader() {
 	m.LeaderId = nil
 }
 
-func (m *ConsensusModule) electNextLeader(message *typesCons.HotstuffMessage) error {
+func (m *ConsensusModule) electNextLeader(message *typesCons.HotstuffMessage) {
 	leaderId, err := m.leaderElectionMod.ElectNextLeader(message)
 	if err != nil || leaderId == 0 {
 		m.nodeLogError(typesCons.ErrLeaderElection(message).Error(), err)
 		m.clearLeader()
-		return err
+		return
 	}
 
 	m.LeaderId = &leaderId
 
 	if m.isLeader() {
 		m.setLogPrefix("LEADER")
-		m.nodeLog(typesCons.ElectedSelfAsNewLeader(m.idToValAddrMap[*m.LeaderId], *m.LeaderId, m.Height, m.Round))
+		m.nodeLog(typesCons.ElectedSelfAsNewLeader(m.IdToValAddrMap[*m.LeaderId], *m.LeaderId, m.Height, m.Round))
 	} else {
 		m.setLogPrefix("REPLICA")
-		m.nodeLog(typesCons.ElectedNewLeader(m.idToValAddrMap[*m.LeaderId], *m.LeaderId, m.Height, m.Round))
+		m.nodeLog(typesCons.ElectedNewLeader(m.IdToValAddrMap[*m.LeaderId], *m.LeaderId, m.Height, m.Round))
 	}
-
-	return nil
 }
 
 /*** General Infrastructure Helpers ***/
 
-// TODO(#164): Remove this once we have a proper logging system.
 func (m *ConsensusModule) nodeLog(s string) {
-	log.Printf("[%s][%d] %s\n", m.logPrefix, m.nodeId, s)
+	log.Printf("[%s][%d] %s\n", m.logPrefix, m.NodeId, s)
 }
 
-// TODO(#164): Remove this once we have a proper logging system.
 func (m *ConsensusModule) nodeLogError(s string, err error) {
-	log.Printf("[ERROR][%s][%d] %s: %v\n", m.logPrefix, m.nodeId, s, err)
+	log.Printf("[ERROR][%s][%d] %s: %v\n", m.logPrefix, m.NodeId, s, err)
 }
 
 func (m *ConsensusModule) setLogPrefix(logPrefix string) {
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 54f41e0dd..d691ebc0c 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -1,15 +1,12 @@
 package consensus
 
 import (
-	"encoding/hex"
 	"unsafe"
 
 	consensusTelemetry "github.com/pokt-network/pocket/consensus/telemetry"
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
 
-type HotstuffLeaderMessageHandler struct{}
-
 var (
 	LeaderMessageHandler HotstuffMessageHandler = &HotstuffLeaderMessageHandler{}
 	leaderHandlers                              = map[typesCons.HotstuffStep]func(*ConsensusModule, *typesCons.HotstuffMessage){
@@ -21,39 +18,32 @@ var (
 	}
 )
 
+type HotstuffLeaderMessageHandler struct{}
+
 /*** Prepare Step ***/
 
 func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	defer m.paceMaker.RestartTimer()
 	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-
-	// DISCUSS: Do we need to pause for `MinBlockFreqMSec` here to let more transactions or should we stick with optimistic responsiveness?
-
+	// TODO(olshansky): add step specific validation
 	if err := m.didReceiveEnoughMessageForStep(NewRound); err != nil {
 		m.nodeLog(typesCons.OptimisticVoteCountWaiting(NewRound, err.Error()))
 		return
 	}
-	m.nodeLog(typesCons.OptimisticVoteCountPassed(NewRound))
 
-	// Clear the previous utility context, if it exists, and create a new one
-	if err := m.refreshUtilityContext(); err != nil {
-		m.nodeLogError("Could not refresh utility context", err)
-		return
-	}
+	// TODO(olshansky): Do we need to pause for `MinBlockFreqMSec` here to let more transactions come in?
+	m.nodeLog(typesCons.OptimisticVoteCountPassed(NewRound))
 
 	// Likely to be `nil` if blockchain is progressing well.
-	// TECHDEBT: How do we properly validate `highPrepareQC` here?
-	highPrepareQC := m.findHighQC(m.messagePool[NewRound])
+	highPrepareQC := m.findHighQC(NewRound)
 
-	// TODO: Add more unit tests for these checks...
-	if m.shouldPrepareNewBlock(highPrepareQC) {
-		// Leader prepares a new block if `highPrepareQC` is not applicable
-		block, err := m.prepareAndApplyBlock()
+	// TODO(olshansky): Add more unit tests for these checks...
+	if highPrepareQC == nil || highPrepareQC.Height < m.Height || highPrepareQC.Round < m.Round {
+		block, err := m.prepareBlockAsLeader()
 		if err != nil {
 			m.nodeLogError(typesCons.ErrPrepareBlock.Error(), err)
 			m.paceMaker.InterruptRound()
@@ -61,20 +51,15 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusM
 		}
 		m.Block = block
 	} else {
-		// DISCUSS: Do we need to call `validateProposal` here?
-		// Leader acts like a replica if `highPrepareQC` is not `nil`
-		if err := m.applyBlock(highPrepareQC.Block); err != nil {
-			m.nodeLogError(typesCons.ErrApplyBlock.Error(), err)
-			m.paceMaker.InterruptRound()
-			return
-		}
+		// TODO(discuss): Do we need to validate highPrepareQC here?
 		m.Block = highPrepareQC.Block
 	}
 
 	m.Step = Prepare
-	m.messagePool[NewRound] = nil
+	m.MessagePool[NewRound] = nil
+	m.paceMaker.RestartTimer()
 
-	prepareProposeMessage, err := CreateProposeMessage(m.Height, m.Round, Prepare, m.Block, highPrepareQC)
+	prepareProposeMessage, err := CreateProposeMessage(m, Prepare, highPrepareQC)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateProposeMessage(Prepare).Error(), err)
 		m.paceMaker.InterruptRound()
@@ -83,10 +68,10 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusM
 	m.broadcastToNodes(prepareProposeMessage)
 
 	// Leader also acts like a replica
-	prepareVoteMessage, err := CreateVoteMessage(m.Height, m.Round, Prepare, m.Block, m.privateKey)
+	prepareVoteMessage, err := CreateVoteMessage(m, Prepare, m.Block)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(Prepare).Error(), err)
-		return
+		return // TODO(olshansky): Should we interrupt the round here?
 	}
 	m.sendToNode(prepareVoteMessage)
 }
@@ -94,14 +79,13 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *ConsensusM
 /*** PreCommit Step ***/
 
 func (handler *HotstuffLeaderMessageHandler) HandlePrepareMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	defer m.paceMaker.RestartTimer()
 	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-
+	// TODO(olshansky): add step specific validation
 	if err := m.didReceiveEnoughMessageForStep(Prepare); err != nil {
 		m.nodeLog(typesCons.OptimisticVoteCountWaiting(Prepare, err.Error()))
 		return
@@ -115,22 +99,23 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrepareMessage(m *ConsensusMo
 	}
 
 	m.Step = PreCommit
-	m.highPrepareQC = prepareQC
-	m.messagePool[Prepare] = nil
+	m.HighPrepareQC = prepareQC
+	m.MessagePool[Prepare] = nil
+	m.paceMaker.RestartTimer()
 
-	preCommitProposeMessage, err := CreateProposeMessage(m.Height, m.Round, PreCommit, m.Block, prepareQC)
+	precommitProposeMessages, err := CreateProposeMessage(m, PreCommit, prepareQC)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateProposeMessage(PreCommit).Error(), err)
 		m.paceMaker.InterruptRound()
 		return
 	}
-	m.broadcastToNodes(preCommitProposeMessage)
+	m.broadcastToNodes(precommitProposeMessages)
 
 	// Leader also acts like a replica
-	precommitVoteMessage, err := CreateVoteMessage(m.Height, m.Round, PreCommit, m.Block, m.privateKey)
+	precommitVoteMessage, err := CreateVoteMessage(m, PreCommit, m.Block)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(PreCommit).Error(), err)
-		return
+		return // TODO(olshansky): Should we interrupt the round here?
 	}
 	m.sendToNode(precommitVoteMessage)
 }
@@ -138,14 +123,13 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrepareMessage(m *ConsensusMo
 /*** Commit Step ***/
 
 func (handler *HotstuffLeaderMessageHandler) HandlePrecommitMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	defer m.paceMaker.RestartTimer()
 	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-
+	// TODO(olshansky): add step specific validation
 	if err := m.didReceiveEnoughMessageForStep(PreCommit); err != nil {
 		m.nodeLog(typesCons.OptimisticVoteCountWaiting(PreCommit, err.Error()))
 		return
@@ -159,10 +143,11 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrecommitMessage(m *Consensus
 	}
 
 	m.Step = Commit
-	m.lockedQC = preCommitQC
-	m.messagePool[PreCommit] = nil
+	m.LockedQC = preCommitQC
+	m.MessagePool[PreCommit] = nil
+	m.paceMaker.RestartTimer()
 
-	commitProposeMessage, err := CreateProposeMessage(m.Height, m.Round, Commit, m.Block, preCommitQC)
+	commitProposeMessage, err := CreateProposeMessage(m, Commit, preCommitQC)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateProposeMessage(Commit).Error(), err)
 		m.paceMaker.InterruptRound()
@@ -171,10 +156,10 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrecommitMessage(m *Consensus
 	m.broadcastToNodes(commitProposeMessage)
 
 	// Leader also acts like a replica
-	commitVoteMessage, err := CreateVoteMessage(m.Height, m.Round, Commit, m.Block, m.privateKey)
+	commitVoteMessage, err := CreateVoteMessage(m, Commit, m.Block)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(Commit).Error(), err)
-		return
+		return // TODO(olshansky): Should we interrupt the round here?
 	}
 	m.sendToNode(commitVoteMessage)
 }
@@ -182,14 +167,13 @@ func (handler *HotstuffLeaderMessageHandler) HandlePrecommitMessage(m *Consensus
 /*** Decide Step ***/
 
 func (handler *HotstuffLeaderMessageHandler) HandleCommitMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	defer m.paceMaker.RestartTimer()
 	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-
+	// TODO(olshansky): add step specific validation
 	if err := m.didReceiveEnoughMessageForStep(Commit); err != nil {
 		m.nodeLog(typesCons.OptimisticVoteCountWaiting(Commit, err.Error()))
 		return
@@ -203,9 +187,10 @@ func (handler *HotstuffLeaderMessageHandler) HandleCommitMessage(m *ConsensusMod
 	}
 
 	m.Step = Decide
-	m.messagePool[Commit] = nil
+	m.MessagePool[Commit] = nil
+	m.paceMaker.RestartTimer()
 
-	decideProposeMessage, err := CreateProposeMessage(m.Height, m.Round, Decide, m.Block, commitQC)
+	decideProposeMessage, err := CreateProposeMessage(m, Decide, commitQC)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateProposeMessage(Decide).Error(), err)
 		m.paceMaker.InterruptRound()
@@ -219,7 +204,7 @@ func (handler *HotstuffLeaderMessageHandler) HandleCommitMessage(m *ConsensusMod
 		return
 	}
 
-	// There is no "replica behavior" to imitate here because the leader already committed the block proposal.
+	// There is no "replica behavior" to imitate here
 
 	m.paceMaker.NewHeight()
 	m.GetBus().
@@ -231,7 +216,6 @@ func (handler *HotstuffLeaderMessageHandler) HandleCommitMessage(m *ConsensusMod
 }
 
 func (handler *HotstuffLeaderMessageHandler) HandleDecideMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	defer m.paceMaker.RestartTimer()
 	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
@@ -242,19 +226,10 @@ func (handler *HotstuffLeaderMessageHandler) HandleDecideMessage(m *ConsensusMod
 
 // anteHandle is the general handler called for every before every specific HotstuffLeaderMessageHandler handler
 func (handler *HotstuffLeaderMessageHandler) anteHandle(m *ConsensusModule, msg *typesCons.HotstuffMessage) error {
-	// Basic block metadata validation
-
-	if err := m.validateBlockBasic(msg.GetBlock()); err != nil {
-		return err
-	}
-
-	// Discard messages with invalid partial signatures before storing it in the leader's consensus mempool
-	if err := m.validatePartialSignature(msg); err != nil {
+	if err := handler.validateBasic(m, msg); err != nil {
 		return err
 	}
-
-	// TECHDEBT: Until we integrate with the real mempool, this is a makeshift solution
-	m.tempIndexHotstuffMessage(msg)
+	m.aggregateMessage(msg)
 	return nil
 }
 
@@ -271,13 +246,22 @@ func (handler *HotstuffLeaderMessageHandler) emitTelemetryEvent(m *ConsensusModu
 		)
 }
 
+// ValidateBasic general validation checks that apply to every HotstuffLeaderMessage
+func (handler *HotstuffLeaderMessageHandler) validateBasic(m *ConsensusModule, msg *typesCons.HotstuffMessage) error {
+	// Discard messages with invalid partial signatures before storing it in the leader's consensus mempool
+	if err := m.validatePartialSignature(msg); err != nil {
+		return err
+	}
+	return nil
+}
+
 func (m *ConsensusModule) validatePartialSignature(msg *typesCons.HotstuffMessage) error {
-	if msg.GetStep() == NewRound {
+	if msg.Step == NewRound {
 		m.nodeLog(typesCons.ErrUnnecessaryPartialSigForNewRound.Error())
 		return nil
 	}
 
-	if msg.GetType() == Propose {
+	if msg.Type == Propose {
 		m.nodeLog(typesCons.ErrUnnecessaryPartialSigForLeaderProposal.Error())
 		return nil
 	}
@@ -285,100 +269,34 @@ func (m *ConsensusModule) validatePartialSignature(msg *typesCons.HotstuffMessag
 	if msg.GetPartialSignature() == nil {
 		return typesCons.ErrNilPartialSig
 	}
-	partialSig := msg.GetPartialSignature()
 
-	if partialSig.Signature == nil || len(partialSig.GetAddress()) == 0 {
+	if msg.GetPartialSignature().Signature == nil || len(msg.GetPartialSignature().Address) == 0 {
 		return typesCons.ErrNilPartialSigOrSourceNotSpecified
 	}
 
-	address := partialSig.GetAddress()
+	address := msg.GetPartialSignature().Address
 	validator, ok := m.validatorMap[address]
 	if !ok {
-		return typesCons.ErrMissingValidator(address, m.valAddrToIdMap[address])
+		return typesCons.ErrMissingValidator(address, m.ValAddrToIdMap[address])
 	}
 	pubKey := validator.GetPublicKey()
-	if isSignatureValid(msg, pubKey, partialSig.GetSignature()) {
+	if isSignatureValid(msg, pubKey, msg.GetPartialSignature().Signature) {
 		return nil
 	}
 
 	return typesCons.ErrValidatingPartialSig(
-		address, m.valAddrToIdMap[address], msg, pubKey)
+		address, m.ValAddrToIdMap[address], msg, pubKey)
 }
 
-// TODO: This is just a placeholder at the moment for indexing hotstuff messages ONLY.
-//       It doesn't actually work because SizeOf returns the size of the map pointer,
-//       and does not recursively determine the size of all the underlying elements
-//       Add proper tests and implementation once the mempool is implemented.
-func (m *ConsensusModule) tempIndexHotstuffMessage(msg *typesCons.HotstuffMessage) {
-	if m.consCfg.GetMaxMempoolBytes() < uint64(unsafe.Sizeof(m.messagePool)) {
+func (m *ConsensusModule) aggregateMessage(msg *typesCons.HotstuffMessage) {
+	// TODO(olshansky): Add proper tests for this when we figure out where the mempool should live.
+	// NOTE: This is just a placeholder at the moment. It doesn't actually work because SizeOf returns
+	// the size of the map pointer, and does not recursively determine the size of all the underlying elements.
+	if m.consCfg.GetMaxMempoolBytes() < uint64(unsafe.Sizeof(m.MessagePool)) {
 		m.nodeLogError(typesCons.DisregardHotstuffMessage, typesCons.ErrConsensusMempoolFull)
 		return
 	}
 
 	// Only the leader needs to aggregate consensus related messages.
-	step := msg.GetStep()
-	m.messagePool[step] = append(m.messagePool[step], msg)
-}
-
-// This is a helper function intended to be called by a leader/validator during a view change
-// to prepare a new block that is applied to the new underlying context.
-func (m *ConsensusModule) prepareAndApplyBlock() (*typesCons.Block, error) {
-	if m.isReplica() {
-		return nil, typesCons.ErrReplicaPrepareBlock
-	}
-
-	// TECHDEBT: Retrieve this from consensus consensus config
-	maxTxBytes := 90000
-
-	// TECHDEBT: Retrieve this from persistence
-	lastByzValidators := make([][]byte, 0)
-
-	// Reap the mempool for transactions to be applied in this block
-	txs, err := m.utilityContext.GetProposalTransactions(m.privateKey.Address(), maxTxBytes, lastByzValidators)
-	if err != nil {
-		return nil, err
-	}
-
-	// OPTIMIZE: Determine if we can avoid the `ApplyBlock` call here
-	// Apply all the transactions in the block
-	appHash, err := m.utilityContext.ApplyBlock(int64(m.Height), m.privateKey.Address(), txs, lastByzValidators)
-	if err != nil {
-		return nil, err
-	}
-
-	// Construct the block
-	blockHeader := &typesCons.BlockHeader{
-		Height:            int64(m.Height),
-		Hash:              hex.EncodeToString(appHash),
-		NumTxs:            uint32(len(txs)),
-		LastBlockHash:     m.lastAppHash,
-		ProposerAddress:   m.privateKey.Address().Bytes(),
-		QuorumCertificate: []byte("HACK: Temporary placeholder"),
-	}
-	block := &typesCons.Block{
-		BlockHeader:  blockHeader,
-		Transactions: txs,
-	}
-
-	return block, nil
-}
-
-// Return true if this node, the leader, should prepare a new block
-func (m *ConsensusModule) shouldPrepareNewBlock(highPrepareQC *typesCons.QuorumCertificate) bool {
-	if highPrepareQC == nil {
-		m.nodeLog("Preparing a new block - no highPrepareQC found")
-		return true
-	} else if m.isHighPrepareQCFromPast(highPrepareQC) {
-		m.nodeLog("Preparing a new block - highPrepareQC is from the past")
-		return true
-	} else if highPrepareQC.Block == nil {
-		m.nodeLog("[WARN] Preparing a new block - highPrepareQC SHOULD be used but block is nil")
-		return true
-	}
-	return false
-}
-
-// The `highPrepareQC` is from the past so we can safely ignore it
-func (m *ConsensusModule) isHighPrepareQCFromPast(highPrepareQC *typesCons.QuorumCertificate) bool {
-	return highPrepareQC.Height < m.Height || highPrepareQC.Round < m.Round
+	m.MessagePool[msg.Step] = append(m.MessagePool[msg.Step], msg)
 }
diff --git a/consensus/hotstuff_replica.go b/consensus/hotstuff_replica.go
index e55e85585..25041c766 100644
--- a/consensus/hotstuff_replica.go
+++ b/consensus/hotstuff_replica.go
@@ -1,11 +1,10 @@
 package consensus
 
 import (
-	"encoding/hex"
 	"fmt"
+	"log"
 
 	consensusTelemetry "github.com/pokt-network/pocket/consensus/telemetry"
-	"github.com/pokt-network/pocket/consensus/types"
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
 
@@ -25,54 +24,46 @@ var (
 /*** NewRound Step ***/
 
 func (handler *HotstuffReplicaMessageHandler) HandleNewRoundMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	defer m.paceMaker.RestartTimer()
 	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-
-	// Clear the previous utility context, if it exists, and create a new one
-	if err := m.refreshUtilityContext(); err != nil {
-		m.nodeLogError("Could not refresh utility context", err)
-		return
-	}
-
+	// TODO(olshansky): add step specific validation
+	m.paceMaker.RestartTimer()
 	m.Step = Prepare
 }
 
 /*** Prepare Step ***/
 
 func (handler *HotstuffReplicaMessageHandler) HandlePrepareMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	defer m.paceMaker.RestartTimer()
 	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-
+	// TODO(olshansky): add step specific validation
 	if err := m.validateProposal(msg); err != nil {
 		m.nodeLogError(fmt.Sprintf("Invalid proposal in %s message", Prepare), err)
 		m.paceMaker.InterruptRound()
 		return
 	}
 
-	block := msg.GetBlock()
-	if err := m.applyBlock(block); err != nil {
+	if err := m.applyBlockAsReplica(msg.Block); err != nil {
 		m.nodeLogError(typesCons.ErrApplyBlock.Error(), err)
 		m.paceMaker.InterruptRound()
 		return
 	}
-	m.Block = block
 
 	m.Step = PreCommit
+	m.paceMaker.RestartTimer()
 
-	prepareVoteMessage, err := CreateVoteMessage(m.Height, m.Round, Prepare, m.Block, m.privateKey)
+	prepareVoteMessage, err := CreateVoteMessage(m, Prepare, msg.Block)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(Prepare).Error(), err)
-		return // Not interrupting the round because liveness could continue with one failed vote
+		return // TODO(olshansky): Should we interrupt the round here?
 	}
 	m.sendToNode(prepareVoteMessage)
 }
@@ -80,28 +71,27 @@ func (handler *HotstuffReplicaMessageHandler) HandlePrepareMessage(m *ConsensusM
 /*** PreCommit Step ***/
 
 func (handler *HotstuffReplicaMessageHandler) HandlePrecommitMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	defer m.paceMaker.RestartTimer()
 	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-
-	quorumCert := msg.GetQuorumCertificate()
-	if err := m.validateQuorumCertificate(quorumCert); err != nil {
+	// TODO(olshansky): add step specific validation
+	if err := m.validateQuorumCertificate(msg.GetQuorumCertificate()); err != nil {
 		m.nodeLogError(typesCons.ErrQCInvalid(PreCommit).Error(), err)
 		m.paceMaker.InterruptRound()
 		return
 	}
 
 	m.Step = Commit
-	m.highPrepareQC = quorumCert // INVESTIGATE: Why are we never using this for validation?
+	m.HighPrepareQC = msg.GetQuorumCertificate() // TODO(discuss): Why are we never using this for validation?
+	m.paceMaker.RestartTimer()
 
-	preCommitVoteMessage, err := CreateVoteMessage(m.Height, m.Round, PreCommit, m.Block, m.privateKey)
+	preCommitVoteMessage, err := CreateVoteMessage(m, PreCommit, msg.Block)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(PreCommit).Error(), err)
-		return // Not interrupting the round because liveness could continue with one failed vote
+		return // TODO(olshansky): Should we interrupt the round here?
 	}
 	m.sendToNode(preCommitVoteMessage)
 }
@@ -109,28 +99,27 @@ func (handler *HotstuffReplicaMessageHandler) HandlePrecommitMessage(m *Consensu
 /*** Commit Step ***/
 
 func (handler *HotstuffReplicaMessageHandler) HandleCommitMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	defer m.paceMaker.RestartTimer()
 	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-
-	quorumCert := msg.GetQuorumCertificate()
-	if err := m.validateQuorumCertificate(quorumCert); err != nil {
+	// TODO(olshansky): add step specific validation
+	if err := m.validateQuorumCertificate(msg.GetQuorumCertificate()); err != nil {
 		m.nodeLogError(typesCons.ErrQCInvalid(Commit).Error(), err)
 		m.paceMaker.InterruptRound()
 		return
 	}
 
 	m.Step = Decide
-	m.lockedQC = quorumCert // DISCUSS: How does the replica recover if it's locked? Replica `formally` agrees on the QC while the rest of the network `verbally` agrees on the QC.
+	m.LockedQC = msg.GetQuorumCertificate() // TODO(discuss): How do the replica recover if it's locked? Replica `formally` agrees on the QC while the rest of the network `verbally` agrees on the QC.
+	m.paceMaker.RestartTimer()
 
-	commitVoteMessage, err := CreateVoteMessage(m.Height, m.Round, Commit, m.Block, m.privateKey)
+	commitVoteMessage, err := CreateVoteMessage(m, Commit, msg.Block)
 	if err != nil {
 		m.nodeLogError(typesCons.ErrCreateVoteMessage(Commit).Error(), err)
-		return // Not interrupting the round because liveness could continue with one failed vote
+		return // TODO(olshansky): Should we interrupt the round here?
 	}
 	m.sendToNode(commitVoteMessage)
 }
@@ -138,22 +127,20 @@ func (handler *HotstuffReplicaMessageHandler) HandleCommitMessage(m *ConsensusMo
 /*** Decide Step ***/
 
 func (handler *HotstuffReplicaMessageHandler) HandleDecideMessage(m *ConsensusModule, msg *typesCons.HotstuffMessage) {
-	defer m.paceMaker.RestartTimer()
 	handler.emitTelemetryEvent(m, msg)
 
 	if err := handler.anteHandle(m, msg); err != nil {
 		m.nodeLogError(typesCons.ErrHotstuffValidation.Error(), err)
 		return
 	}
-
-	quorumCert := msg.GetQuorumCertificate()
-	if err := m.validateQuorumCertificate(quorumCert); err != nil {
+	// TODO(olshansky): add step specific validation
+	if err := m.validateQuorumCertificate(msg.GetQuorumCertificate()); err != nil {
 		m.nodeLogError(typesCons.ErrQCInvalid(Decide).Error(), err)
 		m.paceMaker.InterruptRound()
 		return
 	}
 
-	if err := m.commitBlock(m.Block); err != nil {
+	if err := m.commitBlock(msg.Block); err != nil {
 		m.nodeLogError("Could not commit block", err)
 		m.paceMaker.InterruptRound()
 		return
@@ -164,11 +151,7 @@ func (handler *HotstuffReplicaMessageHandler) HandleDecideMessage(m *ConsensusMo
 
 // anteHandle is the handler called on every replica message before specific handler
 func (handler *HotstuffReplicaMessageHandler) anteHandle(m *ConsensusModule, msg *typesCons.HotstuffMessage) error {
-	// Basic block metadata validation
-	if err := m.validateBlockBasic(msg.GetBlock()); err != nil {
-		return err
-	}
-
+	log.Println("TODO: Hotstuff replica ante handle not implemented yet")
 	return nil
 }
 
@@ -186,22 +169,24 @@ func (handler *HotstuffReplicaMessageHandler) emitTelemetryEvent(m *ConsensusMod
 }
 
 func (m *ConsensusModule) validateProposal(msg *typesCons.HotstuffMessage) error {
-	// Check if node should be accepting proposals
-	if !(msg.GetType() == Propose && msg.GetStep() == Prepare) {
+	if !(msg.Type == Propose && msg.Step == Prepare) {
 		return typesCons.ErrProposalNotValidInPrepare
 	}
 
-	quorumCert := msg.GetQuorumCertificate()
-	// A nil QC implies a successful CommitQC or TimeoutQC, which have been omitted intentionally
-	// since they are not needed for consensus validity. However, if a QC is specified, it must be valid.
-	if quorumCert != nil {
-		if err := m.validateQuorumCertificate(quorumCert); err != nil {
+	if err := m.validateBlock(msg.Block); err != nil {
+		return err
+	}
+
+	// TODO(discuss): A nil QC implies a successfull CommitQC or TimeoutQC, which have been omitted intentionally since
+	// they are not needed for consensus validity. However, if a QC is specified, it must be valid.
+	if msg.GetQuorumCertificate() != nil {
+		if err := m.validateQuorumCertificate(msg.GetQuorumCertificate()); err != nil {
 			return err
 		}
 	}
 
-	lockedQC := m.lockedQC
-	justifyQC := quorumCert
+	lockedQC := m.LockedQC
+	justifyQC := msg.GetQuorumCertificate()
 
 	// Safety: not locked
 	if lockedQC == nil {
@@ -210,40 +195,20 @@ func (m *ConsensusModule) validateProposal(msg *typesCons.HotstuffMessage) error
 	}
 
 	// Safety: check the hash of the locked QC
-	// The equivalent of `lockedQC.Block.ExtendsFrom(justifyQC.Block)` in the hotstuff whitepaper is done in `applyBlock` below.
-	if protoHash(lockedQC.GetBlock()) == protoHash(justifyQC.Block) {
+	// TODO(olshansky): Extend implementation to adopt `ExtendsFrom` as described in the Hotstuff whitepaper.
+	if protoHash(lockedQC.Block) == protoHash(justifyQC.Block) { // && lockedQC.Block.ExtendsFrom(justifyQC.Block)
 		m.nodeLog(typesCons.ProposalBlockExtends)
 		return nil
 	}
 
-	// Liveness: is node locked on a QC from the past?
-	// DISCUSS: Where should additional logic be added to unlock the node?
-	if isLocked, err := isNodeLockedOnPastQC(justifyQC, lockedQC); isLocked {
-		return err
+	// Liveness: node is locked on a QC from the past. [TODO]: Do we want to set `m.LockedQC = nil` here or something else?
+	if justifyQC.Height > lockedQC.Height || (justifyQC.Height == lockedQC.Height && justifyQC.Round > lockedQC.Round) {
+		return typesCons.ErrNodeIsLockedOnPastQC
 	}
 
 	return typesCons.ErrUnhandledProposalCase
 }
 
-// This helper applies the block metadata to the utility & persistence layers
-func (m *ConsensusModule) applyBlock(block *typesCons.Block) error {
-	// TECHDEBT: Retrieve this from persistence
-	lastByzValidators := make([][]byte, 0)
-
-	// Apply all the transactions in the block and get the appHash
-	appHash, err := m.utilityContext.ApplyBlock(int64(m.Height), block.BlockHeader.ProposerAddress, block.Transactions, lastByzValidators)
-	if err != nil {
-		return err
-	}
-
-	// CONSOLIDATE: Terminology of `blockHash`, `appHash` and `stateHash`
-	if block.BlockHeader.Hash != hex.EncodeToString(appHash) {
-		return typesCons.ErrInvalidAppHash(block.BlockHeader.Hash, hex.EncodeToString(appHash))
-	}
-
-	return nil
-}
-
 func (m *ConsensusModule) validateQuorumCertificate(qc *typesCons.QuorumCertificate) error {
 	if qc == nil {
 		return typesCons.ErrNilQC
@@ -259,22 +224,21 @@ func (m *ConsensusModule) validateQuorumCertificate(qc *typesCons.QuorumCertific
 
 	msgToJustify := qcToHotstuffMessage(qc)
 	numValid := 0
-
-	// TODO(#109): Aggregate signatures once BLS or DKG is implemented
 	for _, partialSig := range qc.ThresholdSignature.Signatures {
 		validator, ok := m.validatorMap[partialSig.Address]
 		if !ok {
-			m.nodeLogError(typesCons.ErrMissingValidator(partialSig.Address, m.valAddrToIdMap[partialSig.Address]).Error(), nil)
+			m.nodeLogError(typesCons.ErrMissingValidator(partialSig.Address, m.ValAddrToIdMap[partialSig.Address]).Error(), nil)
 			continue
 		}
 		// TODO(olshansky): Every call to `IsSignatureValid` does a serialization and should be optimized. We can
 		// just serialize `Message` once and verify each signature without re-serializing every time.
 		if !isSignatureValid(msgToJustify, validator.GetPublicKey(), partialSig.Signature) {
-			m.nodeLog(typesCons.WarnInvalidPartialSigInQC(partialSig.Address, m.valAddrToIdMap[partialSig.Address]))
+			m.nodeLog(typesCons.WarnInvalidPartialSigInQC(partialSig.Address, m.ValAddrToIdMap[partialSig.Address]))
 			continue
 		}
 		numValid++
 	}
+
 	if err := m.isOptimisticThresholdMet(numValid); err != nil {
 		return err
 	}
@@ -282,23 +246,6 @@ func (m *ConsensusModule) validateQuorumCertificate(qc *typesCons.QuorumCertific
 	return nil
 }
 
-func isNodeLockedOnPastQC(justifyQC, lockedQC *types.QuorumCertificate) (bool, error) {
-	if isLockedOnPastHeight(justifyQC, lockedQC) {
-		return true, types.ErrNodeLockedPastHeight
-	} else if isLockedOnCurrHeightAndPastRound(justifyQC, lockedQC) {
-		return true, types.ErrNodeLockedPastHeight
-	}
-	return false, nil
-}
-
-func isLockedOnPastHeight(justifyQC, lockedQC *types.QuorumCertificate) bool {
-	return justifyQC.Height > lockedQC.Height
-}
-
-func isLockedOnCurrHeightAndPastRound(justifyQC, lockedQC *types.QuorumCertificate) bool {
-	return justifyQC.Height == lockedQC.Height && justifyQC.Round > lockedQC.Round
-}
-
 func qcToHotstuffMessage(qc *typesCons.QuorumCertificate) *typesCons.HotstuffMessage {
 	return &typesCons.HotstuffMessage{
 		Height: qc.Height,
diff --git a/consensus/messages.go b/consensus/messages.go
index b2a06013e..4fd09cea5 100644
--- a/consensus/messages.go
+++ b/consensus/messages.go
@@ -4,38 +4,35 @@ import (
 	"log"
 
 	typesCons "github.com/pokt-network/pocket/consensus/types"
-	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/crypto"
+	"google.golang.org/protobuf/proto"
 )
 
 func CreateProposeMessage(
-	height uint64,
-	round uint64,
-	step typesCons.HotstuffStep,
-	block *typesCons.Block,
+	m *ConsensusModule,
+	step typesCons.HotstuffStep, // step can be taken from `m` but is specified explicitly via interface to avoid ambiguity
 	qc *typesCons.QuorumCertificate,
 ) (*typesCons.HotstuffMessage, error) {
-	if block == nil {
-		return nil, typesCons.ErrNilBlockVote
+	if m.Block == nil {
+		return nil, typesCons.ErrNilBlockProposal
 	}
 
 	msg := &typesCons.HotstuffMessage{
 		Type:          Propose,
-		Height:        height,
+		Height:        m.Height,
 		Step:          step,
-		Round:         round,
-		Block:         block,
+		Round:         m.Round,
+		Block:         m.Block,
 		Justification: nil, // QC is set below if it is non-nil
 	}
 
-	// TODO: Add unit tests for this
+	// TODO(olshansky): Add unit tests for this
 	if qc == nil && step != Prepare {
 		return nil, typesCons.ErrNilQCProposal
 	}
 
-	// TODO: Add unit tests for this
-	// QC may be nil during NEWROUND if following happy hotstuff path
-	if qc != nil {
+	// TODO(olshansky): Add unit tests for this
+	if qc != nil { // QC may optionally be nil for NEWROUND steps when everything is progressing smoothly
 		msg.Justification = &typesCons.HotstuffMessage_QuorumCertificate{
 			QuorumCertificate: qc,
 		}
@@ -45,11 +42,9 @@ func CreateProposeMessage(
 }
 
 func CreateVoteMessage(
-	height uint64,
-	round uint64,
-	step typesCons.HotstuffStep,
+	m *ConsensusModule,
+	step typesCons.HotstuffStep, // step can be taken from `m` but is specified explicitly via interface to avoid ambiguity
 	block *typesCons.Block,
-	privKey crypto.PrivateKey, // used to sign the vote
 ) (*typesCons.HotstuffMessage, error) {
 	if block == nil {
 		return nil, typesCons.ErrNilBlockVote
@@ -57,50 +52,44 @@ func CreateVoteMessage(
 
 	msg := &typesCons.HotstuffMessage{
 		Type:          Vote,
-		Height:        height,
+		Height:        m.Height,
 		Step:          step,
-		Round:         round,
+		Round:         m.Round,
 		Block:         block,
 		Justification: nil, // signature is computed below
 	}
 
 	msg.Justification = &typesCons.HotstuffMessage_PartialSignature{
 		PartialSignature: &typesCons.PartialSignature{
-			Signature: getMessageSignature(msg, privKey),
-			Address:   privKey.PublicKey().Address().String(),
+			Signature: getMessageSignature(msg, m.privateKey),
+			Address:   m.privateKey.PublicKey().Address().String(),
 		},
 	}
 
 	return msg, nil
 }
 
-// Returns "partial" signature of the hotstuff message from one of the validators.
-// If there is an error signing the bytes, nil is returned instead.
-func getMessageSignature(msg *typesCons.HotstuffMessage, privKey crypto.PrivateKey) []byte {
-	bytesToSign, err := getSignableBytes(msg)
+// Returns a "partial" signature of the hotstuff message from one of the validators
+func getMessageSignature(m *typesCons.HotstuffMessage, privKey crypto.PrivateKey) []byte {
+	bytesToSign, err := getSignableBytes(m)
 	if err != nil {
-		log.Printf("[WARN] error getting bytes to sign: %v\n", err)
 		return nil
 	}
-
 	signature, err := privKey.Sign(bytesToSign)
 	if err != nil {
-		log.Printf("[WARN] error signing message: %v\n", err)
+		log.Fatalf("Error signing message: %v", err)
 		return nil
 	}
-
 	return signature
 }
 
-// Signature only over subset of fields in HotstuffMessage
-// For reference, see section 4.3 of the the hotstuff whitepaper, partial signatures are
-// computed over `tsignr(hm.type, m.viewNumber , m.nodei)`. https://arxiv.org/pdf/1803.05069.pdf
-func getSignableBytes(msg *typesCons.HotstuffMessage) ([]byte, error) {
+// Signature should only be over a subset of the fields in a HotstuffMessage
+func getSignableBytes(m *typesCons.HotstuffMessage) ([]byte, error) {
 	msgToSign := &typesCons.HotstuffMessage{
-		Height: msg.GetHeight(),
-		Step:   msg.GetStep(),
-		Round:  msg.GetRound(),
-		Block:  msg.GetBlock(),
+		Height: m.Height,
+		Step:   m.Step,
+		Round:  m.Round,
+		Block:  m.Block,
 	}
-	return codec.GetCodec().Marshal(msgToSign)
+	return proto.Marshal(msgToSign)
 }
diff --git a/consensus/module.go b/consensus/module.go
index 917cd88d4..c6e240d3d 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -9,9 +9,9 @@ import (
 
 	"github.com/pokt-network/pocket/consensus/leader_election"
 	typesCons "github.com/pokt-network/pocket/consensus/types"
-	"github.com/pokt-network/pocket/shared/codec"
 	cryptoPocket "github.com/pokt-network/pocket/shared/crypto"
 	"github.com/pokt-network/pocket/shared/test_artifacts"
+	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/anypb"
 
 	consensusTelemetry "github.com/pokt-network/pocket/consensus/telemetry"
@@ -19,7 +19,7 @@ import (
 )
 
 const (
-	DefaultLogPrefix    = "NODE" // TODO(#164): Make implicit when logging is standardized
+	DefaultLogPrefix    = "NODE" // Just a default that'll be replaced during consensus operations.
 	ConsensusModuleName = "consensus"
 )
 
@@ -28,13 +28,12 @@ var _ modules.PacemakerConfig = &typesCons.PacemakerConfig{}
 var _ modules.ConsensusConfig = &typesCons.ConsensusConfig{}
 var _ modules.ConsensusModule = &ConsensusModule{}
 
-// TODO(#256): Do not export the `ConsensusModule` struct or the fields inside of it.
+// TODO(olshansky): Any reason to make all of these attributes local only (i.e. not exposed outside the struct)?
+// TODO(olshansky): Look for a way to not externalize the `ConsensusModule` struct
 type ConsensusModule struct {
 	bus        modules.Bus
 	privateKey cryptoPocket.Ed25519PrivateKey
-
-	consCfg     *typesCons.ConsensusConfig
-	consGenesis *typesCons.ConsensusGenesisState
+	consCfg    modules.ConsensusConfig
 
 	// m is a mutex used to control synchronization when multiple goroutines are accessing the struct and its fields / properties.
 	//
@@ -47,32 +46,31 @@ type ConsensusModule struct {
 	Height uint64
 	Round  uint64
 	Step   typesCons.HotstuffStep
-	Block  *typesCons.Block // The current block being proposed / voted on; it has not been committed to finality
+	Block  *typesCons.Block // The current block being voted on prior to committing to finality
 
-	highPrepareQC *typesCons.QuorumCertificate // Highest QC for which replica voted PRECOMMIT
-	lockedQC      *typesCons.QuorumCertificate // Highest QC for which replica voted COMMIT
+	HighPrepareQC *typesCons.QuorumCertificate // Highest QC for which replica voted PRECOMMIT
+	LockedQC      *typesCons.QuorumCertificate // Highest QC for which replica voted COMMIT
 
 	// Leader Election
 	LeaderId       *typesCons.NodeId
-	nodeId         typesCons.NodeId
-	valAddrToIdMap typesCons.ValAddrToIdMap // TODO: This needs to be updated every time the ValMap is modified
-	idToValAddrMap typesCons.IdToValAddrMap // TODO: This needs to be updated every time the ValMap is modified
+	NodeId         typesCons.NodeId
+	ValAddrToIdMap typesCons.ValAddrToIdMap // TODO(design): This needs to be updated every time the ValMap is modified
+	IdToValAddrMap typesCons.IdToValAddrMap // TODO(design): This needs to be updated every time the ValMap is modified
 
 	// Consensus State
-	lastAppHash  string // TODO: Always retrieve this variable from the persistence module and simplify this struct
+	appHash      string
 	validatorMap typesCons.ValidatorMap
 
 	// Module Dependencies
-	// TODO(#283): Improve how `utilityContext` is managed
 	utilityContext    modules.UtilityContext
 	paceMaker         Pacemaker
 	leaderElectionMod leader_election.LeaderElectionModule
 
-	// DEPRECATE: Remove later when we build a shared/proper/injected logger
-	logPrefix string
-
-	// TECHDEBT: Move this over to use the txIndexer
-	messagePool map[typesCons.HotstuffStep][]*typesCons.HotstuffMessage
+	logPrefix   string                                                  // TODO(design): Remove later when we build a shared/proper/injected logger
+	MessagePool map[typesCons.HotstuffStep][]*typesCons.HotstuffMessage // TODO(design): Move this over to the persistence module or elsewhere?
+	// TODO(andrew): Explain (or remove) why have an explicit `MaxBlockBytes` if we are already storing a reference to `consCfg` above?
+	// TODO(andrew): This needs to be updated every time the utility module changes this value. It can be accessed via the "application specific bus" (mimicking the intermodule interface in ABCI)
+	MaxBlockBytes uint64
 }
 
 func Create(configPath, genesisPath string, useRandomPK bool) (modules.ConsensusModule, error) {
@@ -114,32 +112,32 @@ func Create(configPath, genesisPath string, useRandomPK bool) (modules.Consensus
 	m := &ConsensusModule{
 		bus: nil,
 
-		privateKey:  privateKey.(cryptoPocket.Ed25519PrivateKey),
-		consCfg:     cfg,
-		consGenesis: genesis,
+		privateKey: privateKey.(cryptoPocket.Ed25519PrivateKey),
+		consCfg:    cfg,
 
 		Height: 0,
 		Round:  0,
 		Step:   NewRound,
 		Block:  nil,
 
-		highPrepareQC: nil,
-		lockedQC:      nil,
+		HighPrepareQC: nil,
+		LockedQC:      nil,
 
-		nodeId:         valIdMap[address],
+		NodeId:         valIdMap[address],
 		LeaderId:       nil,
-		valAddrToIdMap: valIdMap,
-		idToValAddrMap: idValMap,
+		ValAddrToIdMap: valIdMap,
+		IdToValAddrMap: idValMap,
 
-		lastAppHash:  "",
+		appHash:      "",
 		validatorMap: valMap,
 
 		utilityContext:    nil,
 		paceMaker:         paceMaker,
 		leaderElectionMod: leaderElectionMod,
 
-		logPrefix:   DefaultLogPrefix,
-		messagePool: make(map[typesCons.HotstuffStep][]*typesCons.HotstuffMessage),
+		logPrefix:     DefaultLogPrefix,
+		MessagePool:   make(map[typesCons.HotstuffStep][]*typesCons.HotstuffMessage),
+		MaxBlockBytes: genesis.GetMaxBlockBytes(),
 	}
 
 	// TODO(olshansky): Look for a way to avoid doing this.
@@ -226,22 +224,70 @@ func (m *ConsensusModule) SetBus(pocketBus modules.Bus) {
 	m.leaderElectionMod.SetBus(pocketBus)
 }
 
+func (m *ConsensusModule) loadPersistedState() error {
+	persistenceContext, err := m.GetBus().GetPersistenceModule().NewReadContext(-1) // Unknown height
+	if err != nil {
+		return nil
+	}
+	defer persistenceContext.Close()
+
+	latestHeight, err := persistenceContext.GetLatestBlockHeight()
+	if err != nil || latestHeight == 0 {
+		m.nodeLog("TODO: State sync not implement")
+		return nil
+	}
+
+	appHash, err := persistenceContext.GetBlockHash(int64(latestHeight))
+	if err != nil {
+		return fmt.Errorf("error getting block hash for height %d even though it's in the database: %s", latestHeight, err)
+	}
+
+	// TODO: Populate the rest of the state from the persistence module: validator set, quorum cert, last block hash, etc...
+	m.Height = uint64(latestHeight) + 1 // +1 because the height of the consensus module is where it is actively participating in consensus
+	m.appHash = string(appHash)
+
+	m.nodeLog(fmt.Sprintf("Starting node at height %d", latestHeight))
+	return nil
+}
+
+// TODO(discuss): Low priority design: think of a way to make `hotstuff_*` files be a sub-package under consensus.
+// This is currently not possible because functions tied to the `ConsensusModule`
+// struct (implementing the ConsensusModule module), which spans multiple files.
+/*
+TODO(discuss): The reason we do not assign both the leader and the replica handlers
+to the leader (which should also act as a replica when it is a leader) is because it
+can create a weird inconsistent state (e.g. both the replica and leader try to restart
+the Pacemaker timeout). This requires additional "replica-like" logic in the leader
+handler which has both pros and cons:
+	Pros:
+		* The leader can short-circuit and optimize replica related logic
+		* Avoids additional code flowing through the P2P pipeline
+		* Allows for micro-optimizations
+	Cons:
+		* The leader's "replica related logic" requires an additional code path
+		* Code is less "generalizable" and therefore potentially more error prone
+*/
+
+// TODO(olshansky): Should we just make these singletons or embed them directly in the ConsensusModule?
+type HotstuffMessageHandler interface {
+	HandleNewRoundMessage(*ConsensusModule, *typesCons.HotstuffMessage)
+	HandlePrepareMessage(*ConsensusModule, *typesCons.HotstuffMessage)
+	HandlePrecommitMessage(*ConsensusModule, *typesCons.HotstuffMessage)
+	HandleCommitMessage(*ConsensusModule, *typesCons.HotstuffMessage)
+	HandleDecideMessage(*ConsensusModule, *typesCons.HotstuffMessage)
+}
+
 func (m *ConsensusModule) HandleMessage(message *anypb.Any) error {
 	m.m.Lock()
 	defer m.m.Unlock()
 	switch message.MessageName() {
 	case HotstuffMessage:
-		msg, err := codec.GetCodec().FromAny(message)
+		var hotstuffMessage typesCons.HotstuffMessage
+		err := anypb.UnmarshalTo(message, &hotstuffMessage, proto.UnmarshalOptions{})
 		if err != nil {
 			return err
 		}
-		hotstuffMessage, ok := msg.(*typesCons.HotstuffMessage)
-		if !ok {
-			return fmt.Errorf("failed to cast message to HotstuffMessage")
-		}
-		if err := m.handleHotstuffMessage(hotstuffMessage); err != nil {
-			return err
-		}
+		m.handleHotstuffMessage(&hotstuffMessage)
 	case UtilityMessage:
 		panic("[WARN] UtilityMessage handling is not implemented by consensus yet...")
 	default:
@@ -251,8 +297,36 @@ func (m *ConsensusModule) HandleMessage(message *anypb.Any) error {
 	return nil
 }
 
+func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage) {
+	m.nodeLog(typesCons.DebugHandlingHotstuffMessage(msg))
+
+	// Liveness & safety checks
+	if err := m.paceMaker.ValidateMessage(msg); err != nil {
+		// If a replica is not a leader for this round, but has already determined a leader,
+		// and continues to receive NewRound messages, we avoid logging the "message discard"
+		// because it creates unnecessary spam.
+		if !(m.LeaderId != nil && !m.isLeader() && msg.Step == NewRound) {
+			m.nodeLog(typesCons.WarnDiscardHotstuffMessage(msg, err.Error()))
+		}
+		return
+	}
+
+	// Need to execute leader election if there is no leader and we are in a new round.
+	if m.Step == NewRound && m.isLeaderUnknown() {
+		m.electNextLeader(msg)
+	}
+
+	if m.isReplica() {
+		replicaHandlers[msg.Step](m, msg)
+		return
+	}
+
+	// Note that the leader also acts as a replica, but this logic is implemented in the underlying code.
+	leaderHandlers[msg.Step](m, msg)
+}
+
 func (m *ConsensusModule) AppHash() string {
-	return m.lastAppHash
+	return m.appHash
 }
 
 func (m *ConsensusModule) CurrentHeight() uint64 {
@@ -262,34 +336,3 @@ func (m *ConsensusModule) CurrentHeight() uint64 {
 func (m *ConsensusModule) ValidatorMap() modules.ValidatorMap {
 	return typesCons.ValidatorMapToModulesValidatorMap(m.validatorMap)
 }
-
-// TODO(#256): Currently only used for testing purposes
-func (m *ConsensusModule) SetUtilityContext(utilityContext modules.UtilityContext) {
-	m.utilityContext = utilityContext
-}
-
-// TODO: Populate the entire state from the persistence module: validator set, quorum cert, last block hash, etc...
-func (m *ConsensusModule) loadPersistedState() error {
-	persistenceContext, err := m.GetBus().GetPersistenceModule().NewReadContext(-1) // Unknown height
-	if err != nil {
-		return nil
-	}
-	defer persistenceContext.Close()
-
-	latestHeight, err := persistenceContext.GetLatestBlockHeight()
-	if err != nil || latestHeight == 0 {
-		m.nodeLog("TODO: State sync not implemented yet")
-		return nil
-	}
-
-	appHash, err := persistenceContext.GetBlockHash(int64(latestHeight))
-	if err != nil {
-		return fmt.Errorf("error getting block hash for height %d even though it's in the database: %s", latestHeight, err)
-	}
-
-	m.Height = uint64(latestHeight) + 1 // +1 because the height of the consensus module is where it is actively participating in consensus
-	m.lastAppHash = string(appHash)
-
-	m.nodeLog(fmt.Sprintf("Starting node at height %d", latestHeight))
-	return nil
-}
diff --git a/consensus/pacemaker.go b/consensus/pacemaker.go
index ba4202897..21abdbdab 100644
--- a/consensus/pacemaker.go
+++ b/consensus/pacemaker.go
@@ -183,7 +183,7 @@ func (p *paceMaker) InterruptRound() {
 	p.consensusMod.nodeLog(typesCons.PacemakerInterrupt(p.consensusMod.CurrentHeight(), p.consensusMod.Step, p.consensusMod.Round))
 
 	p.consensusMod.Round++
-	p.startNextView(p.consensusMod.highPrepareQC, false)
+	p.startNextView(p.consensusMod.HighPrepareQC, false)
 }
 
 func (p *paceMaker) NewHeight() {
diff --git a/consensus/types/errors.go b/consensus/types/errors.go
index 5368ee1bf..e3f4d3987 100644
--- a/consensus/types/errors.go
+++ b/consensus/types/errors.go
@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/pokt-network/pocket/shared/codec"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -72,11 +71,11 @@ func ElectedSelfAsNewLeader(address string, nodeId NodeId, height, round uint64)
 }
 
 func SendingMessage(msg *HotstuffMessage, nodeId NodeId) string {
-	return fmt.Sprintf("Sending %s message to %d", StepToString[msg.GetStep()], nodeId)
+	return fmt.Sprintf("Sending %s message to %d", StepToString[msg.Step], nodeId)
 }
 
 func BroadcastingMessage(msg *HotstuffMessage) string {
-	return fmt.Sprintf("Broadcasting message for %s step", StepToString[msg.GetStep()])
+	return fmt.Sprintf("Broadcasting message for %s step", StepToString[msg.Step])
 }
 
 func WarnInvalidPartialSigInQC(address string, nodeId NodeId) string {
@@ -84,7 +83,7 @@ func WarnInvalidPartialSigInQC(address string, nodeId NodeId) string {
 }
 
 func WarnMissingPartialSig(msg *HotstuffMessage) string {
-	return fmt.Sprintf("[WARN] No partial signature found for step %s which should not happen...", StepToString[msg.GetStep()])
+	return fmt.Sprintf("[WARN] No partial signature found for step %s which should not happen...", StepToString[msg.Step])
 }
 
 func WarnDiscardHotstuffMessage(_ *HotstuffMessage, reason string) string {
@@ -96,7 +95,7 @@ func WarnUnexpectedMessageInPool(_ *HotstuffMessage, height uint64, step Hotstuf
 }
 
 func WarnIncompletePartialSig(ps *PartialSignature, msg *HotstuffMessage) string {
-	return fmt.Sprintf("[WARN] Partial signature is incomplete for step %s which should not happen...", StepToString[msg.GetStep()])
+	return fmt.Sprintf("[WARN] Partial signature is incomplete for step %s which should not happen...", StepToString[msg.Step])
 }
 
 func DebugTogglePacemakerManualMode(mode string) string {
@@ -109,13 +108,12 @@ func DebugNodeState(state ConsensusNodeState) string {
 
 func DebugHandlingHotstuffMessage(msg *HotstuffMessage) string {
 	// TODO(olshansky): Add source and destination NodeId of message here
-	return fmt.Sprintf("[DEBUG] Handling message w/ Height: %d; Type: %s; Round: %d.", msg.Height, StepToString[msg.GetStep()], msg.Round)
+	return fmt.Sprintf("[DEBUG] Handling message w/ Height: %d; Type: %s; Round: %d.", msg.Height, StepToString[msg.Step], msg.Round)
 }
 
 // Errors
 const (
 	nilBLockError                               = "block is nil"
-	blockExistsError                            = "block exists but should be nil"
 	nilBLockProposalError                       = "block should never be nil when creating a proposal message"
 	nilBLockVoteError                           = "block should never be nil when creating a vote message for a proposal"
 	proposalNotValidInPrepareError              = "proposal is not valid in the PREPARE step"
@@ -124,8 +122,7 @@ const (
 	nilBlockInQCError                           = "QC must contain a non nil block"
 	nilThresholdSigInQCError                    = "QC must contains a non nil threshold signature"
 	notEnoughSignaturesError                    = "did not receive enough partial signature"
-	nodeIsLockedOnPastHeightQCError             = "node is locked on a QC from a past height"
-	nodeIsLockedOnPastRoundQCError              = "node is locked on a QC from a past round"
+	nodeIsLockedOnPastQCError                   = "node is locked on a QC from the past"
 	unhandledProposalCaseError                  = "unhandled proposal validation check"
 	unnecessaryPartialSigForNewRoundError       = "newRound messages do not need a partial signature"
 	unnecessaryPartialSigForLeaderProposalError = "leader proposals do not need a partial signature"
@@ -145,6 +142,7 @@ const (
 	prepareBlockError                           = "could not prepare block"
 	commitBlockError                            = "could not commit block"
 	replicaPrepareBlockError                    = "node should not call `prepareBlock` if it is not a leader"
+	leaderErrApplyBlock                         = "node should not call `applyBlock` if it is leader"
 	blockSizeTooLargeError                      = "block size is too large"
 	sendMessageError                            = "error sending message"
 	broadcastMessageError                       = "error broadcasting message"
@@ -155,7 +153,6 @@ const (
 
 var (
 	ErrNilBlock                               = errors.New(nilBLockError)
-	ErrBlockExists                            = errors.New(blockExistsError)
 	ErrNilBlockProposal                       = errors.New(nilBLockProposalError)
 	ErrNilBlockVote                           = errors.New(nilBLockVoteError)
 	ErrProposalNotValidInPrepare              = errors.New(proposalNotValidInPrepareError)
@@ -164,8 +161,7 @@ var (
 	ErrNilBlockInQC                           = errors.New(nilBlockInQCError)
 	ErrNilThresholdSigInQC                    = errors.New(nilThresholdSigInQCError)
 	ErrNotEnoughSignatures                    = errors.New(notEnoughSignaturesError)
-	ErrNodeLockedPastHeight                   = errors.New(nodeIsLockedOnPastHeightQCError)
-	ErrNodeLockedPastRound                    = errors.New(nodeIsLockedOnPastRoundQCError)
+	ErrNodeIsLockedOnPastQC                   = errors.New(nodeIsLockedOnPastQCError)
 	ErrUnhandledProposalCase                  = errors.New(unhandledProposalCaseError)
 	ErrUnnecessaryPartialSigForNewRound       = errors.New(unnecessaryPartialSigForNewRoundError)
 	ErrUnnecessaryPartialSigForLeaderProposal = errors.New(unnecessaryPartialSigForLeaderProposalError)
@@ -181,6 +177,7 @@ var (
 	ErrPrepareBlock                           = errors.New(prepareBlockError)
 	ErrCommitBlock                            = errors.New(commitBlockError)
 	ErrReplicaPrepareBlock                    = errors.New(replicaPrepareBlockError)
+	ErrLeaderApplyBLock                       = errors.New(leaderErrApplyBlock)
 	ErrSendMessage                            = errors.New(sendMessageError)
 	ErrBroadcastMessage                       = errors.New(broadcastMessageError)
 	ErrCreateConsensusMessage                 = errors.New(createConsensusMessageError)
@@ -206,7 +203,7 @@ func ErrMissingValidator(address string, nodeId NodeId) error {
 
 func ErrValidatingPartialSig(senderAddr string, senderNodeId NodeId, msg *HotstuffMessage, pubKey string) error {
 	return fmt.Errorf("%s: Sender: %s (%d); Height: %d; Step: %s; Round: %d; SigHash: %s; BlockHash: %s; PubKey: %s",
-		invalidPartialSignatureError, senderAddr, senderNodeId, msg.Height, StepToString[msg.GetStep()], msg.Round, string(msg.GetPartialSignature().Signature), protoHash(msg.Block), pubKey)
+		invalidPartialSignatureError, senderAddr, senderNodeId, msg.Height, StepToString[msg.Step], msg.Round, string(msg.GetPartialSignature().Signature), protoHash(msg.Block), pubKey)
 }
 
 func ErrPacemakerUnexpectedMessageHeight(err error, heightCurrent, heightMessage uint64) error {
@@ -214,7 +211,7 @@ func ErrPacemakerUnexpectedMessageHeight(err error, heightCurrent, heightMessage
 }
 
 func ErrPacemakerUnexpectedMessageStepRound(err error, step HotstuffStep, round uint64, msg *HotstuffMessage) error {
-	return fmt.Errorf("%s: Current (step, round): (%s, %d); Message (step, round): (%s, %d)", err, StepToString[step], round, StepToString[msg.GetStep()], msg.Round)
+	return fmt.Errorf("%s: Current (step, round): (%s, %d); Message (step, round): (%s, %d)", err, StepToString[step], round, StepToString[msg.Step], msg.Round)
 }
 
 func ErrUnknownConsensusMessageType(msg interface{}) error {
@@ -238,7 +235,7 @@ func ErrLeaderElection(msg *HotstuffMessage) error {
 }
 
 func protoHash(m proto.Message) string {
-	b, err := codec.GetCodec().Marshal(m)
+	b, err := proto.Marshal(m)
 	if err != nil {
 		log.Fatalf("Could not marshal proto message: %v", err)
 	}
diff --git a/consensus/types/proto/block.proto b/consensus/types/proto/block.proto
index b18d8dfa7..6024bcea4 100644
--- a/consensus/types/proto/block.proto
+++ b/consensus/types/proto/block.proto
@@ -5,7 +5,7 @@ option go_package = "github.com/pokt-network/pocket/consensus/types";
 
 import "google/protobuf/timestamp.proto";
 
-// TECHDEBT: Re-evaluate some tendermint legacy fields
+// TODO (Team) Discuss all tendermint legacy
 message BlockHeader {
   int64 height = 1;
   string hash = 2;
diff --git a/consensus/types/proto/hotstuff_types.proto b/consensus/types/proto/hotstuff_types.proto
index c289694c8..b1f7c9b4d 100644
--- a/consensus/types/proto/hotstuff_types.proto
+++ b/consensus/types/proto/hotstuff_types.proto
@@ -18,7 +18,7 @@ enum HotstuffStep {
 
 enum HotstuffMessageType {
     HOTSTUFF_MESSAGE_UNKNOWN = 0;
-    HOTSTUFF_MESSAGE_PROPOSE = 1;
+    HOTSTUFF_MESAGE_PROPOSE = 1;
     HOTSTUFF_MESSAGE_VOTE = 2;
 }
 
diff --git a/consensus/types/types.go b/consensus/types/types.go
index 86b9a0624..36896cfaf 100644
--- a/consensus/types/types.go
+++ b/consensus/types/types.go
@@ -1,10 +1,8 @@
 package types
 
-// TODO: Split this file into multiple types files.
 import (
-	"sort"
-
 	"github.com/pokt-network/pocket/shared/modules"
+	"sort"
 )
 
 type NodeId uint64
diff --git a/go.mod b/go.mod
index 30f937624..1aa121424 100644
--- a/go.mod
+++ b/go.mod
@@ -20,7 +20,6 @@ require (
 )
 
 require (
-	github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884
 	github.com/benbjohnson/clock v1.3.0
 	github.com/dgraph-io/badger/v3 v3.2103.2
 	github.com/jackc/pgconn v1.11.0
@@ -39,7 +38,7 @@ require (
 	github.com/docker/go-connections v0.4.0 // indirect
 	github.com/docker/go-units v0.4.0 // indirect
 	github.com/dustin/go-humanize v1.0.0 // indirect
-	github.com/gogo/protobuf v1.3.2
+	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b // indirect
 	github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
diff --git a/go.sum b/go.sum
index f7e72a772..8d255a0b5 100644
--- a/go.sum
+++ b/go.sum
@@ -63,8 +63,6 @@ github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+Ce
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/boombuler/barcode v1.0.0/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8=
-github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884 h1:iRNKw2WmAbVgGMNYzDH5Y2yY3+jyxwEK9Hc5pwIjZAE=
-github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884/go.mod h1:/sdYDakowo/XaxS2Fl7CBqtuf/O2uTqF2zmAUFAtAiw=
 github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4=
 github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
diff --git a/persistence/application.go b/persistence/application.go
index 755288155..78750a7b6 100644
--- a/persistence/application.go
+++ b/persistence/application.go
@@ -4,66 +4,15 @@ import (
 	"encoding/hex"
 
 	"github.com/pokt-network/pocket/persistence/types"
-	"google.golang.org/protobuf/proto"
-
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
-func (p PostgresContext) UpdateApplicationsTree(apps []modules.Actor) error {
-	for _, app := range apps {
-		bzAddr, err := hex.DecodeString(app.GetAddress())
-		if err != nil {
-			return err
-		}
-
-		appBz, err := proto.Marshal(app.(*types.Actor))
-		if err != nil {
-			return err
-		}
-
-		// OPTIMIZE: This is the only line unique to `Application`
-		if _, err := p.MerkleTrees[appMerkleTree].Update(bzAddr, appBz); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (p PostgresContext) getApplicationsUpdatedAtHeight(height int64) (apps []*types.Actor, err error) {
-	// OPTIMIZE: This is the only line unique to `Application`
-	actors, err := p.GetActorsUpdated(types.ApplicationActor, height)
-	if err != nil {
-		return nil, err
-	}
-
-	apps = make([]*types.Actor, len(actors))
-	for _, actor := range actors {
-		app := &types.Actor{
-			ActorType:       types.ActorType_App,
-			Address:         actor.Address,
-			PublicKey:       actor.PublicKey,
-			Chains:          actor.Chains,
-			GenericParam:    actor.ActorSpecificParam,
-			StakedAmount:    actor.StakedTokens,
-			PausedHeight:    actor.PausedHeight,
-			UnstakingHeight: actor.UnstakingHeight,
-			Output:          actor.OutputAddress,
-		}
-		apps = append(apps, app)
-	}
-	return
-}
-
 func (p PostgresContext) GetAppExists(address []byte, height int64) (exists bool, err error) {
 	return p.GetExists(types.ApplicationActor, address, height)
 }
 
 func (p PostgresContext) GetApp(address []byte, height int64) (operator, publicKey, stakedTokens, maxRelays, outputAddress string, pauseHeight, unstakingHeight int64, chains []string, err error) {
 	actor, err := p.GetActor(types.ApplicationActor, address, height)
-	if err != nil {
-		return
-	}
 	operator = actor.Address
 	publicKey = actor.PublicKey
 	stakedTokens = actor.StakedTokens
diff --git a/persistence/block.go b/persistence/block.go
index 5efa1b71e..aaee96364 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -5,7 +5,6 @@ import (
 	"encoding/hex"
 	"log"
 
-	"github.com/gogo/protobuf/proto"
 	"github.com/pokt-network/pocket/persistence/types"
 )
 
@@ -50,44 +49,21 @@ func (p PostgresContext) StoreTransaction(transactionProtoBytes []byte) error {
 	return nil
 }
 
-func (p PostgresContext) insertBlock(block *types.Block) error {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return err
-	}
-
-	_, err = tx.Exec(ctx, types.InsertBlockQuery(block.Height, block.Hash, block.ProposerAddress, block.QuorumCertificate))
-	return err
+func (p PostgresContext) StoreBlock(blockProtoBytes []byte) error {
+	// INVESTIGATE: Note that we are writing this directly to the blockStore. Depending on how
+	// the use of the PostgresContext evolves, we may need to write this to `ContextStore` and copy
+	// over to `BlockStore` when the block is committed.
+	return p.blockstore.Put(heightToBytes(p.Height), blockProtoBytes)
 }
 
-func (p PostgresContext) storeBlock(block *types.Block) error {
-	blockBz, err := proto.Marshal(block)
+func (p PostgresContext) InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error {
+	ctx, tx, err := p.GetCtxAndTx()
 	if err != nil {
 		return err
 	}
 
-	return p.blockstore.Put(heightToBytes(p.Height), blockBz)
-}
-
-func (p PostgresContext) getBlock(proposerAddr []byte, quorumCert []byte) (*types.Block, error) {
-	prevHash, err := p.GetBlockHash(p.Height - 1)
-	if err != nil {
-		return nil, err
-	}
-
-	// TODO: get this from the transactions that were store via `StoreTransaction`
-	txs := make([][]byte, 0)
-
-	block := &types.Block{
-		Height:            uint64(p.Height),
-		Hash:              string(p.stateHash),
-		PrevHash:          string(prevHash),
-		ProposerAddress:   proposerAddr,
-		QuorumCertificate: quorumCert,
-		Transactions:      txs,
-	}
-
-	return block, nil
+	_, err = tx.Exec(ctx, types.InsertBlockQuery(height, hash, proposerAddr, quorumCert))
+	return err
 }
 
 // CLEANUP: Should this be moved to a shared directory?
diff --git a/persistence/context.go b/persistence/context.go
index 8224a229a..fd44e3af1 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -15,39 +15,25 @@ func (p PostgresContext) RollbackToSavePoint(bytes []byte) error {
 	return p.GetTx().Rollback(context.TODO())
 }
 
-func (p PostgresContext) UpdateAppHash() ([]byte, error) {
-	if err := p.updateStateHash(); err != nil {
-		return nil, err
-	}
-	return p.stateHash, nil
+func (p PostgresContext) AppHash() ([]byte, error) {
+	log.Println("TODO: AppHash not implemented")
+	return []byte("A real app hash, I am not"), nil
 }
 
 func (p PostgresContext) Reset() error {
 	panic("TODO: PostgresContext Reset not implemented")
 }
 
-func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
+func (p PostgresContext) Commit() error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
-	block, err := p.getBlock(proposerAddr, quorumCert)
-	if err != nil {
-		return err
-	}
-
-	if err := p.insertBlock(block); err != nil {
-		return err
-	}
-
-	if err := p.storeBlock(block); err != nil {
-		return err
-	}
-
 	ctx := context.TODO()
-	if err := p.GetTx().Commit(ctx); err != nil {
+	if err := p.GetTx().Commit(context.TODO()); err != nil {
 		return err
 	}
 	if err := p.conn.Close(ctx); err != nil {
 		log.Println("[TODO][ERROR] Implement connection pooling. Error when closing DB connecting...", err)
+
 	}
 	return nil
 }
diff --git a/persistence/db.go b/persistence/db.go
index b8a974939..3a495596c 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -7,7 +7,6 @@ import (
 
 	"github.com/pokt-network/pocket/persistence/types"
 
-	"github.com/celestiaorg/smt"
 	"github.com/jackc/pgconn"
 	"github.com/jackc/pgx/v4"
 	"github.com/pokt-network/pocket/persistence/kvstore"
@@ -41,13 +40,6 @@ type PostgresContext struct {
 	conn       *pgx.Conn
 	tx         pgx.Tx
 	blockstore kvstore.KVStore
-
-	stateHash []byte
-	// IMPROVE: Depending on how the use of `PostgresContext` evolves, we may be able to get
-	// access to these directly via the postgres module.
-	PostgresDB  *pgx.Conn
-	BlockStore  kvstore.KVStore                      // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context)
-	MerkleTrees map[MerkleTree]*smt.SparseMerkleTree // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context)
 }
 
 func (pg *PostgresContext) GetCtxAndTx() (context.Context, pgx.Tx, error) {
diff --git a/persistence/debug.go b/persistence/debug.go
index e0e3b6e5e..3fdc583a4 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -44,7 +44,7 @@ func (m *PersistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 
 func (m *PersistenceModule) clearState(_ *debug.DebugMessage) {
 	context, err := m.NewRWContext(-1)
-	defer context.Commit(nil, nil)
+	defer context.Commit()
 	if err != nil {
 		log.Printf("Error creating new context: %s \n", err)
 		return
diff --git a/persistence/genesis.go b/persistence/genesis.go
index a6eefaa90..1c7e82f14 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -149,7 +149,7 @@ func (m *PersistenceModule) populateGenesisState(state *types.PersistenceGenesis
 		log.Fatalf("an error occurred initializing flags: %s", err.Error())
 	}
 
-	if err = rwContext.Commit(nil, nil); err != nil {
+	if err = rwContext.Commit(); err != nil {
 		log.Fatalf("an error occurred during commit() on genesis state %s ", err.Error())
 	}
 }
@@ -316,7 +316,7 @@ func (p PostgresContext) GetAllFishermen(height int64) (f []modules.Actor, err e
 	return
 }
 
-// CONSOLIDATE: Consolidate `types.BaseActor` with `types.Actor`
+// TODO (Team) deprecate with interface #163 <Bumped to #149> as #163 is getting large
 func (p PostgresContext) BaseActorToActor(ba types.BaseActor, actorType types.ActorType) *types.Actor {
 	actor := new(types.Actor)
 	actor.ActorType = actorType
diff --git a/persistence/kvstore/kvstore.go b/persistence/kvstore/kvstore.go
index 8636e4519..24613afc9 100644
--- a/persistence/kvstore/kvstore.go
+++ b/persistence/kvstore/kvstore.go
@@ -1,47 +1,33 @@
 package kvstore
 
 import (
-	"errors"
 	"log"
 
-	"github.com/celestiaorg/smt"
 	badger "github.com/dgraph-io/badger/v3"
 )
 
+// CLEANUP: move this structure to a shared module
 type KVStore interface {
 	// Lifecycle methods
 	Stop() error
 
 	// Accessors
 	// TODO: Add a proper iterator interface
+	Put(key []byte, value []byte) error
+	Get(key []byte) ([]byte, error)
 	// TODO: Add pagination for `GetAll`
 	GetAll(prefixKey []byte, descending bool) ([][]byte, error)
-
 	Exists(key []byte) (bool, error)
 	ClearAll() error
-
-	// Same interface as in `smt.MapStore``
-	Put(key, value []byte) error
-	Get(key []byte) ([]byte, error)
-	Delete(key []byte) error
 }
 
 var _ KVStore = &badgerKVStore{}
-var _ smt.MapStore = &badgerKVStore{}
-
-var (
-	ErrKVStoreExists    = errors.New("kvstore already exists")
-	ErrKVStoreNotExists = errors.New("kvstore does not exist")
-)
 
 type badgerKVStore struct {
 	db *badger.DB
 }
 
-// REFACTOR: Loads or creates a badgerDb at `path`. This may potentially need to be refactored
-// into `NewKVStore` and `LoadKVStore` depending on how state sync evolves by leveraging `os.Stat`
-// on the file path.
-func OpenKVStore(path string) (KVStore, error) {
+func NewKVStore(path string) (KVStore, error) {
 	db, err := badger.Open(badger.DefaultOptions(path))
 	if err != nil {
 		return nil, err
@@ -57,7 +43,7 @@ func NewMemKVStore() KVStore {
 	return badgerKVStore{db: db}
 }
 
-func (store badgerKVStore) Put(key, value []byte) error {
+func (store badgerKVStore) Put(key []byte, value []byte) error {
 	tx := store.db.NewTransaction(true)
 	defer tx.Discard()
 
@@ -69,12 +55,6 @@ func (store badgerKVStore) Put(key, value []byte) error {
 	return tx.Commit()
 }
 
-// CONSOLIDATE: We might be able to remove the `KVStore` interface altogether if we end up using `smt.MapStore`
-// A wrapper around `Put` to conform to the `smt.MapStore` interface
-func (store *badgerKVStore) Set(key, value []byte) error {
-	return store.Put(key, value)
-}
-
 func (store badgerKVStore) Get(key []byte) ([]byte, error) {
 	tx := store.db.NewTransaction(false)
 	defer tx.Discard()
@@ -96,11 +76,6 @@ func (store badgerKVStore) Get(key []byte) ([]byte, error) {
 	return value, nil
 }
 
-func (store badgerKVStore) Delete(key []byte) error {
-	log.Fatalf("badgerKVStore.Delete not implemented yet")
-	return nil
-}
-
 func (store badgerKVStore) GetAll(prefix []byte, descending bool) (values [][]byte, err error) {
 	// INVESTIGATE: research `badger.views` for further improvements and optimizations
 	txn := store.db.NewTransaction(false)
diff --git a/persistence/module.go b/persistence/module.go
index 6761bb22b..33bd827bd 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -7,10 +7,10 @@ import (
 	"io/ioutil"
 	"log"
 
-	"github.com/celestiaorg/smt"
+	"github.com/pokt-network/pocket/persistence/types"
+
 	"github.com/jackc/pgx/v4"
 	"github.com/pokt-network/pocket/persistence/kvstore"
-	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 	"github.com/pokt-network/pocket/shared/test_artifacts"
 )
@@ -26,19 +26,10 @@ type PersistenceModule struct {
 	postgresURL string
 	nodeSchema  string
 	genesisPath string
+	blockStore  kvstore.KVStore // INVESTIGATE: We may need to create a custom `BlockStore` package in the future
 
 	// TECHDEBT: Need to implement context pooling (for writes), timeouts (for read & writes), etc...
 	writeContext *PostgresContext // only one write context is allowed at a time
-
-	// The connection to the PostgreSQL database
-	postgresConn *pgx.Conn
-	// A reference to the block key-value store
-	// INVESTIGATE: We may need to create a custom `BlockStore` package in the future.
-	blockStore kvstore.KVStore
-	// A mapping of context IDs to persistence contexts
-	// contexts map[contextId]modules.PersistenceRWContext
-	// Merkle trees
-	trees map[MerkleTree]*smt.SparseMerkleTree
 }
 
 const (
@@ -51,10 +42,8 @@ func Create(configPath, genesisPath string) (modules.PersistenceModule, error) {
 	if err != nil {
 		return nil, err
 	}
-
 	cfg := c.(*types.PersistenceConfig)
 	g, err := m.InitGenesis(genesisPath)
-
 	if err != nil {
 		return nil, err
 	}
@@ -80,20 +69,8 @@ func Create(configPath, genesisPath string) (modules.PersistenceModule, error) {
 		genesisPath:  genesisPath,
 		blockStore:   blockStore,
 		writeContext: nil,
-		// contexts:     make(map[contextId]modules.PersistenceContext),
-		trees: make(map[MerkleTree]*smt.SparseMerkleTree),
 	}
 
-	// DISCUSS_IN_THIS_COMMIT: We've been using the module function pattern, but this making `initializeTrees`
-	// be able to create and/or load trees outside the scope of the persistence module makes it easier to test.
-	trees, err := newMerkleTrees()
-	if err != nil {
-		return nil, err
-	}
-
-	// TODO_IN_THIS_COMMIT: load trees from state
-	persistenceMod.trees = trees
-
 	// Determine if we should hydrate the genesis db or use the current state of the DB attached
 	if shouldHydrateGenesis, err := persistenceMod.shouldHydrateGenesisDb(); err != nil {
 		return nil, err
@@ -237,7 +214,7 @@ func initializeBlockStore(blockStorePath string) (kvstore.KVStore, error) {
 	if blockStorePath == "" {
 		return kvstore.NewMemKVStore(), nil
 	}
-	return kvstore.OpenKVStore(blockStorePath)
+	return kvstore.NewKVStore(blockStorePath)
 }
 
 // TODO(drewsky): Simplify and externalize the logic for whether genesis should be populated and
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
index 8eac77562..9f2c19a00 100644
--- a/persistence/shared_sql.go
+++ b/persistence/shared_sql.go
@@ -44,36 +44,6 @@ func (p *PostgresContext) GetExists(actorSchema types.ProtocolActorSchema, addre
 	return
 }
 
-func (p *PostgresContext) GetActorsUpdated(actorSchema types.ProtocolActorSchema, height int64) (actors []types.BaseActor, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return
-	}
-
-	rows, err := tx.Query(ctx, actorSchema.GetUpdatedAtHeightQuery(height))
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	// OPTIMIZE: Consolidate logic with `GetActor` to reduce code footprint
-	var addr string
-	for rows.Next() {
-		if err = rows.Scan(&addr); err != nil {
-			return
-		}
-
-		actor, err := p.GetActor(actorSchema, []byte(addr), height)
-		if err != nil {
-			return nil, err
-		}
-
-		actors = append(actors, actor)
-	}
-
-	return
-}
-
 func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, address []byte, height int64) (actor types.BaseActor, err error) {
 	ctx, tx, err := p.GetCtxAndTx()
 	if err != nil {
@@ -87,16 +57,10 @@ func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, addres
 	return p.GetChainsForActor(ctx, tx, actorSchema, actor, height)
 }
 
-// IMPORTANT: Need to consolidate `persistence/types.BaseActor` with `persistence/genesisTypes.Actor`
 func (p *PostgresContext) GetActorFromRow(row pgx.Row) (actor types.BaseActor, height int64, err error) {
 	err = row.Scan(
-		&actor.Address,
-		&actor.PublicKey,
-		&actor.StakedTokens,
-		&actor.ActorSpecificParam,
-		&actor.OutputAddress,
-		&actor.PausedHeight,
-		&actor.UnstakingHeight,
+		&actor.Address, &actor.PublicKey, &actor.StakedTokens, &actor.ActorSpecificParam,
+		&actor.OutputAddress, &actor.PausedHeight, &actor.UnstakingHeight,
 		&height)
 	return
 }
diff --git a/persistence/test/module_test.go b/persistence/test/module_test.go
index ccb7bd37f..3bee636c5 100644
--- a/persistence/test/module_test.go
+++ b/persistence/test/module_test.go
@@ -18,14 +18,12 @@ func TestPersistenceContextParallelReadWrite(t *testing.T) {
 	poolAddress := []byte("address")
 	originalAmount := "15"
 	modifiedAmount := "10"
-	proposer := []byte("proposer")
-	quorumCert := []byte("quorumCert")
 
 	// setup a write context, insert a pool and commit it
 	context, err := testPersistenceMod.NewRWContext(0)
 	require.NoError(t, err)
 	require.NoError(t, context.InsertPool(poolName, poolAddress, originalAmount))
-	require.NoError(t, context.Commit(proposer, quorumCert))
+	require.NoError(t, context.Commit())
 
 	// verify the insert in the previously committed context worked
 	contextA, err := testPersistenceMod.NewRWContext(0)
diff --git a/persistence/types/base_actor.go b/persistence/types/base_actor.go
index 1c73da9a7..9514b15eb 100644
--- a/persistence/types/base_actor.go
+++ b/persistence/types/base_actor.go
@@ -1,6 +1,5 @@
 package types
 
-// IMPROVE: Move schema related functions to a separate sub-package
 import "github.com/pokt-network/pocket/shared/modules"
 
 // TECHDEBT: Consider moving this to a protobuf. This struct was created to make testing simple of protocol actors that
@@ -61,10 +60,6 @@ func (actor *BaseProtocolActorSchema) GetChainsTableSchema() string {
 	return ProtocolActorChainsTableSchema(actor.chainsHeightConstraintName)
 }
 
-func (actor *BaseProtocolActorSchema) GetUpdatedAtHeightQuery(height int64) string {
-	return SelectAtHeight(AddressCol, height, actor.tableName)
-}
-
 func (actor *BaseProtocolActorSchema) GetQuery(address string, height int64) string {
 	return Select(AllColsSelector, address, height, actor.tableName)
 }
@@ -155,5 +150,5 @@ func (x *Actor) GetActorTyp() modules.ActorType {
 	if x != nil {
 		return x.GetActorType()
 	}
-	return ActorType_App // HACK: Is this a hack?
+	return ActorType_App
 }
diff --git a/persistence/types/protocol_actor.go b/persistence/types/protocol_actor.go
index 709457b6c..1052dc3d6 100644
--- a/persistence/types/protocol_actor.go
+++ b/persistence/types/protocol_actor.go
@@ -15,9 +15,6 @@ type ProtocolActorSchema interface {
 	GetActorSpecificColName() string
 
 	/*** Read/Get Queries ***/
-
-	// Returns a query to retrieve the addresses of all the Actors updated at that specific height
-	GetUpdatedAtHeightQuery(height int64) string
 	// Returns a query to retrieve all of a single Actor's attributes.
 	GetQuery(address string, height int64) string
 	// Returns all actors at that height
diff --git a/persistence/types/shared_sql.go b/persistence/types/shared_sql.go
index 6e1f929c7..e36907124 100644
--- a/persistence/types/shared_sql.go
+++ b/persistence/types/shared_sql.go
@@ -69,11 +69,6 @@ func ProtocolActorChainsTableSchema(constraintName string) string {
 		)`, AddressCol, ChainIDCol, HeightCol, DefaultBigInt, constraintName, AddressCol, ChainIDCol, HeightCol)
 }
 
-func SelectAtHeight(selector string, height int64, tableName string) string {
-	return fmt.Sprintf(`SELECT %s FROM %s WHERE height=%d`,
-		selector, tableName, height)
-}
-
 func Select(selector, address string, height int64, tableName string) string {
 	return fmt.Sprintf(`SELECT %s FROM %s WHERE address='%s' AND height<=%d ORDER BY height DESC LIMIT 1`,
 		selector, tableName, address, height)
diff --git a/shared/indexer/indexer.go b/shared/indexer/indexer.go
index 59355787f..559ca1f6e 100644
--- a/shared/indexer/indexer.go
+++ b/shared/indexer/indexer.go
@@ -5,7 +5,6 @@ package indexer
 import (
 	"encoding/hex"
 	"fmt"
-
 	"github.com/pokt-network/pocket/shared/codec"
 
 	"github.com/jordanorelli/lexnum"
@@ -112,7 +111,7 @@ type txIndexer struct {
 }
 
 func NewTxIndexer(databasePath string) (TxIndexer, error) {
-	db, err := kvstore.OpenKVStore(databasePath)
+	db, err := kvstore.NewKVStore(databasePath)
 	return &txIndexer{
 		db: db,
 	}, err
diff --git a/shared/modules/consensus_module.go b/shared/modules/consensus_module.go
index 62a87c368..c6c6213ed 100644
--- a/shared/modules/consensus_module.go
+++ b/shared/modules/consensus_module.go
@@ -7,8 +7,7 @@ import (
 	"google.golang.org/protobuf/types/known/anypb"
 )
 
-// TODO(olshansky): deprecate ValidatorMap or populate from persistence module
-type ValidatorMap map[string]Actor
+type ValidatorMap map[string]Actor // TODO (Drewsky) deprecate Validator map or populate from persistence module
 
 // NOTE: Consensus is the core of the replicated state machine and is driven by various asynchronous events.
 // Consider adding a mutex lock to your implementation that is acquired at the beginning of each entrypoint/function implemented in this interface.
@@ -16,11 +15,11 @@ type ValidatorMap map[string]Actor
 type ConsensusModule interface {
 	Module
 
-	// Consensus Engine Handlers
+	// Consensus Engine
 	HandleMessage(*anypb.Any) error
 	HandleDebugMessage(*debug.DebugMessage) error
 
-	// Consensus State Accessors
+	// Consensus State
 	CurrentHeight() uint64
 	AppHash() string            // DISCUSS: Why not call this a BlockHash or StateHash? Should it be a []byte or string?
 	ValidatorMap() ValidatorMap // TODO: This needs to be dynamically updated during various operations and network changes.
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index e6e5e086a..5f4a6718c 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -3,14 +3,12 @@ package modules
 //go:generate mockgen -source=$GOFILE -destination=./mocks/persistence_module_mock.go -aux_files=github.com/pokt-network/pocket/shared/modules=module.go
 
 import (
-	"github.com/pokt-network/pocket/persistence/kvstore" // Should be moved to shared
+	"github.com/pokt-network/pocket/persistence/kvstore"
 	"github.com/pokt-network/pocket/shared/debug"
 )
 
 type PersistenceModule interface {
 	Module
-
-	// Persistence Context Factory Methods
 	NewRWContext(height int64) (PersistenceRWContext, error)
 	NewReadContext(height int64) (PersistenceReadContext, error)
 
@@ -40,28 +38,34 @@ type PersistenceRWContext interface {
 	PersistenceWriteContext
 }
 
-// TODO: Simplify the interface (reference - https://dave.cheney.net/practical-go/presentations/gophercon-israel.html#_prefer_single_method_interfaces)
-// - Add general purpose methods such as `ActorOperation(enum_actor_type, ...)` which can be use like so: `Insert(FISHERMAN, ...)`
-// - Use general purpose parameter methods such as `Set(enum_gov_type, ...)` such as `Set(STAKING_ADJUSTMENT, ...)`
-
 // NOTE: There's not really a use case for a write only interface,
 // but it abstracts and contrasts nicely against the read only context
 // TODO (andrew) convert address and public key to string not bytes #149
 type PersistenceWriteContext interface {
+	// TODO: Simplify the interface (reference - https://dave.cheney.net/practical-go/presentations/gophercon-israel.html#_prefer_single_method_interfaces)
+	// - Add general purpose methods such as `ActorOperation(enum_actor_type, ...)` which can be use like so: `Insert(FISHERMAN, ...)`
+	// - Use general purpose parameter methods such as `Set(enum_gov_type, ...)` such as `Set(STAKING_ADJUSTMENT, ...)`
 	// Context Operations
 	NewSavePoint([]byte) error
 	RollbackToSavePoint([]byte) error
 
-	// DISCUSS: Can we consolidate `Reset` and `Release`
 	Reset() error
+	Commit() error
 	Release() error
 
-	// Block / indexer operations
-	UpdateAppHash() ([]byte, error)
-	// Commits the current context (height, hash, transactions, etc...) to finality.
-	Commit(proposerAddr []byte, quorumCert []byte) error
-	// Indexes the transaction
-	StoreTransaction(transactionProtoBytes []byte) error // Stores a transaction
+	AppHash() ([]byte, error)
+
+	// Block Operations
+
+	// Indexer Operations
+	StoreTransaction(transactionProtoBytes []byte) error
+
+	// Block Operations
+	// TODO_TEMPORARY: Including two functions for the SQL and KV Store as an interim solution
+	//                 until we include the schema as part of the SQL Store because persistence
+	//                 currently has no access to the protobuf schema which is the source of truth.
+	StoreBlock(blockProtoBytes []byte) error                                              // Store the block in the KV Store
+	InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error // Writes the block in the SQL database
 
 	// Pool Operations
 	AddPoolAmount(name string, amount string) error
@@ -118,29 +122,6 @@ type PersistenceWriteContext interface {
 	// Flag Operations
 	InitFlags() error
 	SetFlag(paramName string, value interface{}, enabled bool) error
-
-	// Tree Operations
-
-	// # Option 1:
-
-	UpdateApplicationsTree([]Actor) error
-	// UpdateValidatorsTree([]Actor) error
-	// UpdateServiceNodesTree([]Actor) error
-	// UpdateFishermanTree([]Actor) error
-	// Update<FutureActors>Tree([]Actor) error
-	// Update<Other>Tree([]Other) error
-
-	// # Option 2:
-	// UpdateActorTree(types.ProtocolActorSchema, []Actor) error
-	// Update<Other>Tree([]Other) error
-
-	// # Option 3:
-	// UpdateApplicationsTree([]Application) error
-	// UpdateValidatorsTree([]Validator) error
-	// UpdateServiceNodesTree([]ServiceNode) error
-	// UpdateFishermanTree([]Fisherman) error
-	// Update<FutureActors>Tree([]FutureActor) error
-	// Update<Other>Tree([]Other) error
 }
 
 type PersistenceReadContext interface {
@@ -219,28 +200,4 @@ type PersistenceReadContext interface {
 	GetIntFlag(paramName string, height int64) (int, bool, error)
 	GetStringFlag(paramName string, height int64) (string, bool, error)
 	GetBytesFlag(paramName string, height int64) ([]byte, bool, error)
-
-	// Tree Operations
-
-	// # Option 1:
-
-	// GetApplicationsUpdatedAtHeight(height int64) ([]Actor, error)
-	// GetValidatorsUpdatedAtHeight(height int64) ([]Actor, error)
-	// GetServiceNodesUpdatedAtHeight(height int64) ([]Actor, error)
-	// GetFishermanUpdatedAtHeight(height int64) ([]Actor, error)
-	// Get<FutureActor>UpdatedAtHeight(height int64) ([]Actor, error)
-	// Get<Other>UpdatedAtHeight(height int64) ([]Actor, error)
-	// Update<Other>Tree(height int64) ([]Actor, error)
-
-	// # Option 2:
-	// Get<FutureActor>UpdatedAtHeight(types.ProtocolActorSchema, height int64) ([]Actor, error)
-	// Get<Other>UpdatedAtHeight(height int64) ([]Other, error)
-
-	// # Option 3:
-	// GetApplicationsUpdatedAtHeight(height int64) ([]Application, error)
-	// GetValidatorsUpdatedAtHeight(height int64) ([]Validator, error)
-	// GetServiceNodesUpdatedAtHeight(height int64) ([]ServiceNode, error)
-	// GetFishermanUpdatedAtHeight(height int64) ([]Fisherman, error)
-	// Get<FutureActor>UpdatedAtHeight(height int64) ([]FutureActor, error)
-	// Get<Other>UpdatedAtHeight(height int64) ([]Other, error)
 }
diff --git a/shared/modules/utility_module.go b/shared/modules/utility_module.go
index 5dbf9f887..edfbc94ee 100644
--- a/shared/modules/utility_module.go
+++ b/shared/modules/utility_module.go
@@ -14,15 +14,13 @@ type UtilityModule interface {
 // operations.
 type UtilityContext interface {
 	// Block operations
-
-	// Reaps the mempool for transactions that are ready to be proposed in a new block
 	GetProposalTransactions(proposer []byte, maxTransactionBytes int, lastBlockByzantineValidators [][]byte) (transactions [][]byte, err error)
-	// Applies the transactions to an ephemeral state in the utility & underlying persistence context;similar to `SafeNode` in the Hotstuff whitepaper.
 	ApplyBlock(height int64, proposer []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) (appHash []byte, err error)
 
 	// Context operations
-	ReleaseContext() error
-	CommitContext(quorumCert []byte) error
+	ReleaseContext()
+	GetPersistenceContext() PersistenceRWContext
+	CommitPersistenceContext() error
 
 	// Validation operations
 	CheckTransaction(tx []byte) error
diff --git a/utility/block.go b/utility/block.go
index 7394b04b0..1bca5f6c1 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -33,8 +33,6 @@ var (
 
 func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) ([]byte, error) {
 	u.LatestHeight = latestHeight
-	u.CurrentProposer = proposerAddress
-
 	// begin block lifecycle phase
 	if err := u.BeginBlock(lastBlockByzantineValidators); err != nil {
 		return nil, err
@@ -52,30 +50,22 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 		if err := u.ApplyTransaction(tx); err != nil {
 			return nil, err
 		}
-		if err := u.Context.PersistenceRWContext.StoreTransaction(transactionProtoBytes); err != nil {
+		if err := u.GetPersistenceContext().StoreTransaction(transactionProtoBytes); err != nil {
 			return nil, err
 		}
 
-		// DISCUSS: What if the context is rolled back or cancelled. Do we add it back to the mempool?
 		// TODO: if found, remove transaction from mempool
+		// DISCUSS: What if the context is rolled back or cancelled. Do we add it back to the mempool?
 		// if err := u.Mempool.DeleteTransaction(transaction); err != nil {
 		// 	return nil, err
 		// }
 	}
-
 	// end block lifecycle phase
 	if err := u.EndBlock(proposerAddress); err != nil {
 		return nil, err
 	}
-
-	// TODO: What if everything above succeeded but updating the app hash failed?
-	appHash, err := u.Context.UpdateAppHash()
-	if err != nil {
-		return nil, typesUtil.ErrAppHash(err)
-	}
-
-	// return the app hash; consensus module will get the validator set directly
-	return appHash, nil
+	// return the app hash (consensus module will get the validator set directly
+	return u.GetAppHash()
 }
 
 func (u *UtilityContext) BeginBlock(previousBlockByzantineValidators [][]byte) typesUtil.Error {
@@ -101,6 +91,15 @@ func (u *UtilityContext) EndBlock(proposer []byte) typesUtil.Error {
 	return nil
 }
 
+func (u *UtilityContext) GetAppHash() ([]byte, typesUtil.Error) {
+	// Get the root hash of the merkle state tree for state consensus integrity
+	appHash, er := u.Context.AppHash()
+	if er != nil {
+		return nil, typesUtil.ErrAppHash(er)
+	}
+	return appHash, nil
+}
+
 // HandleByzantineValidators handles the validators who either didn't sign at all or disagreed with the 2/3+ majority
 func (u *UtilityContext) HandleByzantineValidators(lastBlockByzantineValidators [][]byte) typesUtil.Error {
 	latestBlockHeight, err := u.GetLatestBlockHeight()
diff --git a/utility/context.go b/utility/context.go
index a8797a52c..c3f97f3a8 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -2,24 +2,19 @@ package utility
 
 import (
 	"encoding/hex"
-
 	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/modules"
 	typesUtil "github.com/pokt-network/pocket/utility/types"
 )
 
 type UtilityContext struct {
-	LatestHeight    int64 // IMPROVE: Rename to `currentHeight?`
-	CurrentProposer []byte
-
-	Mempool typesUtil.Mempool
-	Context *Context // IMPROVE: Rename to `persistenceContext` or `storeContext` or `reversibleContext`?
+	LatestHeight int64
+	Mempool      typesUtil.Mempool
+	Context      *Context // IMPROVE: Consider renmaming to PersistenceContext
 }
 
-type Context struct { // IMPROVE: Rename to `persistenceContext` or `storeContext`?
-	// TODO: Since `Context` embeds `PersistenceRWContext`, we don't need to do `u.Context.PersistenceRWContext`, but can call `u.Context` directly
+type Context struct {
 	modules.PersistenceRWContext
-	// TODO/DISCUSS: `SavePoints`` have not been implemented yet
 	SavePointsM map[string]struct{}
 	SavePoints  [][]byte
 }
@@ -44,16 +39,17 @@ func (u *UtilityContext) Store() *Context {
 	return u.Context
 }
 
-func (u *UtilityContext) CommitContext(quorumCert []byte) error {
-	err := u.Context.PersistenceRWContext.Commit(u.CurrentProposer, quorumCert)
-	u.Context = nil // DISCUSS: Should we release the context if there was an error here?
-	return err
+func (u *UtilityContext) GetPersistenceContext() modules.PersistenceRWContext {
+	return u.Context.PersistenceRWContext
+}
+
+func (u *UtilityContext) CommitPersistenceContext() error {
+	return u.Context.PersistenceRWContext.Commit()
 }
 
-func (u *UtilityContext) ReleaseContext() error {
-	err := u.Context.Release()
+func (u *UtilityContext) ReleaseContext() {
+	u.Context.Release()
 	u.Context = nil
-	return err
 }
 
 func (u *UtilityContext) GetLatestBlockHeight() (int64, typesUtil.Error) {
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index 13c6b2175..b59f31bef 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -2,16 +2,12 @@ package test
 
 import (
 	"encoding/hex"
-	"fmt"
 	"github.com/pokt-network/pocket/shared/modules"
-	"github.com/pokt-network/pocket/shared/test_artifacts"s/249/consensus_techdebt
+	"github.com/pokt-network/pocket/shared/test_artifacts"
 	"math"
 	"math/big"
 	"testing"
 
-	"github.com/pokt-network/pocket/shared/modules"
-	"github.com/pokt-network/pocket/shared/test_artifacts"
-
 	typesUtil "github.com/pokt-network/pocket/utility/types"
 	"github.com/stretchr/testify/require"
 )
@@ -175,6 +171,19 @@ func TestUtilityContext_EndBlock(t *testing.T) {
 	test_artifacts.CleanupTest(ctx)
 }
 
+func TestUtilityContext_GetAppHash(t *testing.T) {
+	ctx := NewTestingUtilityContext(t, 0)
+
+	appHashTest, err := ctx.GetAppHash()
+	require.NoError(t, err)
+
+	appHashSource, er := ctx.Context.AppHash()
+	require.NoError(t, er)
+	require.Equal(t, appHashTest, appHashSource, "unexpected appHash")
+
+	test_artifacts.CleanupTest(ctx)
+}
+
 func TestUtilityContext_UnstakeValidatorsActorsThatAreReady(t *testing.T) {
 	for _, actorType := range typesUtil.ActorTypes {
 		ctx := NewTestingUtilityContext(t, 1)

From 0ca02aadf7f43e0a41b96608ce7a89184e138914 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 4 Oct 2022 19:00:41 -0700
Subject: [PATCH 065/227] Merge with interface changes

---
 shared/CHANGELOG.md                  | 16 +++++-
 shared/docs/flows/AppHash.md         | 80 +++++++++++++++++++---------
 shared/docs/flows/README.md          |  3 ++
 shared/modules/persistence_module.go | 49 ++++++-----------
 shared/modules/utility_module.go     |  8 +--
 5 files changed, 95 insertions(+), 61 deletions(-)
 create mode 100644 shared/docs/flows/README.md

diff --git a/shared/CHANGELOG.md b/shared/CHANGELOG.md
index 758de960a..75ac655c4 100644
--- a/shared/CHANGELOG.md
+++ b/shared/CHANGELOG.md
@@ -7,8 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.0.2] - 2022-10-04
+
+- Updates to the `PersistenceModule` interface
+  - Added `ReleaseWriteContext`
+  - Removed `ResetContext`
+- Updates to the `PersistenceContext` interface
+  - Removed `Reset`
+  - Changed `AppHash` `UpdateAppHash`
+  - Changed `Commit()` to `Commit(proposerAddr, quorumCert)`
+- Updates to the `UtilityContext` interface
+  - Change `ReleaseContext` to `Release`
+  - Removed `GetPersistenceContext`
+  - Changed `CommitPersistenceContext()` to `Commit(quorumCert)`
+
+## [0.0.0.1] - 2022-09-24
 
-## [0.0.1] - 2022-09-24
 - Add unit test for `SharedCodec()`
 - Added `TestProtoStructure` for testing
 - Flaky tests troubleshooting - https://github.com/pokt-network/pocket/issues/192
diff --git a/shared/docs/flows/AppHash.md b/shared/docs/flows/AppHash.md
index c17f3cd41..f905328fa 100644
--- a/shared/docs/flows/AppHash.md
+++ b/shared/docs/flows/AppHash.md
@@ -1,40 +1,70 @@
 # AppHash
 
-## Context Initialization
+## Block Application
 
 ```mermaid
 sequenceDiagram
-    %% autonumber
-    participant N as Node
     participant C as Consensus
     participant U as Utility
     participant P as Persistence
     participant PP as Persistence (PostgresDB)
     participant PM as Persistence (MerkleTree)
-    participant P2P as P2P
-
-    %% Should this be P2P?
-    N-->>C: HandleMessage(anypb.Any)
-    critical NewRound Message
-        C->>+U: NewContext(height)
-        U->>P: NewRWContext(height)
-        P->>U: PersistenceRWContext
-        U->>U: Store persistenceContext
-        U->>-C: UtilityContext
-        C->>C: Store utilityContext
-        Note over C, PM: See 'Block Application'
-    end
-    Note over N, P2P: Hotstuff lifecycle
-    N-->>C: HandleMessage(anypb.Any)
-    critical Decide Message
-        Note over C, PM: See 'Block Commit'
+    alt as leader
+        C->>+U: GetProposalTransactions(proposer, maxTxBz, [lastVal])
+        U->>U: reap mempool
+        U->>-C: txs
+        Note over C, U: Perform replica behaviour
+    else as replica
+        C->>+U: ApplyBlock(height, proposer, txs, lastVals)
+        loop Update DB: for each operation in tx
+            U->>P: ReadOp | WriteOp
+            P->>PP: ReadOp | WriteOp
+            PP->>P: data | ok
+            P->>U: data | ok
+            U->>U: validate
+            U->>P: StoreTransaction(tx)
+            P->>P: store locally
+            P->>U: ok
+        end
+        U->>+P: UpdateAppHash()
+        loop for each protocol actor type
+            P->>PP: GetActorsUpdate(height)
+            PP->>P: actors
+            loop Update Tree: for each actor
+                P->>PM: Update(addr, serialized(actor))
+                PM->>P: ok
+            end
+            P->>PM: GetRoot()
+            PM->>P: rootHash
+        end
+        P->>P: computeStateHash(rootHashes)
+        P->>-U: stateHash
+        U->>-C: hash
     end
 ```
 
-## Block Application
-
-TODO(olshansky): Add a sequenceDiagram here.
-
 ## Block Commit
 
-TODO(olshansky): Add a sequenceDiagram here.
+```mermaid
+sequenceDiagram
+    %% autonumber
+    participant C as Consensus
+    participant U as Utility
+    participant P as Persistence
+    participant PP as Persistence (PostgresDB)
+    participant PK as Persistence (Key-Value Store)
+    C->>U: CommitContext(quorumCert)
+    U->>P: Commit(proposerAddr, quorumCert)
+    P->>P: create typesPer.Block
+    P->>PP: insertBlock(block)
+    PP->>P: ok
+    P->>PK: Put(height, block)
+    PK->>P: ok
+    P->>P: commit tx
+    P->>U: ok
+    U->>P: Release()
+    P->>U: ok
+    C->>U: Release()
+    U->>C: ok
+    C->>C: release utilityContext
+```
diff --git a/shared/docs/flows/README.md b/shared/docs/flows/README.md
new file mode 100644
index 000000000..cb4e5d663
--- /dev/null
+++ b/shared/docs/flows/README.md
@@ -0,0 +1,3 @@
+# Flows
+
+The purpose of [shared/flows](./) is to document cross-module communication for end-to-end behaviour that has cross-module dependencies and and depends on the interfaces exposed by the interfaces exposed in [shared/modules](../modules).
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index 5f4a6718c..9379f6362 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -3,21 +3,19 @@ package modules
 //go:generate mockgen -source=$GOFILE -destination=./mocks/persistence_module_mock.go -aux_files=github.com/pokt-network/pocket/shared/modules=module.go
 
 import (
-	"github.com/pokt-network/pocket/persistence/kvstore"
+	"github.com/pokt-network/pocket/persistence/kvstore" // Should be moved to shared
 	"github.com/pokt-network/pocket/shared/debug"
 )
 
 type PersistenceModule interface {
 	Module
+
+	// Context interface
 	NewRWContext(height int64) (PersistenceRWContext, error)
 	NewReadContext(height int64) (PersistenceReadContext, error)
+	ReleaseWriteContext() error // Only one write context can exist at a time
 
-	// TODO(drewsky): Make this a context function only and do not expose it at the module level.
-	//                The reason `Olshansky` originally made it a module level function is because
-	//                the module was responsible for maintaining a single write context and assuring
-	//                that a second can't be created (or a previous one is cleaned up) but there is
-	//                likely a better and cleaner approach that simplifies the interface.
-	ResetContext() error
+	// BlockStore interface
 	GetBlockStore() kvstore.KVStore
 
 	// Debugging / development only
@@ -38,40 +36,31 @@ type PersistenceRWContext interface {
 	PersistenceWriteContext
 }
 
-// NOTE: There's not really a use case for a write only interface,
-// but it abstracts and contrasts nicely against the read only context
 // TODO (andrew) convert address and public key to string not bytes #149
+// TODO: Simplify the interface (reference - https://dave.cheney.net/practical-go/presentations/gophercon-israel.html#_prefer_single_method_interfaces)
+// - Add general purpose methods such as `ActorOperation(enum_actor_type, ...)` which can be use like so: `Insert(FISHERMAN, ...)`
+// - Use general purpose parameter methods such as `Set(enum_gov_type, ...)` such as `Set(STAKING_ADJUSTMENT, ...)`
+
+// NOTE: There's not really a use case for a write only interface,
+//       but it abstracts and contrasts nicely against the read only context
 type PersistenceWriteContext interface {
-	// TODO: Simplify the interface (reference - https://dave.cheney.net/practical-go/presentations/gophercon-israel.html#_prefer_single_method_interfaces)
-	// - Add general purpose methods such as `ActorOperation(enum_actor_type, ...)` which can be use like so: `Insert(FISHERMAN, ...)`
-	// - Use general purpose parameter methods such as `Set(enum_gov_type, ...)` such as `Set(STAKING_ADJUSTMENT, ...)`
 	// Context Operations
 	NewSavePoint([]byte) error
 	RollbackToSavePoint([]byte) error
 
-	Reset() error
-	Commit() error
 	Release() error
 
-	AppHash() ([]byte, error)
-
-	// Block Operations
-
-	// Indexer Operations
-	StoreTransaction(transactionProtoBytes []byte) error
-
-	// Block Operations
-	// TODO_TEMPORARY: Including two functions for the SQL and KV Store as an interim solution
-	//                 until we include the schema as part of the SQL Store because persistence
-	//                 currently has no access to the protobuf schema which is the source of truth.
-	StoreBlock(blockProtoBytes []byte) error                                              // Store the block in the KV Store
-	InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error // Writes the block in the SQL database
+	// Block / indexer operations
+	UpdateAppHash() ([]byte, error)
+	// Commits the current context (height, hash, transactions, etc...) to finality.
+	Commit(proposerAddr []byte, quorumCert []byte) error
+	// Indexes the transaction
+	StoreTransaction(transactionProtoBytes []byte) error // Stores a transaction
 
 	// Pool Operations
 	AddPoolAmount(name string, amount string) error
 	SubtractPoolAmount(name string, amount string) error
 	SetPoolAmount(name string, amount string) error
-
 	InsertPool(name string, address []byte, amount string) error // TODO (Andrew) remove address from pool #149
 
 	// Account Operations
@@ -113,8 +102,6 @@ type PersistenceWriteContext interface {
 	SetValidatorPauseHeightAndMissedBlocks(address []byte, pauseHeight int64, missedBlocks int) error
 	SetValidatorMissedBlocks(address []byte, missedBlocks int) error
 
-	/* TODO(olshansky): review/revisit this in more details */
-
 	// Param Operations
 	InitParams() error
 	SetParam(paramName string, value interface{}) error
@@ -189,8 +176,6 @@ type PersistenceReadContext interface {
 	GetValidatorOutputAddress(operator []byte, height int64) (output []byte, err error)
 	GetValidatorMissedBlocks(address []byte, height int64) (int, error)
 
-	/* TODO(olshansky): review/revisit this in more details */
-
 	// Params
 	GetIntParam(paramName string, height int64) (int, error)
 	GetStringParam(paramName string, height int64) (string, error)
diff --git a/shared/modules/utility_module.go b/shared/modules/utility_module.go
index edfbc94ee..37729fba1 100644
--- a/shared/modules/utility_module.go
+++ b/shared/modules/utility_module.go
@@ -14,13 +14,15 @@ type UtilityModule interface {
 // operations.
 type UtilityContext interface {
 	// Block operations
+
+	// Reaps the mempool for transactions that are ready to be proposed in a new block
 	GetProposalTransactions(proposer []byte, maxTransactionBytes int, lastBlockByzantineValidators [][]byte) (transactions [][]byte, err error)
+	// Applies the transactions to an ephemeral state in the utility & underlying persistence context;similar to `SafeNode` in the Hotstuff whitepaper.
 	ApplyBlock(height int64, proposer []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) (appHash []byte, err error)
 
 	// Context operations
-	ReleaseContext()
-	GetPersistenceContext() PersistenceRWContext
-	CommitPersistenceContext() error
+	Release() error
+	Commit(quorumCert []byte) error
 
 	// Validation operations
 	CheckTransaction(tx []byte) error

From aaffb791d965a0d26b64b7cacaec080852a03d7b Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 4 Oct 2022 19:06:05 -0700
Subject: [PATCH 066/227] Uplied diffs back

---
 consensus/block.go                   | 45 ++++--------------------
 go.mod                               |  3 +-
 go.sum                               |  2 ++
 persistence/application.go           | 51 ++++++++++++++++++++++++++++
 persistence/block.go                 | 42 ++++++++++++++++++-----
 persistence/context.go               | 26 ++++++++++----
 persistence/db.go                    |  8 +++++
 persistence/debug.go                 |  2 +-
 persistence/genesis.go               |  4 +--
 persistence/kvstore/kvstore.go       | 35 ++++++++++++++++---
 persistence/module.go                | 31 ++++++++++++++---
 persistence/shared_sql.go            | 40 ++++++++++++++++++++--
 persistence/test/module_test.go      |  4 ++-
 persistence/types/base_actor.go      |  7 +++-
 persistence/types/protocol_actor.go  |  3 ++
 persistence/types/shared_sql.go      |  5 +++
 shared/codec/codec.go                |  4 +++
 shared/docs/flows/README.md          |  3 --
 shared/indexer/indexer.go            |  3 +-
 shared/modules/persistence_module.go | 47 +++++++++++++++++++++++++
 shared/test_artifacts/generator.go   |  5 +--
 utility/block.go                     | 27 ++++++++-------
 utility/context.go                   | 28 ++++++++-------
 utility/test/block_test.go           | 19 +++--------
 24 files changed, 328 insertions(+), 116 deletions(-)
 delete mode 100644 shared/docs/flows/README.md

diff --git a/consensus/block.go b/consensus/block.go
index 536c3cc74..14675bbd5 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -4,8 +4,6 @@ import (
 	"encoding/hex"
 	"unsafe"
 
-	"github.com/pokt-network/pocket/shared/codec"
-
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
 
@@ -89,7 +87,9 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 	// should not be called.
 	if m.utilityContext != nil {
 		m.nodeLog(typesCons.NilUtilityContextWarning)
-		m.utilityContext.ReleaseContext()
+		if err := m.utilityContext.Release(); err != nil {
+			return err
+		}
 		m.utilityContext = nil
 	}
 
@@ -105,47 +105,14 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
 
-	// Store the block in the KV store
-	codec := codec.GetCodec()
-	blockProtoBytes, err := codec.Marshal(block)
-	if err != nil {
-		return err
-	}
-
-	// IMPROVE(olshansky): temporary solution. `ApplyBlock` above applies the
-	// transactions to the postgres database, and this stores it in the KV store upon commitment.
-	// Instead of calling this directly, an alternative solution is to store the block metadata in
-	// the persistence context and have `CommitPersistenceContext` do this under the hood. However,
-	// additional `Block` metadata will need to be passed through and may change when we merkle the
-	// state hash.
-	if err := m.storeBlock(block, blockProtoBytes); err != nil {
-		return err
-	}
-
 	// Commit and release the context
-	if err := m.utilityContext.CommitPersistenceContext(); err != nil {
+	if err := m.utilityContext.Commit(block.BlockHeader.QuorumCertificate); err != nil {
 		return err
 	}
-
-	m.utilityContext.ReleaseContext()
+	m.utilityContext.Release()
 	m.utilityContext = nil
 
-	m.appHash = block.BlockHeader.Hash
+	m.lastAppHash = block.BlockHeader.Hash
 
 	return nil
 }
-
-func (m *ConsensusModule) storeBlock(block *typesCons.Block, blockProtoBytes []byte) error {
-	store := m.utilityContext.GetPersistenceContext()
-	// Store in KV Store
-	if err := store.StoreBlock(blockProtoBytes); err != nil {
-		return err
-	}
-
-	// Store in SQL Store
-	header := block.BlockHeader
-	if err := store.InsertBlock(uint64(header.Height), header.Hash, header.ProposerAddress, header.QuorumCertificate); err != nil {
-		return err
-	}
-	return nil
-}
diff --git a/go.mod b/go.mod
index 1aa121424..30f937624 100644
--- a/go.mod
+++ b/go.mod
@@ -20,6 +20,7 @@ require (
 )
 
 require (
+	github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884
 	github.com/benbjohnson/clock v1.3.0
 	github.com/dgraph-io/badger/v3 v3.2103.2
 	github.com/jackc/pgconn v1.11.0
@@ -38,7 +39,7 @@ require (
 	github.com/docker/go-connections v0.4.0 // indirect
 	github.com/docker/go-units v0.4.0 // indirect
 	github.com/dustin/go-humanize v1.0.0 // indirect
-	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/gogo/protobuf v1.3.2
 	github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b // indirect
 	github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
diff --git a/go.sum b/go.sum
index 8d255a0b5..f7e72a772 100644
--- a/go.sum
+++ b/go.sum
@@ -63,6 +63,8 @@ github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+Ce
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/boombuler/barcode v1.0.0/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8=
+github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884 h1:iRNKw2WmAbVgGMNYzDH5Y2yY3+jyxwEK9Hc5pwIjZAE=
+github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884/go.mod h1:/sdYDakowo/XaxS2Fl7CBqtuf/O2uTqF2zmAUFAtAiw=
 github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4=
 github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
diff --git a/persistence/application.go b/persistence/application.go
index 78750a7b6..755288155 100644
--- a/persistence/application.go
+++ b/persistence/application.go
@@ -4,15 +4,66 @@ import (
 	"encoding/hex"
 
 	"github.com/pokt-network/pocket/persistence/types"
+	"google.golang.org/protobuf/proto"
+
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
+func (p PostgresContext) UpdateApplicationsTree(apps []modules.Actor) error {
+	for _, app := range apps {
+		bzAddr, err := hex.DecodeString(app.GetAddress())
+		if err != nil {
+			return err
+		}
+
+		appBz, err := proto.Marshal(app.(*types.Actor))
+		if err != nil {
+			return err
+		}
+
+		// OPTIMIZE: This is the only line unique to `Application`
+		if _, err := p.MerkleTrees[appMerkleTree].Update(bzAddr, appBz); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (p PostgresContext) getApplicationsUpdatedAtHeight(height int64) (apps []*types.Actor, err error) {
+	// OPTIMIZE: This is the only line unique to `Application`
+	actors, err := p.GetActorsUpdated(types.ApplicationActor, height)
+	if err != nil {
+		return nil, err
+	}
+
+	apps = make([]*types.Actor, len(actors))
+	for _, actor := range actors {
+		app := &types.Actor{
+			ActorType:       types.ActorType_App,
+			Address:         actor.Address,
+			PublicKey:       actor.PublicKey,
+			Chains:          actor.Chains,
+			GenericParam:    actor.ActorSpecificParam,
+			StakedAmount:    actor.StakedTokens,
+			PausedHeight:    actor.PausedHeight,
+			UnstakingHeight: actor.UnstakingHeight,
+			Output:          actor.OutputAddress,
+		}
+		apps = append(apps, app)
+	}
+	return
+}
+
 func (p PostgresContext) GetAppExists(address []byte, height int64) (exists bool, err error) {
 	return p.GetExists(types.ApplicationActor, address, height)
 }
 
 func (p PostgresContext) GetApp(address []byte, height int64) (operator, publicKey, stakedTokens, maxRelays, outputAddress string, pauseHeight, unstakingHeight int64, chains []string, err error) {
 	actor, err := p.GetActor(types.ApplicationActor, address, height)
+	if err != nil {
+		return
+	}
 	operator = actor.Address
 	publicKey = actor.PublicKey
 	stakedTokens = actor.StakedTokens
diff --git a/persistence/block.go b/persistence/block.go
index aaee96364..5efa1b71e 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -5,6 +5,7 @@ import (
 	"encoding/hex"
 	"log"
 
+	"github.com/gogo/protobuf/proto"
 	"github.com/pokt-network/pocket/persistence/types"
 )
 
@@ -49,23 +50,46 @@ func (p PostgresContext) StoreTransaction(transactionProtoBytes []byte) error {
 	return nil
 }
 
-func (p PostgresContext) StoreBlock(blockProtoBytes []byte) error {
-	// INVESTIGATE: Note that we are writing this directly to the blockStore. Depending on how
-	// the use of the PostgresContext evolves, we may need to write this to `ContextStore` and copy
-	// over to `BlockStore` when the block is committed.
-	return p.blockstore.Put(heightToBytes(p.Height), blockProtoBytes)
-}
-
-func (p PostgresContext) InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error {
+func (p PostgresContext) insertBlock(block *types.Block) error {
 	ctx, tx, err := p.GetCtxAndTx()
 	if err != nil {
 		return err
 	}
 
-	_, err = tx.Exec(ctx, types.InsertBlockQuery(height, hash, proposerAddr, quorumCert))
+	_, err = tx.Exec(ctx, types.InsertBlockQuery(block.Height, block.Hash, block.ProposerAddress, block.QuorumCertificate))
 	return err
 }
 
+func (p PostgresContext) storeBlock(block *types.Block) error {
+	blockBz, err := proto.Marshal(block)
+	if err != nil {
+		return err
+	}
+
+	return p.blockstore.Put(heightToBytes(p.Height), blockBz)
+}
+
+func (p PostgresContext) getBlock(proposerAddr []byte, quorumCert []byte) (*types.Block, error) {
+	prevHash, err := p.GetBlockHash(p.Height - 1)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: get this from the transactions that were store via `StoreTransaction`
+	txs := make([][]byte, 0)
+
+	block := &types.Block{
+		Height:            uint64(p.Height),
+		Hash:              string(p.stateHash),
+		PrevHash:          string(prevHash),
+		ProposerAddress:   proposerAddr,
+		QuorumCertificate: quorumCert,
+		Transactions:      txs,
+	}
+
+	return block, nil
+}
+
 // CLEANUP: Should this be moved to a shared directory?
 func heightToBytes(height int64) []byte {
 	heightBytes := make([]byte, 8)
diff --git a/persistence/context.go b/persistence/context.go
index fd44e3af1..8224a229a 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -15,25 +15,39 @@ func (p PostgresContext) RollbackToSavePoint(bytes []byte) error {
 	return p.GetTx().Rollback(context.TODO())
 }
 
-func (p PostgresContext) AppHash() ([]byte, error) {
-	log.Println("TODO: AppHash not implemented")
-	return []byte("A real app hash, I am not"), nil
+func (p PostgresContext) UpdateAppHash() ([]byte, error) {
+	if err := p.updateStateHash(); err != nil {
+		return nil, err
+	}
+	return p.stateHash, nil
 }
 
 func (p PostgresContext) Reset() error {
 	panic("TODO: PostgresContext Reset not implemented")
 }
 
-func (p PostgresContext) Commit() error {
+func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
+	block, err := p.getBlock(proposerAddr, quorumCert)
+	if err != nil {
+		return err
+	}
+
+	if err := p.insertBlock(block); err != nil {
+		return err
+	}
+
+	if err := p.storeBlock(block); err != nil {
+		return err
+	}
+
 	ctx := context.TODO()
-	if err := p.GetTx().Commit(context.TODO()); err != nil {
+	if err := p.GetTx().Commit(ctx); err != nil {
 		return err
 	}
 	if err := p.conn.Close(ctx); err != nil {
 		log.Println("[TODO][ERROR] Implement connection pooling. Error when closing DB connecting...", err)
-
 	}
 	return nil
 }
diff --git a/persistence/db.go b/persistence/db.go
index 3a495596c..b8a974939 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -7,6 +7,7 @@ import (
 
 	"github.com/pokt-network/pocket/persistence/types"
 
+	"github.com/celestiaorg/smt"
 	"github.com/jackc/pgconn"
 	"github.com/jackc/pgx/v4"
 	"github.com/pokt-network/pocket/persistence/kvstore"
@@ -40,6 +41,13 @@ type PostgresContext struct {
 	conn       *pgx.Conn
 	tx         pgx.Tx
 	blockstore kvstore.KVStore
+
+	stateHash []byte
+	// IMPROVE: Depending on how the use of `PostgresContext` evolves, we may be able to get
+	// access to these directly via the postgres module.
+	PostgresDB  *pgx.Conn
+	BlockStore  kvstore.KVStore                      // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context)
+	MerkleTrees map[MerkleTree]*smt.SparseMerkleTree // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context)
 }
 
 func (pg *PostgresContext) GetCtxAndTx() (context.Context, pgx.Tx, error) {
diff --git a/persistence/debug.go b/persistence/debug.go
index 3fdc583a4..e0e3b6e5e 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -44,7 +44,7 @@ func (m *PersistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 
 func (m *PersistenceModule) clearState(_ *debug.DebugMessage) {
 	context, err := m.NewRWContext(-1)
-	defer context.Commit()
+	defer context.Commit(nil, nil)
 	if err != nil {
 		log.Printf("Error creating new context: %s \n", err)
 		return
diff --git a/persistence/genesis.go b/persistence/genesis.go
index 1c7e82f14..a6eefaa90 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -149,7 +149,7 @@ func (m *PersistenceModule) populateGenesisState(state *types.PersistenceGenesis
 		log.Fatalf("an error occurred initializing flags: %s", err.Error())
 	}
 
-	if err = rwContext.Commit(); err != nil {
+	if err = rwContext.Commit(nil, nil); err != nil {
 		log.Fatalf("an error occurred during commit() on genesis state %s ", err.Error())
 	}
 }
@@ -316,7 +316,7 @@ func (p PostgresContext) GetAllFishermen(height int64) (f []modules.Actor, err e
 	return
 }
 
-// TODO (Team) deprecate with interface #163 <Bumped to #149> as #163 is getting large
+// CONSOLIDATE: Consolidate `types.BaseActor` with `types.Actor`
 func (p PostgresContext) BaseActorToActor(ba types.BaseActor, actorType types.ActorType) *types.Actor {
 	actor := new(types.Actor)
 	actor.ActorType = actorType
diff --git a/persistence/kvstore/kvstore.go b/persistence/kvstore/kvstore.go
index 24613afc9..8636e4519 100644
--- a/persistence/kvstore/kvstore.go
+++ b/persistence/kvstore/kvstore.go
@@ -1,33 +1,47 @@
 package kvstore
 
 import (
+	"errors"
 	"log"
 
+	"github.com/celestiaorg/smt"
 	badger "github.com/dgraph-io/badger/v3"
 )
 
-// CLEANUP: move this structure to a shared module
 type KVStore interface {
 	// Lifecycle methods
 	Stop() error
 
 	// Accessors
 	// TODO: Add a proper iterator interface
-	Put(key []byte, value []byte) error
-	Get(key []byte) ([]byte, error)
 	// TODO: Add pagination for `GetAll`
 	GetAll(prefixKey []byte, descending bool) ([][]byte, error)
+
 	Exists(key []byte) (bool, error)
 	ClearAll() error
+
+	// Same interface as in `smt.MapStore``
+	Put(key, value []byte) error
+	Get(key []byte) ([]byte, error)
+	Delete(key []byte) error
 }
 
 var _ KVStore = &badgerKVStore{}
+var _ smt.MapStore = &badgerKVStore{}
+
+var (
+	ErrKVStoreExists    = errors.New("kvstore already exists")
+	ErrKVStoreNotExists = errors.New("kvstore does not exist")
+)
 
 type badgerKVStore struct {
 	db *badger.DB
 }
 
-func NewKVStore(path string) (KVStore, error) {
+// REFACTOR: Loads or creates a badgerDb at `path`. This may potentially need to be refactored
+// into `NewKVStore` and `LoadKVStore` depending on how state sync evolves by leveraging `os.Stat`
+// on the file path.
+func OpenKVStore(path string) (KVStore, error) {
 	db, err := badger.Open(badger.DefaultOptions(path))
 	if err != nil {
 		return nil, err
@@ -43,7 +57,7 @@ func NewMemKVStore() KVStore {
 	return badgerKVStore{db: db}
 }
 
-func (store badgerKVStore) Put(key []byte, value []byte) error {
+func (store badgerKVStore) Put(key, value []byte) error {
 	tx := store.db.NewTransaction(true)
 	defer tx.Discard()
 
@@ -55,6 +69,12 @@ func (store badgerKVStore) Put(key []byte, value []byte) error {
 	return tx.Commit()
 }
 
+// CONSOLIDATE: We might be able to remove the `KVStore` interface altogether if we end up using `smt.MapStore`
+// A wrapper around `Put` to conform to the `smt.MapStore` interface
+func (store *badgerKVStore) Set(key, value []byte) error {
+	return store.Put(key, value)
+}
+
 func (store badgerKVStore) Get(key []byte) ([]byte, error) {
 	tx := store.db.NewTransaction(false)
 	defer tx.Discard()
@@ -76,6 +96,11 @@ func (store badgerKVStore) Get(key []byte) ([]byte, error) {
 	return value, nil
 }
 
+func (store badgerKVStore) Delete(key []byte) error {
+	log.Fatalf("badgerKVStore.Delete not implemented yet")
+	return nil
+}
+
 func (store badgerKVStore) GetAll(prefix []byte, descending bool) (values [][]byte, err error) {
 	// INVESTIGATE: research `badger.views` for further improvements and optimizations
 	txn := store.db.NewTransaction(false)
diff --git a/persistence/module.go b/persistence/module.go
index 33bd827bd..6761bb22b 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -7,10 +7,10 @@ import (
 	"io/ioutil"
 	"log"
 
-	"github.com/pokt-network/pocket/persistence/types"
-
+	"github.com/celestiaorg/smt"
 	"github.com/jackc/pgx/v4"
 	"github.com/pokt-network/pocket/persistence/kvstore"
+	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 	"github.com/pokt-network/pocket/shared/test_artifacts"
 )
@@ -26,10 +26,19 @@ type PersistenceModule struct {
 	postgresURL string
 	nodeSchema  string
 	genesisPath string
-	blockStore  kvstore.KVStore // INVESTIGATE: We may need to create a custom `BlockStore` package in the future
 
 	// TECHDEBT: Need to implement context pooling (for writes), timeouts (for read & writes), etc...
 	writeContext *PostgresContext // only one write context is allowed at a time
+
+	// The connection to the PostgreSQL database
+	postgresConn *pgx.Conn
+	// A reference to the block key-value store
+	// INVESTIGATE: We may need to create a custom `BlockStore` package in the future.
+	blockStore kvstore.KVStore
+	// A mapping of context IDs to persistence contexts
+	// contexts map[contextId]modules.PersistenceRWContext
+	// Merkle trees
+	trees map[MerkleTree]*smt.SparseMerkleTree
 }
 
 const (
@@ -42,8 +51,10 @@ func Create(configPath, genesisPath string) (modules.PersistenceModule, error) {
 	if err != nil {
 		return nil, err
 	}
+
 	cfg := c.(*types.PersistenceConfig)
 	g, err := m.InitGenesis(genesisPath)
+
 	if err != nil {
 		return nil, err
 	}
@@ -69,8 +80,20 @@ func Create(configPath, genesisPath string) (modules.PersistenceModule, error) {
 		genesisPath:  genesisPath,
 		blockStore:   blockStore,
 		writeContext: nil,
+		// contexts:     make(map[contextId]modules.PersistenceContext),
+		trees: make(map[MerkleTree]*smt.SparseMerkleTree),
 	}
 
+	// DISCUSS_IN_THIS_COMMIT: We've been using the module function pattern, but this making `initializeTrees`
+	// be able to create and/or load trees outside the scope of the persistence module makes it easier to test.
+	trees, err := newMerkleTrees()
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO_IN_THIS_COMMIT: load trees from state
+	persistenceMod.trees = trees
+
 	// Determine if we should hydrate the genesis db or use the current state of the DB attached
 	if shouldHydrateGenesis, err := persistenceMod.shouldHydrateGenesisDb(); err != nil {
 		return nil, err
@@ -214,7 +237,7 @@ func initializeBlockStore(blockStorePath string) (kvstore.KVStore, error) {
 	if blockStorePath == "" {
 		return kvstore.NewMemKVStore(), nil
 	}
-	return kvstore.NewKVStore(blockStorePath)
+	return kvstore.OpenKVStore(blockStorePath)
 }
 
 // TODO(drewsky): Simplify and externalize the logic for whether genesis should be populated and
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
index 9f2c19a00..8eac77562 100644
--- a/persistence/shared_sql.go
+++ b/persistence/shared_sql.go
@@ -44,6 +44,36 @@ func (p *PostgresContext) GetExists(actorSchema types.ProtocolActorSchema, addre
 	return
 }
 
+func (p *PostgresContext) GetActorsUpdated(actorSchema types.ProtocolActorSchema, height int64) (actors []types.BaseActor, err error) {
+	ctx, tx, err := p.GetCtxAndTx()
+	if err != nil {
+		return
+	}
+
+	rows, err := tx.Query(ctx, actorSchema.GetUpdatedAtHeightQuery(height))
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	// OPTIMIZE: Consolidate logic with `GetActor` to reduce code footprint
+	var addr string
+	for rows.Next() {
+		if err = rows.Scan(&addr); err != nil {
+			return
+		}
+
+		actor, err := p.GetActor(actorSchema, []byte(addr), height)
+		if err != nil {
+			return nil, err
+		}
+
+		actors = append(actors, actor)
+	}
+
+	return
+}
+
 func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, address []byte, height int64) (actor types.BaseActor, err error) {
 	ctx, tx, err := p.GetCtxAndTx()
 	if err != nil {
@@ -57,10 +87,16 @@ func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, addres
 	return p.GetChainsForActor(ctx, tx, actorSchema, actor, height)
 }
 
+// IMPORTANT: Need to consolidate `persistence/types.BaseActor` with `persistence/genesisTypes.Actor`
 func (p *PostgresContext) GetActorFromRow(row pgx.Row) (actor types.BaseActor, height int64, err error) {
 	err = row.Scan(
-		&actor.Address, &actor.PublicKey, &actor.StakedTokens, &actor.ActorSpecificParam,
-		&actor.OutputAddress, &actor.PausedHeight, &actor.UnstakingHeight,
+		&actor.Address,
+		&actor.PublicKey,
+		&actor.StakedTokens,
+		&actor.ActorSpecificParam,
+		&actor.OutputAddress,
+		&actor.PausedHeight,
+		&actor.UnstakingHeight,
 		&height)
 	return
 }
diff --git a/persistence/test/module_test.go b/persistence/test/module_test.go
index 3bee636c5..ccb7bd37f 100644
--- a/persistence/test/module_test.go
+++ b/persistence/test/module_test.go
@@ -18,12 +18,14 @@ func TestPersistenceContextParallelReadWrite(t *testing.T) {
 	poolAddress := []byte("address")
 	originalAmount := "15"
 	modifiedAmount := "10"
+	proposer := []byte("proposer")
+	quorumCert := []byte("quorumCert")
 
 	// setup a write context, insert a pool and commit it
 	context, err := testPersistenceMod.NewRWContext(0)
 	require.NoError(t, err)
 	require.NoError(t, context.InsertPool(poolName, poolAddress, originalAmount))
-	require.NoError(t, context.Commit())
+	require.NoError(t, context.Commit(proposer, quorumCert))
 
 	// verify the insert in the previously committed context worked
 	contextA, err := testPersistenceMod.NewRWContext(0)
diff --git a/persistence/types/base_actor.go b/persistence/types/base_actor.go
index 9514b15eb..1c73da9a7 100644
--- a/persistence/types/base_actor.go
+++ b/persistence/types/base_actor.go
@@ -1,5 +1,6 @@
 package types
 
+// IMPROVE: Move schema related functions to a separate sub-package
 import "github.com/pokt-network/pocket/shared/modules"
 
 // TECHDEBT: Consider moving this to a protobuf. This struct was created to make testing simple of protocol actors that
@@ -60,6 +61,10 @@ func (actor *BaseProtocolActorSchema) GetChainsTableSchema() string {
 	return ProtocolActorChainsTableSchema(actor.chainsHeightConstraintName)
 }
 
+func (actor *BaseProtocolActorSchema) GetUpdatedAtHeightQuery(height int64) string {
+	return SelectAtHeight(AddressCol, height, actor.tableName)
+}
+
 func (actor *BaseProtocolActorSchema) GetQuery(address string, height int64) string {
 	return Select(AllColsSelector, address, height, actor.tableName)
 }
@@ -150,5 +155,5 @@ func (x *Actor) GetActorTyp() modules.ActorType {
 	if x != nil {
 		return x.GetActorType()
 	}
-	return ActorType_App
+	return ActorType_App // HACK: Is this a hack?
 }
diff --git a/persistence/types/protocol_actor.go b/persistence/types/protocol_actor.go
index 1052dc3d6..709457b6c 100644
--- a/persistence/types/protocol_actor.go
+++ b/persistence/types/protocol_actor.go
@@ -15,6 +15,9 @@ type ProtocolActorSchema interface {
 	GetActorSpecificColName() string
 
 	/*** Read/Get Queries ***/
+
+	// Returns a query to retrieve the addresses of all the Actors updated at that specific height
+	GetUpdatedAtHeightQuery(height int64) string
 	// Returns a query to retrieve all of a single Actor's attributes.
 	GetQuery(address string, height int64) string
 	// Returns all actors at that height
diff --git a/persistence/types/shared_sql.go b/persistence/types/shared_sql.go
index e36907124..6e1f929c7 100644
--- a/persistence/types/shared_sql.go
+++ b/persistence/types/shared_sql.go
@@ -69,6 +69,11 @@ func ProtocolActorChainsTableSchema(constraintName string) string {
 		)`, AddressCol, ChainIDCol, HeightCol, DefaultBigInt, constraintName, AddressCol, ChainIDCol, HeightCol)
 }
 
+func SelectAtHeight(selector string, height int64, tableName string) string {
+	return fmt.Sprintf(`SELECT %s FROM %s WHERE height=%d`,
+		selector, tableName, height)
+}
+
 func Select(selector, address string, height int64, tableName string) string {
 	return fmt.Sprintf(`SELECT %s FROM %s WHERE address='%s' AND height<=%d ORDER BY height DESC LIMIT 1`,
 		selector, tableName, address, height)
diff --git a/shared/codec/codec.go b/shared/codec/codec.go
index ac7765673..a41fe2e0b 100644
--- a/shared/codec/codec.go
+++ b/shared/codec/codec.go
@@ -5,6 +5,8 @@ import (
 	"google.golang.org/protobuf/types/known/anypb"
 )
 
+// TODO: Use generics in place of `proto.Message` in the interface below
+//       so every caller does not need to do in place casting.
 type Codec interface { // TODO (Team) move to shared. Possibly rename
 	Marshal(proto.Message) ([]byte, error)
 	Unmarshal([]byte, proto.Message) error
@@ -14,6 +16,8 @@ type Codec interface { // TODO (Team) move to shared. Possibly rename
 
 var _ Codec = &ProtoCodec{}
 
+// TODO: Need to define a type like `type ProtoAny anypb.Any` so that we are
+//       mixing protobufs and a centralized codec structure throughout the codebase.
 type ProtoCodec struct{}
 
 func (p *ProtoCodec) Marshal(message proto.Message) ([]byte, error) {
diff --git a/shared/docs/flows/README.md b/shared/docs/flows/README.md
deleted file mode 100644
index cb4e5d663..000000000
--- a/shared/docs/flows/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# Flows
-
-The purpose of [shared/flows](./) is to document cross-module communication for end-to-end behaviour that has cross-module dependencies and and depends on the interfaces exposed by the interfaces exposed in [shared/modules](../modules).
diff --git a/shared/indexer/indexer.go b/shared/indexer/indexer.go
index 559ca1f6e..59355787f 100644
--- a/shared/indexer/indexer.go
+++ b/shared/indexer/indexer.go
@@ -5,6 +5,7 @@ package indexer
 import (
 	"encoding/hex"
 	"fmt"
+
 	"github.com/pokt-network/pocket/shared/codec"
 
 	"github.com/jordanorelli/lexnum"
@@ -111,7 +112,7 @@ type txIndexer struct {
 }
 
 func NewTxIndexer(databasePath string) (TxIndexer, error) {
-	db, err := kvstore.NewKVStore(databasePath)
+	db, err := kvstore.OpenKVStore(databasePath)
 	return &txIndexer{
 		db: db,
 	}, err
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index 9379f6362..dd4f7fd19 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -109,6 +109,29 @@ type PersistenceWriteContext interface {
 	// Flag Operations
 	InitFlags() error
 	SetFlag(paramName string, value interface{}, enabled bool) error
+
+	// Tree Operations
+
+	// # Option 1:
+
+	UpdateApplicationsTree([]Actor) error
+	// UpdateValidatorsTree([]Actor) error
+	// UpdateServiceNodesTree([]Actor) error
+	// UpdateFishermanTree([]Actor) error
+	// Update<FutureActors>Tree([]Actor) error
+	// Update<Other>Tree([]Other) error
+
+	// # Option 2:
+	// UpdateActorTree(types.ProtocolActorSchema, []Actor) error
+	// Update<Other>Tree([]Other) error
+
+	// # Option 3:
+	// UpdateApplicationsTree([]Application) error
+	// UpdateValidatorsTree([]Validator) error
+	// UpdateServiceNodesTree([]ServiceNode) error
+	// UpdateFishermanTree([]Fisherman) error
+	// Update<FutureActors>Tree([]FutureActor) error
+	// Update<Other>Tree([]Other) error
 }
 
 type PersistenceReadContext interface {
@@ -185,4 +208,28 @@ type PersistenceReadContext interface {
 	GetIntFlag(paramName string, height int64) (int, bool, error)
 	GetStringFlag(paramName string, height int64) (string, bool, error)
 	GetBytesFlag(paramName string, height int64) ([]byte, bool, error)
+
+	// Tree Operations
+
+	// # Option 1:
+
+	// GetApplicationsUpdatedAtHeight(height int64) ([]Actor, error)
+	// GetValidatorsUpdatedAtHeight(height int64) ([]Actor, error)
+	// GetServiceNodesUpdatedAtHeight(height int64) ([]Actor, error)
+	// GetFishermanUpdatedAtHeight(height int64) ([]Actor, error)
+	// Get<FutureActor>UpdatedAtHeight(height int64) ([]Actor, error)
+	// Get<Other>UpdatedAtHeight(height int64) ([]Actor, error)
+	// Update<Other>Tree(height int64) ([]Actor, error)
+
+	// # Option 2:
+	// Get<FutureActor>UpdatedAtHeight(types.ProtocolActorSchema, height int64) ([]Actor, error)
+	// Get<Other>UpdatedAtHeight(height int64) ([]Other, error)
+
+	// # Option 3:
+	// GetApplicationsUpdatedAtHeight(height int64) ([]Application, error)
+	// GetValidatorsUpdatedAtHeight(height int64) ([]Validator, error)
+	// GetServiceNodesUpdatedAtHeight(height int64) ([]ServiceNode, error)
+	// GetFishermanUpdatedAtHeight(height int64) ([]Fisherman, error)
+	// Get<FutureActor>UpdatedAtHeight(height int64) ([]FutureActor, error)
+	// Get<Other>UpdatedAtHeight(height int64) ([]Other, error)
 }
diff --git a/shared/test_artifacts/generator.go b/shared/test_artifacts/generator.go
index 6d6923d32..a48fbc7a3 100644
--- a/shared/test_artifacts/generator.go
+++ b/shared/test_artifacts/generator.go
@@ -2,11 +2,12 @@ package test_artifacts
 
 import (
 	"fmt"
+	"math/big"
+	"strconv"
+
 	typesPersistence "github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 	"github.com/pokt-network/pocket/utility/types"
-	"math/big"
-	"strconv"
 
 	"github.com/pokt-network/pocket/shared/crypto"
 	"google.golang.org/protobuf/types/known/timestamppb"
diff --git a/utility/block.go b/utility/block.go
index 1bca5f6c1..7394b04b0 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -33,6 +33,8 @@ var (
 
 func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) ([]byte, error) {
 	u.LatestHeight = latestHeight
+	u.CurrentProposer = proposerAddress
+
 	// begin block lifecycle phase
 	if err := u.BeginBlock(lastBlockByzantineValidators); err != nil {
 		return nil, err
@@ -50,22 +52,30 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 		if err := u.ApplyTransaction(tx); err != nil {
 			return nil, err
 		}
-		if err := u.GetPersistenceContext().StoreTransaction(transactionProtoBytes); err != nil {
+		if err := u.Context.PersistenceRWContext.StoreTransaction(transactionProtoBytes); err != nil {
 			return nil, err
 		}
 
-		// TODO: if found, remove transaction from mempool
 		// DISCUSS: What if the context is rolled back or cancelled. Do we add it back to the mempool?
+		// TODO: if found, remove transaction from mempool
 		// if err := u.Mempool.DeleteTransaction(transaction); err != nil {
 		// 	return nil, err
 		// }
 	}
+
 	// end block lifecycle phase
 	if err := u.EndBlock(proposerAddress); err != nil {
 		return nil, err
 	}
-	// return the app hash (consensus module will get the validator set directly
-	return u.GetAppHash()
+
+	// TODO: What if everything above succeeded but updating the app hash failed?
+	appHash, err := u.Context.UpdateAppHash()
+	if err != nil {
+		return nil, typesUtil.ErrAppHash(err)
+	}
+
+	// return the app hash; consensus module will get the validator set directly
+	return appHash, nil
 }
 
 func (u *UtilityContext) BeginBlock(previousBlockByzantineValidators [][]byte) typesUtil.Error {
@@ -91,15 +101,6 @@ func (u *UtilityContext) EndBlock(proposer []byte) typesUtil.Error {
 	return nil
 }
 
-func (u *UtilityContext) GetAppHash() ([]byte, typesUtil.Error) {
-	// Get the root hash of the merkle state tree for state consensus integrity
-	appHash, er := u.Context.AppHash()
-	if er != nil {
-		return nil, typesUtil.ErrAppHash(er)
-	}
-	return appHash, nil
-}
-
 // HandleByzantineValidators handles the validators who either didn't sign at all or disagreed with the 2/3+ majority
 func (u *UtilityContext) HandleByzantineValidators(lastBlockByzantineValidators [][]byte) typesUtil.Error {
 	latestBlockHeight, err := u.GetLatestBlockHeight()
diff --git a/utility/context.go b/utility/context.go
index c3f97f3a8..a8797a52c 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -2,19 +2,24 @@ package utility
 
 import (
 	"encoding/hex"
+
 	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/modules"
 	typesUtil "github.com/pokt-network/pocket/utility/types"
 )
 
 type UtilityContext struct {
-	LatestHeight int64
-	Mempool      typesUtil.Mempool
-	Context      *Context // IMPROVE: Consider renmaming to PersistenceContext
+	LatestHeight    int64 // IMPROVE: Rename to `currentHeight?`
+	CurrentProposer []byte
+
+	Mempool typesUtil.Mempool
+	Context *Context // IMPROVE: Rename to `persistenceContext` or `storeContext` or `reversibleContext`?
 }
 
-type Context struct {
+type Context struct { // IMPROVE: Rename to `persistenceContext` or `storeContext`?
+	// TODO: Since `Context` embeds `PersistenceRWContext`, we don't need to do `u.Context.PersistenceRWContext`, but can call `u.Context` directly
 	modules.PersistenceRWContext
+	// TODO/DISCUSS: `SavePoints`` have not been implemented yet
 	SavePointsM map[string]struct{}
 	SavePoints  [][]byte
 }
@@ -39,17 +44,16 @@ func (u *UtilityContext) Store() *Context {
 	return u.Context
 }
 
-func (u *UtilityContext) GetPersistenceContext() modules.PersistenceRWContext {
-	return u.Context.PersistenceRWContext
-}
-
-func (u *UtilityContext) CommitPersistenceContext() error {
-	return u.Context.PersistenceRWContext.Commit()
+func (u *UtilityContext) CommitContext(quorumCert []byte) error {
+	err := u.Context.PersistenceRWContext.Commit(u.CurrentProposer, quorumCert)
+	u.Context = nil // DISCUSS: Should we release the context if there was an error here?
+	return err
 }
 
-func (u *UtilityContext) ReleaseContext() {
-	u.Context.Release()
+func (u *UtilityContext) ReleaseContext() error {
+	err := u.Context.Release()
 	u.Context = nil
+	return err
 }
 
 func (u *UtilityContext) GetLatestBlockHeight() (int64, typesUtil.Error) {
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index b59f31bef..13c6b2175 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -2,12 +2,16 @@ package test
 
 import (
 	"encoding/hex"
+	"fmt"
 	"github.com/pokt-network/pocket/shared/modules"
-	"github.com/pokt-network/pocket/shared/test_artifacts"
+	"github.com/pokt-network/pocket/shared/test_artifacts"s/249/consensus_techdebt
 	"math"
 	"math/big"
 	"testing"
 
+	"github.com/pokt-network/pocket/shared/modules"
+	"github.com/pokt-network/pocket/shared/test_artifacts"
+
 	typesUtil "github.com/pokt-network/pocket/utility/types"
 	"github.com/stretchr/testify/require"
 )
@@ -171,19 +175,6 @@ func TestUtilityContext_EndBlock(t *testing.T) {
 	test_artifacts.CleanupTest(ctx)
 }
 
-func TestUtilityContext_GetAppHash(t *testing.T) {
-	ctx := NewTestingUtilityContext(t, 0)
-
-	appHashTest, err := ctx.GetAppHash()
-	require.NoError(t, err)
-
-	appHashSource, er := ctx.Context.AppHash()
-	require.NoError(t, er)
-	require.Equal(t, appHashTest, appHashSource, "unexpected appHash")
-
-	test_artifacts.CleanupTest(ctx)
-}
-
 func TestUtilityContext_UnstakeValidatorsActorsThatAreReady(t *testing.T) {
 	for _, actorType := range typesUtil.ActorTypes {
 		ctx := NewTestingUtilityContext(t, 1)

From 342de6ae400a680f6a8b6af54dcde97561acbbbe Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 4 Oct 2022 19:15:38 -0700
Subject: [PATCH 067/227] Temp checkout commit

---
 consensus/block.go                   | 45 ++++++++++++++++++++----
 go.mod                               |  3 +-
 go.sum                               |  2 --
 persistence/application.go           | 51 ----------------------------
 persistence/block.go                 | 42 +++++------------------
 persistence/context.go               | 26 ++++----------
 persistence/db.go                    |  8 -----
 persistence/debug.go                 |  2 +-
 persistence/genesis.go               |  4 +--
 persistence/kvstore/kvstore.go       | 35 +++----------------
 persistence/module.go                | 31 +++--------------
 persistence/shared_sql.go            | 40 ++--------------------
 persistence/test/module_test.go      |  4 +--
 persistence/types/base_actor.go      |  7 +---
 persistence/types/protocol_actor.go  |  3 --
 persistence/types/shared_sql.go      |  5 ---
 shared/codec/codec.go                |  4 ---
 shared/docs/flows/README.md          |  3 ++
 shared/indexer/indexer.go            |  3 +-
 shared/modules/persistence_module.go | 47 -------------------------
 shared/test_artifacts/generator.go   |  5 ++-
 utility/block.go                     | 27 +++++++--------
 utility/context.go                   | 28 +++++++--------
 utility/test/block_test.go           | 19 ++++++++---
 24 files changed, 116 insertions(+), 328 deletions(-)
 create mode 100644 shared/docs/flows/README.md

diff --git a/consensus/block.go b/consensus/block.go
index 14675bbd5..536c3cc74 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -4,6 +4,8 @@ import (
 	"encoding/hex"
 	"unsafe"
 
+	"github.com/pokt-network/pocket/shared/codec"
+
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
 
@@ -87,9 +89,7 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 	// should not be called.
 	if m.utilityContext != nil {
 		m.nodeLog(typesCons.NilUtilityContextWarning)
-		if err := m.utilityContext.Release(); err != nil {
-			return err
-		}
+		m.utilityContext.ReleaseContext()
 		m.utilityContext = nil
 	}
 
@@ -105,14 +105,47 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
 
+	// Store the block in the KV store
+	codec := codec.GetCodec()
+	blockProtoBytes, err := codec.Marshal(block)
+	if err != nil {
+		return err
+	}
+
+	// IMPROVE(olshansky): temporary solution. `ApplyBlock` above applies the
+	// transactions to the postgres database, and this stores it in the KV store upon commitment.
+	// Instead of calling this directly, an alternative solution is to store the block metadata in
+	// the persistence context and have `CommitPersistenceContext` do this under the hood. However,
+	// additional `Block` metadata will need to be passed through and may change when we merkle the
+	// state hash.
+	if err := m.storeBlock(block, blockProtoBytes); err != nil {
+		return err
+	}
+
 	// Commit and release the context
-	if err := m.utilityContext.Commit(block.BlockHeader.QuorumCertificate); err != nil {
+	if err := m.utilityContext.CommitPersistenceContext(); err != nil {
 		return err
 	}
-	m.utilityContext.Release()
+
+	m.utilityContext.ReleaseContext()
 	m.utilityContext = nil
 
-	m.lastAppHash = block.BlockHeader.Hash
+	m.appHash = block.BlockHeader.Hash
 
 	return nil
 }
+
+func (m *ConsensusModule) storeBlock(block *typesCons.Block, blockProtoBytes []byte) error {
+	store := m.utilityContext.GetPersistenceContext()
+	// Store in KV Store
+	if err := store.StoreBlock(blockProtoBytes); err != nil {
+		return err
+	}
+
+	// Store in SQL Store
+	header := block.BlockHeader
+	if err := store.InsertBlock(uint64(header.Height), header.Hash, header.ProposerAddress, header.QuorumCertificate); err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/go.mod b/go.mod
index 30f937624..1aa121424 100644
--- a/go.mod
+++ b/go.mod
@@ -20,7 +20,6 @@ require (
 )
 
 require (
-	github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884
 	github.com/benbjohnson/clock v1.3.0
 	github.com/dgraph-io/badger/v3 v3.2103.2
 	github.com/jackc/pgconn v1.11.0
@@ -39,7 +38,7 @@ require (
 	github.com/docker/go-connections v0.4.0 // indirect
 	github.com/docker/go-units v0.4.0 // indirect
 	github.com/dustin/go-humanize v1.0.0 // indirect
-	github.com/gogo/protobuf v1.3.2
+	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b // indirect
 	github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
diff --git a/go.sum b/go.sum
index f7e72a772..8d255a0b5 100644
--- a/go.sum
+++ b/go.sum
@@ -63,8 +63,6 @@ github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+Ce
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/boombuler/barcode v1.0.0/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8=
-github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884 h1:iRNKw2WmAbVgGMNYzDH5Y2yY3+jyxwEK9Hc5pwIjZAE=
-github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884/go.mod h1:/sdYDakowo/XaxS2Fl7CBqtuf/O2uTqF2zmAUFAtAiw=
 github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4=
 github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
diff --git a/persistence/application.go b/persistence/application.go
index 755288155..78750a7b6 100644
--- a/persistence/application.go
+++ b/persistence/application.go
@@ -4,66 +4,15 @@ import (
 	"encoding/hex"
 
 	"github.com/pokt-network/pocket/persistence/types"
-	"google.golang.org/protobuf/proto"
-
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
-func (p PostgresContext) UpdateApplicationsTree(apps []modules.Actor) error {
-	for _, app := range apps {
-		bzAddr, err := hex.DecodeString(app.GetAddress())
-		if err != nil {
-			return err
-		}
-
-		appBz, err := proto.Marshal(app.(*types.Actor))
-		if err != nil {
-			return err
-		}
-
-		// OPTIMIZE: This is the only line unique to `Application`
-		if _, err := p.MerkleTrees[appMerkleTree].Update(bzAddr, appBz); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (p PostgresContext) getApplicationsUpdatedAtHeight(height int64) (apps []*types.Actor, err error) {
-	// OPTIMIZE: This is the only line unique to `Application`
-	actors, err := p.GetActorsUpdated(types.ApplicationActor, height)
-	if err != nil {
-		return nil, err
-	}
-
-	apps = make([]*types.Actor, len(actors))
-	for _, actor := range actors {
-		app := &types.Actor{
-			ActorType:       types.ActorType_App,
-			Address:         actor.Address,
-			PublicKey:       actor.PublicKey,
-			Chains:          actor.Chains,
-			GenericParam:    actor.ActorSpecificParam,
-			StakedAmount:    actor.StakedTokens,
-			PausedHeight:    actor.PausedHeight,
-			UnstakingHeight: actor.UnstakingHeight,
-			Output:          actor.OutputAddress,
-		}
-		apps = append(apps, app)
-	}
-	return
-}
-
 func (p PostgresContext) GetAppExists(address []byte, height int64) (exists bool, err error) {
 	return p.GetExists(types.ApplicationActor, address, height)
 }
 
 func (p PostgresContext) GetApp(address []byte, height int64) (operator, publicKey, stakedTokens, maxRelays, outputAddress string, pauseHeight, unstakingHeight int64, chains []string, err error) {
 	actor, err := p.GetActor(types.ApplicationActor, address, height)
-	if err != nil {
-		return
-	}
 	operator = actor.Address
 	publicKey = actor.PublicKey
 	stakedTokens = actor.StakedTokens
diff --git a/persistence/block.go b/persistence/block.go
index 5efa1b71e..aaee96364 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -5,7 +5,6 @@ import (
 	"encoding/hex"
 	"log"
 
-	"github.com/gogo/protobuf/proto"
 	"github.com/pokt-network/pocket/persistence/types"
 )
 
@@ -50,44 +49,21 @@ func (p PostgresContext) StoreTransaction(transactionProtoBytes []byte) error {
 	return nil
 }
 
-func (p PostgresContext) insertBlock(block *types.Block) error {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return err
-	}
-
-	_, err = tx.Exec(ctx, types.InsertBlockQuery(block.Height, block.Hash, block.ProposerAddress, block.QuorumCertificate))
-	return err
+func (p PostgresContext) StoreBlock(blockProtoBytes []byte) error {
+	// INVESTIGATE: Note that we are writing this directly to the blockStore. Depending on how
+	// the use of the PostgresContext evolves, we may need to write this to `ContextStore` and copy
+	// over to `BlockStore` when the block is committed.
+	return p.blockstore.Put(heightToBytes(p.Height), blockProtoBytes)
 }
 
-func (p PostgresContext) storeBlock(block *types.Block) error {
-	blockBz, err := proto.Marshal(block)
+func (p PostgresContext) InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error {
+	ctx, tx, err := p.GetCtxAndTx()
 	if err != nil {
 		return err
 	}
 
-	return p.blockstore.Put(heightToBytes(p.Height), blockBz)
-}
-
-func (p PostgresContext) getBlock(proposerAddr []byte, quorumCert []byte) (*types.Block, error) {
-	prevHash, err := p.GetBlockHash(p.Height - 1)
-	if err != nil {
-		return nil, err
-	}
-
-	// TODO: get this from the transactions that were store via `StoreTransaction`
-	txs := make([][]byte, 0)
-
-	block := &types.Block{
-		Height:            uint64(p.Height),
-		Hash:              string(p.stateHash),
-		PrevHash:          string(prevHash),
-		ProposerAddress:   proposerAddr,
-		QuorumCertificate: quorumCert,
-		Transactions:      txs,
-	}
-
-	return block, nil
+	_, err = tx.Exec(ctx, types.InsertBlockQuery(height, hash, proposerAddr, quorumCert))
+	return err
 }
 
 // CLEANUP: Should this be moved to a shared directory?
diff --git a/persistence/context.go b/persistence/context.go
index 8224a229a..fd44e3af1 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -15,39 +15,25 @@ func (p PostgresContext) RollbackToSavePoint(bytes []byte) error {
 	return p.GetTx().Rollback(context.TODO())
 }
 
-func (p PostgresContext) UpdateAppHash() ([]byte, error) {
-	if err := p.updateStateHash(); err != nil {
-		return nil, err
-	}
-	return p.stateHash, nil
+func (p PostgresContext) AppHash() ([]byte, error) {
+	log.Println("TODO: AppHash not implemented")
+	return []byte("A real app hash, I am not"), nil
 }
 
 func (p PostgresContext) Reset() error {
 	panic("TODO: PostgresContext Reset not implemented")
 }
 
-func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
+func (p PostgresContext) Commit() error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
-	block, err := p.getBlock(proposerAddr, quorumCert)
-	if err != nil {
-		return err
-	}
-
-	if err := p.insertBlock(block); err != nil {
-		return err
-	}
-
-	if err := p.storeBlock(block); err != nil {
-		return err
-	}
-
 	ctx := context.TODO()
-	if err := p.GetTx().Commit(ctx); err != nil {
+	if err := p.GetTx().Commit(context.TODO()); err != nil {
 		return err
 	}
 	if err := p.conn.Close(ctx); err != nil {
 		log.Println("[TODO][ERROR] Implement connection pooling. Error when closing DB connecting...", err)
+
 	}
 	return nil
 }
diff --git a/persistence/db.go b/persistence/db.go
index b8a974939..3a495596c 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -7,7 +7,6 @@ import (
 
 	"github.com/pokt-network/pocket/persistence/types"
 
-	"github.com/celestiaorg/smt"
 	"github.com/jackc/pgconn"
 	"github.com/jackc/pgx/v4"
 	"github.com/pokt-network/pocket/persistence/kvstore"
@@ -41,13 +40,6 @@ type PostgresContext struct {
 	conn       *pgx.Conn
 	tx         pgx.Tx
 	blockstore kvstore.KVStore
-
-	stateHash []byte
-	// IMPROVE: Depending on how the use of `PostgresContext` evolves, we may be able to get
-	// access to these directly via the postgres module.
-	PostgresDB  *pgx.Conn
-	BlockStore  kvstore.KVStore                      // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context)
-	MerkleTrees map[MerkleTree]*smt.SparseMerkleTree // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context)
 }
 
 func (pg *PostgresContext) GetCtxAndTx() (context.Context, pgx.Tx, error) {
diff --git a/persistence/debug.go b/persistence/debug.go
index e0e3b6e5e..3fdc583a4 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -44,7 +44,7 @@ func (m *PersistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 
 func (m *PersistenceModule) clearState(_ *debug.DebugMessage) {
 	context, err := m.NewRWContext(-1)
-	defer context.Commit(nil, nil)
+	defer context.Commit()
 	if err != nil {
 		log.Printf("Error creating new context: %s \n", err)
 		return
diff --git a/persistence/genesis.go b/persistence/genesis.go
index a6eefaa90..1c7e82f14 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -149,7 +149,7 @@ func (m *PersistenceModule) populateGenesisState(state *types.PersistenceGenesis
 		log.Fatalf("an error occurred initializing flags: %s", err.Error())
 	}
 
-	if err = rwContext.Commit(nil, nil); err != nil {
+	if err = rwContext.Commit(); err != nil {
 		log.Fatalf("an error occurred during commit() on genesis state %s ", err.Error())
 	}
 }
@@ -316,7 +316,7 @@ func (p PostgresContext) GetAllFishermen(height int64) (f []modules.Actor, err e
 	return
 }
 
-// CONSOLIDATE: Consolidate `types.BaseActor` with `types.Actor`
+// TODO (Team) deprecate with interface #163 <Bumped to #149> as #163 is getting large
 func (p PostgresContext) BaseActorToActor(ba types.BaseActor, actorType types.ActorType) *types.Actor {
 	actor := new(types.Actor)
 	actor.ActorType = actorType
diff --git a/persistence/kvstore/kvstore.go b/persistence/kvstore/kvstore.go
index 8636e4519..24613afc9 100644
--- a/persistence/kvstore/kvstore.go
+++ b/persistence/kvstore/kvstore.go
@@ -1,47 +1,33 @@
 package kvstore
 
 import (
-	"errors"
 	"log"
 
-	"github.com/celestiaorg/smt"
 	badger "github.com/dgraph-io/badger/v3"
 )
 
+// CLEANUP: move this structure to a shared module
 type KVStore interface {
 	// Lifecycle methods
 	Stop() error
 
 	// Accessors
 	// TODO: Add a proper iterator interface
+	Put(key []byte, value []byte) error
+	Get(key []byte) ([]byte, error)
 	// TODO: Add pagination for `GetAll`
 	GetAll(prefixKey []byte, descending bool) ([][]byte, error)
-
 	Exists(key []byte) (bool, error)
 	ClearAll() error
-
-	// Same interface as in `smt.MapStore``
-	Put(key, value []byte) error
-	Get(key []byte) ([]byte, error)
-	Delete(key []byte) error
 }
 
 var _ KVStore = &badgerKVStore{}
-var _ smt.MapStore = &badgerKVStore{}
-
-var (
-	ErrKVStoreExists    = errors.New("kvstore already exists")
-	ErrKVStoreNotExists = errors.New("kvstore does not exist")
-)
 
 type badgerKVStore struct {
 	db *badger.DB
 }
 
-// REFACTOR: Loads or creates a badgerDb at `path`. This may potentially need to be refactored
-// into `NewKVStore` and `LoadKVStore` depending on how state sync evolves by leveraging `os.Stat`
-// on the file path.
-func OpenKVStore(path string) (KVStore, error) {
+func NewKVStore(path string) (KVStore, error) {
 	db, err := badger.Open(badger.DefaultOptions(path))
 	if err != nil {
 		return nil, err
@@ -57,7 +43,7 @@ func NewMemKVStore() KVStore {
 	return badgerKVStore{db: db}
 }
 
-func (store badgerKVStore) Put(key, value []byte) error {
+func (store badgerKVStore) Put(key []byte, value []byte) error {
 	tx := store.db.NewTransaction(true)
 	defer tx.Discard()
 
@@ -69,12 +55,6 @@ func (store badgerKVStore) Put(key, value []byte) error {
 	return tx.Commit()
 }
 
-// CONSOLIDATE: We might be able to remove the `KVStore` interface altogether if we end up using `smt.MapStore`
-// A wrapper around `Put` to conform to the `smt.MapStore` interface
-func (store *badgerKVStore) Set(key, value []byte) error {
-	return store.Put(key, value)
-}
-
 func (store badgerKVStore) Get(key []byte) ([]byte, error) {
 	tx := store.db.NewTransaction(false)
 	defer tx.Discard()
@@ -96,11 +76,6 @@ func (store badgerKVStore) Get(key []byte) ([]byte, error) {
 	return value, nil
 }
 
-func (store badgerKVStore) Delete(key []byte) error {
-	log.Fatalf("badgerKVStore.Delete not implemented yet")
-	return nil
-}
-
 func (store badgerKVStore) GetAll(prefix []byte, descending bool) (values [][]byte, err error) {
 	// INVESTIGATE: research `badger.views` for further improvements and optimizations
 	txn := store.db.NewTransaction(false)
diff --git a/persistence/module.go b/persistence/module.go
index 6761bb22b..33bd827bd 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -7,10 +7,10 @@ import (
 	"io/ioutil"
 	"log"
 
-	"github.com/celestiaorg/smt"
+	"github.com/pokt-network/pocket/persistence/types"
+
 	"github.com/jackc/pgx/v4"
 	"github.com/pokt-network/pocket/persistence/kvstore"
-	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 	"github.com/pokt-network/pocket/shared/test_artifacts"
 )
@@ -26,19 +26,10 @@ type PersistenceModule struct {
 	postgresURL string
 	nodeSchema  string
 	genesisPath string
+	blockStore  kvstore.KVStore // INVESTIGATE: We may need to create a custom `BlockStore` package in the future
 
 	// TECHDEBT: Need to implement context pooling (for writes), timeouts (for read & writes), etc...
 	writeContext *PostgresContext // only one write context is allowed at a time
-
-	// The connection to the PostgreSQL database
-	postgresConn *pgx.Conn
-	// A reference to the block key-value store
-	// INVESTIGATE: We may need to create a custom `BlockStore` package in the future.
-	blockStore kvstore.KVStore
-	// A mapping of context IDs to persistence contexts
-	// contexts map[contextId]modules.PersistenceRWContext
-	// Merkle trees
-	trees map[MerkleTree]*smt.SparseMerkleTree
 }
 
 const (
@@ -51,10 +42,8 @@ func Create(configPath, genesisPath string) (modules.PersistenceModule, error) {
 	if err != nil {
 		return nil, err
 	}
-
 	cfg := c.(*types.PersistenceConfig)
 	g, err := m.InitGenesis(genesisPath)
-
 	if err != nil {
 		return nil, err
 	}
@@ -80,20 +69,8 @@ func Create(configPath, genesisPath string) (modules.PersistenceModule, error) {
 		genesisPath:  genesisPath,
 		blockStore:   blockStore,
 		writeContext: nil,
-		// contexts:     make(map[contextId]modules.PersistenceContext),
-		trees: make(map[MerkleTree]*smt.SparseMerkleTree),
 	}
 
-	// DISCUSS_IN_THIS_COMMIT: We've been using the module function pattern, but this making `initializeTrees`
-	// be able to create and/or load trees outside the scope of the persistence module makes it easier to test.
-	trees, err := newMerkleTrees()
-	if err != nil {
-		return nil, err
-	}
-
-	// TODO_IN_THIS_COMMIT: load trees from state
-	persistenceMod.trees = trees
-
 	// Determine if we should hydrate the genesis db or use the current state of the DB attached
 	if shouldHydrateGenesis, err := persistenceMod.shouldHydrateGenesisDb(); err != nil {
 		return nil, err
@@ -237,7 +214,7 @@ func initializeBlockStore(blockStorePath string) (kvstore.KVStore, error) {
 	if blockStorePath == "" {
 		return kvstore.NewMemKVStore(), nil
 	}
-	return kvstore.OpenKVStore(blockStorePath)
+	return kvstore.NewKVStore(blockStorePath)
 }
 
 // TODO(drewsky): Simplify and externalize the logic for whether genesis should be populated and
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
index 8eac77562..9f2c19a00 100644
--- a/persistence/shared_sql.go
+++ b/persistence/shared_sql.go
@@ -44,36 +44,6 @@ func (p *PostgresContext) GetExists(actorSchema types.ProtocolActorSchema, addre
 	return
 }
 
-func (p *PostgresContext) GetActorsUpdated(actorSchema types.ProtocolActorSchema, height int64) (actors []types.BaseActor, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return
-	}
-
-	rows, err := tx.Query(ctx, actorSchema.GetUpdatedAtHeightQuery(height))
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	// OPTIMIZE: Consolidate logic with `GetActor` to reduce code footprint
-	var addr string
-	for rows.Next() {
-		if err = rows.Scan(&addr); err != nil {
-			return
-		}
-
-		actor, err := p.GetActor(actorSchema, []byte(addr), height)
-		if err != nil {
-			return nil, err
-		}
-
-		actors = append(actors, actor)
-	}
-
-	return
-}
-
 func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, address []byte, height int64) (actor types.BaseActor, err error) {
 	ctx, tx, err := p.GetCtxAndTx()
 	if err != nil {
@@ -87,16 +57,10 @@ func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, addres
 	return p.GetChainsForActor(ctx, tx, actorSchema, actor, height)
 }
 
-// IMPORTANT: Need to consolidate `persistence/types.BaseActor` with `persistence/genesisTypes.Actor`
 func (p *PostgresContext) GetActorFromRow(row pgx.Row) (actor types.BaseActor, height int64, err error) {
 	err = row.Scan(
-		&actor.Address,
-		&actor.PublicKey,
-		&actor.StakedTokens,
-		&actor.ActorSpecificParam,
-		&actor.OutputAddress,
-		&actor.PausedHeight,
-		&actor.UnstakingHeight,
+		&actor.Address, &actor.PublicKey, &actor.StakedTokens, &actor.ActorSpecificParam,
+		&actor.OutputAddress, &actor.PausedHeight, &actor.UnstakingHeight,
 		&height)
 	return
 }
diff --git a/persistence/test/module_test.go b/persistence/test/module_test.go
index ccb7bd37f..3bee636c5 100644
--- a/persistence/test/module_test.go
+++ b/persistence/test/module_test.go
@@ -18,14 +18,12 @@ func TestPersistenceContextParallelReadWrite(t *testing.T) {
 	poolAddress := []byte("address")
 	originalAmount := "15"
 	modifiedAmount := "10"
-	proposer := []byte("proposer")
-	quorumCert := []byte("quorumCert")
 
 	// setup a write context, insert a pool and commit it
 	context, err := testPersistenceMod.NewRWContext(0)
 	require.NoError(t, err)
 	require.NoError(t, context.InsertPool(poolName, poolAddress, originalAmount))
-	require.NoError(t, context.Commit(proposer, quorumCert))
+	require.NoError(t, context.Commit())
 
 	// verify the insert in the previously committed context worked
 	contextA, err := testPersistenceMod.NewRWContext(0)
diff --git a/persistence/types/base_actor.go b/persistence/types/base_actor.go
index 1c73da9a7..9514b15eb 100644
--- a/persistence/types/base_actor.go
+++ b/persistence/types/base_actor.go
@@ -1,6 +1,5 @@
 package types
 
-// IMPROVE: Move schema related functions to a separate sub-package
 import "github.com/pokt-network/pocket/shared/modules"
 
 // TECHDEBT: Consider moving this to a protobuf. This struct was created to make testing simple of protocol actors that
@@ -61,10 +60,6 @@ func (actor *BaseProtocolActorSchema) GetChainsTableSchema() string {
 	return ProtocolActorChainsTableSchema(actor.chainsHeightConstraintName)
 }
 
-func (actor *BaseProtocolActorSchema) GetUpdatedAtHeightQuery(height int64) string {
-	return SelectAtHeight(AddressCol, height, actor.tableName)
-}
-
 func (actor *BaseProtocolActorSchema) GetQuery(address string, height int64) string {
 	return Select(AllColsSelector, address, height, actor.tableName)
 }
@@ -155,5 +150,5 @@ func (x *Actor) GetActorTyp() modules.ActorType {
 	if x != nil {
 		return x.GetActorType()
 	}
-	return ActorType_App // HACK: Is this a hack?
+	return ActorType_App
 }
diff --git a/persistence/types/protocol_actor.go b/persistence/types/protocol_actor.go
index 709457b6c..1052dc3d6 100644
--- a/persistence/types/protocol_actor.go
+++ b/persistence/types/protocol_actor.go
@@ -15,9 +15,6 @@ type ProtocolActorSchema interface {
 	GetActorSpecificColName() string
 
 	/*** Read/Get Queries ***/
-
-	// Returns a query to retrieve the addresses of all the Actors updated at that specific height
-	GetUpdatedAtHeightQuery(height int64) string
 	// Returns a query to retrieve all of a single Actor's attributes.
 	GetQuery(address string, height int64) string
 	// Returns all actors at that height
diff --git a/persistence/types/shared_sql.go b/persistence/types/shared_sql.go
index 6e1f929c7..e36907124 100644
--- a/persistence/types/shared_sql.go
+++ b/persistence/types/shared_sql.go
@@ -69,11 +69,6 @@ func ProtocolActorChainsTableSchema(constraintName string) string {
 		)`, AddressCol, ChainIDCol, HeightCol, DefaultBigInt, constraintName, AddressCol, ChainIDCol, HeightCol)
 }
 
-func SelectAtHeight(selector string, height int64, tableName string) string {
-	return fmt.Sprintf(`SELECT %s FROM %s WHERE height=%d`,
-		selector, tableName, height)
-}
-
 func Select(selector, address string, height int64, tableName string) string {
 	return fmt.Sprintf(`SELECT %s FROM %s WHERE address='%s' AND height<=%d ORDER BY height DESC LIMIT 1`,
 		selector, tableName, address, height)
diff --git a/shared/codec/codec.go b/shared/codec/codec.go
index a41fe2e0b..ac7765673 100644
--- a/shared/codec/codec.go
+++ b/shared/codec/codec.go
@@ -5,8 +5,6 @@ import (
 	"google.golang.org/protobuf/types/known/anypb"
 )
 
-// TODO: Use generics in place of `proto.Message` in the interface below
-//       so every caller does not need to do in place casting.
 type Codec interface { // TODO (Team) move to shared. Possibly rename
 	Marshal(proto.Message) ([]byte, error)
 	Unmarshal([]byte, proto.Message) error
@@ -16,8 +14,6 @@ type Codec interface { // TODO (Team) move to shared. Possibly rename
 
 var _ Codec = &ProtoCodec{}
 
-// TODO: Need to define a type like `type ProtoAny anypb.Any` so that we are
-//       mixing protobufs and a centralized codec structure throughout the codebase.
 type ProtoCodec struct{}
 
 func (p *ProtoCodec) Marshal(message proto.Message) ([]byte, error) {
diff --git a/shared/docs/flows/README.md b/shared/docs/flows/README.md
new file mode 100644
index 000000000..cb4e5d663
--- /dev/null
+++ b/shared/docs/flows/README.md
@@ -0,0 +1,3 @@
+# Flows
+
+The purpose of [shared/flows](./) is to document cross-module communication for end-to-end behaviour that has cross-module dependencies and and depends on the interfaces exposed by the interfaces exposed in [shared/modules](../modules).
diff --git a/shared/indexer/indexer.go b/shared/indexer/indexer.go
index 59355787f..559ca1f6e 100644
--- a/shared/indexer/indexer.go
+++ b/shared/indexer/indexer.go
@@ -5,7 +5,6 @@ package indexer
 import (
 	"encoding/hex"
 	"fmt"
-
 	"github.com/pokt-network/pocket/shared/codec"
 
 	"github.com/jordanorelli/lexnum"
@@ -112,7 +111,7 @@ type txIndexer struct {
 }
 
 func NewTxIndexer(databasePath string) (TxIndexer, error) {
-	db, err := kvstore.OpenKVStore(databasePath)
+	db, err := kvstore.NewKVStore(databasePath)
 	return &txIndexer{
 		db: db,
 	}, err
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index dd4f7fd19..9379f6362 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -109,29 +109,6 @@ type PersistenceWriteContext interface {
 	// Flag Operations
 	InitFlags() error
 	SetFlag(paramName string, value interface{}, enabled bool) error
-
-	// Tree Operations
-
-	// # Option 1:
-
-	UpdateApplicationsTree([]Actor) error
-	// UpdateValidatorsTree([]Actor) error
-	// UpdateServiceNodesTree([]Actor) error
-	// UpdateFishermanTree([]Actor) error
-	// Update<FutureActors>Tree([]Actor) error
-	// Update<Other>Tree([]Other) error
-
-	// # Option 2:
-	// UpdateActorTree(types.ProtocolActorSchema, []Actor) error
-	// Update<Other>Tree([]Other) error
-
-	// # Option 3:
-	// UpdateApplicationsTree([]Application) error
-	// UpdateValidatorsTree([]Validator) error
-	// UpdateServiceNodesTree([]ServiceNode) error
-	// UpdateFishermanTree([]Fisherman) error
-	// Update<FutureActors>Tree([]FutureActor) error
-	// Update<Other>Tree([]Other) error
 }
 
 type PersistenceReadContext interface {
@@ -208,28 +185,4 @@ type PersistenceReadContext interface {
 	GetIntFlag(paramName string, height int64) (int, bool, error)
 	GetStringFlag(paramName string, height int64) (string, bool, error)
 	GetBytesFlag(paramName string, height int64) ([]byte, bool, error)
-
-	// Tree Operations
-
-	// # Option 1:
-
-	// GetApplicationsUpdatedAtHeight(height int64) ([]Actor, error)
-	// GetValidatorsUpdatedAtHeight(height int64) ([]Actor, error)
-	// GetServiceNodesUpdatedAtHeight(height int64) ([]Actor, error)
-	// GetFishermanUpdatedAtHeight(height int64) ([]Actor, error)
-	// Get<FutureActor>UpdatedAtHeight(height int64) ([]Actor, error)
-	// Get<Other>UpdatedAtHeight(height int64) ([]Actor, error)
-	// Update<Other>Tree(height int64) ([]Actor, error)
-
-	// # Option 2:
-	// Get<FutureActor>UpdatedAtHeight(types.ProtocolActorSchema, height int64) ([]Actor, error)
-	// Get<Other>UpdatedAtHeight(height int64) ([]Other, error)
-
-	// # Option 3:
-	// GetApplicationsUpdatedAtHeight(height int64) ([]Application, error)
-	// GetValidatorsUpdatedAtHeight(height int64) ([]Validator, error)
-	// GetServiceNodesUpdatedAtHeight(height int64) ([]ServiceNode, error)
-	// GetFishermanUpdatedAtHeight(height int64) ([]Fisherman, error)
-	// Get<FutureActor>UpdatedAtHeight(height int64) ([]FutureActor, error)
-	// Get<Other>UpdatedAtHeight(height int64) ([]Other, error)
 }
diff --git a/shared/test_artifacts/generator.go b/shared/test_artifacts/generator.go
index a48fbc7a3..6d6923d32 100644
--- a/shared/test_artifacts/generator.go
+++ b/shared/test_artifacts/generator.go
@@ -2,12 +2,11 @@ package test_artifacts
 
 import (
 	"fmt"
-	"math/big"
-	"strconv"
-
 	typesPersistence "github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 	"github.com/pokt-network/pocket/utility/types"
+	"math/big"
+	"strconv"
 
 	"github.com/pokt-network/pocket/shared/crypto"
 	"google.golang.org/protobuf/types/known/timestamppb"
diff --git a/utility/block.go b/utility/block.go
index 7394b04b0..1bca5f6c1 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -33,8 +33,6 @@ var (
 
 func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) ([]byte, error) {
 	u.LatestHeight = latestHeight
-	u.CurrentProposer = proposerAddress
-
 	// begin block lifecycle phase
 	if err := u.BeginBlock(lastBlockByzantineValidators); err != nil {
 		return nil, err
@@ -52,30 +50,22 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 		if err := u.ApplyTransaction(tx); err != nil {
 			return nil, err
 		}
-		if err := u.Context.PersistenceRWContext.StoreTransaction(transactionProtoBytes); err != nil {
+		if err := u.GetPersistenceContext().StoreTransaction(transactionProtoBytes); err != nil {
 			return nil, err
 		}
 
-		// DISCUSS: What if the context is rolled back or cancelled. Do we add it back to the mempool?
 		// TODO: if found, remove transaction from mempool
+		// DISCUSS: What if the context is rolled back or cancelled. Do we add it back to the mempool?
 		// if err := u.Mempool.DeleteTransaction(transaction); err != nil {
 		// 	return nil, err
 		// }
 	}
-
 	// end block lifecycle phase
 	if err := u.EndBlock(proposerAddress); err != nil {
 		return nil, err
 	}
-
-	// TODO: What if everything above succeeded but updating the app hash failed?
-	appHash, err := u.Context.UpdateAppHash()
-	if err != nil {
-		return nil, typesUtil.ErrAppHash(err)
-	}
-
-	// return the app hash; consensus module will get the validator set directly
-	return appHash, nil
+	// return the app hash (consensus module will get the validator set directly
+	return u.GetAppHash()
 }
 
 func (u *UtilityContext) BeginBlock(previousBlockByzantineValidators [][]byte) typesUtil.Error {
@@ -101,6 +91,15 @@ func (u *UtilityContext) EndBlock(proposer []byte) typesUtil.Error {
 	return nil
 }
 
+func (u *UtilityContext) GetAppHash() ([]byte, typesUtil.Error) {
+	// Get the root hash of the merkle state tree for state consensus integrity
+	appHash, er := u.Context.AppHash()
+	if er != nil {
+		return nil, typesUtil.ErrAppHash(er)
+	}
+	return appHash, nil
+}
+
 // HandleByzantineValidators handles the validators who either didn't sign at all or disagreed with the 2/3+ majority
 func (u *UtilityContext) HandleByzantineValidators(lastBlockByzantineValidators [][]byte) typesUtil.Error {
 	latestBlockHeight, err := u.GetLatestBlockHeight()
diff --git a/utility/context.go b/utility/context.go
index a8797a52c..c3f97f3a8 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -2,24 +2,19 @@ package utility
 
 import (
 	"encoding/hex"
-
 	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/modules"
 	typesUtil "github.com/pokt-network/pocket/utility/types"
 )
 
 type UtilityContext struct {
-	LatestHeight    int64 // IMPROVE: Rename to `currentHeight?`
-	CurrentProposer []byte
-
-	Mempool typesUtil.Mempool
-	Context *Context // IMPROVE: Rename to `persistenceContext` or `storeContext` or `reversibleContext`?
+	LatestHeight int64
+	Mempool      typesUtil.Mempool
+	Context      *Context // IMPROVE: Consider renmaming to PersistenceContext
 }
 
-type Context struct { // IMPROVE: Rename to `persistenceContext` or `storeContext`?
-	// TODO: Since `Context` embeds `PersistenceRWContext`, we don't need to do `u.Context.PersistenceRWContext`, but can call `u.Context` directly
+type Context struct {
 	modules.PersistenceRWContext
-	// TODO/DISCUSS: `SavePoints`` have not been implemented yet
 	SavePointsM map[string]struct{}
 	SavePoints  [][]byte
 }
@@ -44,16 +39,17 @@ func (u *UtilityContext) Store() *Context {
 	return u.Context
 }
 
-func (u *UtilityContext) CommitContext(quorumCert []byte) error {
-	err := u.Context.PersistenceRWContext.Commit(u.CurrentProposer, quorumCert)
-	u.Context = nil // DISCUSS: Should we release the context if there was an error here?
-	return err
+func (u *UtilityContext) GetPersistenceContext() modules.PersistenceRWContext {
+	return u.Context.PersistenceRWContext
+}
+
+func (u *UtilityContext) CommitPersistenceContext() error {
+	return u.Context.PersistenceRWContext.Commit()
 }
 
-func (u *UtilityContext) ReleaseContext() error {
-	err := u.Context.Release()
+func (u *UtilityContext) ReleaseContext() {
+	u.Context.Release()
 	u.Context = nil
-	return err
 }
 
 func (u *UtilityContext) GetLatestBlockHeight() (int64, typesUtil.Error) {
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index 13c6b2175..b59f31bef 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -2,16 +2,12 @@ package test
 
 import (
 	"encoding/hex"
-	"fmt"
 	"github.com/pokt-network/pocket/shared/modules"
-	"github.com/pokt-network/pocket/shared/test_artifacts"s/249/consensus_techdebt
+	"github.com/pokt-network/pocket/shared/test_artifacts"
 	"math"
 	"math/big"
 	"testing"
 
-	"github.com/pokt-network/pocket/shared/modules"
-	"github.com/pokt-network/pocket/shared/test_artifacts"
-
 	typesUtil "github.com/pokt-network/pocket/utility/types"
 	"github.com/stretchr/testify/require"
 )
@@ -175,6 +171,19 @@ func TestUtilityContext_EndBlock(t *testing.T) {
 	test_artifacts.CleanupTest(ctx)
 }
 
+func TestUtilityContext_GetAppHash(t *testing.T) {
+	ctx := NewTestingUtilityContext(t, 0)
+
+	appHashTest, err := ctx.GetAppHash()
+	require.NoError(t, err)
+
+	appHashSource, er := ctx.Context.AppHash()
+	require.NoError(t, er)
+	require.Equal(t, appHashTest, appHashSource, "unexpected appHash")
+
+	test_artifacts.CleanupTest(ctx)
+}
+
 func TestUtilityContext_UnstakeValidatorsActorsThatAreReady(t *testing.T) {
 	for _, actorType := range typesUtil.ActorTypes {
 		ctx := NewTestingUtilityContext(t, 1)

From 81837cfcef7a96f7d0cf8762a7806fba58dba33e Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 4 Oct 2022 19:16:00 -0700
Subject: [PATCH 068/227] Reapplied all changes from diff

---
 consensus/block.go                   | 45 ++++--------------------
 go.mod                               |  3 +-
 go.sum                               |  2 ++
 persistence/application.go           | 51 ++++++++++++++++++++++++++++
 persistence/block.go                 | 42 ++++++++++++++++++-----
 persistence/context.go               | 26 ++++++++++----
 persistence/db.go                    |  8 +++++
 persistence/debug.go                 |  2 +-
 persistence/genesis.go               |  4 +--
 persistence/kvstore/kvstore.go       | 35 ++++++++++++++++---
 persistence/module.go                | 31 ++++++++++++++---
 persistence/shared_sql.go            | 40 ++++++++++++++++++++--
 persistence/test/module_test.go      |  4 ++-
 persistence/types/base_actor.go      |  7 +++-
 persistence/types/protocol_actor.go  |  3 ++
 persistence/types/shared_sql.go      |  5 +++
 shared/codec/codec.go                |  4 +++
 shared/docs/flows/README.md          |  3 --
 shared/indexer/indexer.go            |  3 +-
 shared/modules/persistence_module.go | 47 +++++++++++++++++++++++++
 shared/test_artifacts/generator.go   |  5 +--
 utility/block.go                     | 27 ++++++++-------
 utility/context.go                   | 28 ++++++++-------
 utility/test/block_test.go           | 19 +++--------
 24 files changed, 328 insertions(+), 116 deletions(-)
 delete mode 100644 shared/docs/flows/README.md

diff --git a/consensus/block.go b/consensus/block.go
index 536c3cc74..14675bbd5 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -4,8 +4,6 @@ import (
 	"encoding/hex"
 	"unsafe"
 
-	"github.com/pokt-network/pocket/shared/codec"
-
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
 
@@ -89,7 +87,9 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 	// should not be called.
 	if m.utilityContext != nil {
 		m.nodeLog(typesCons.NilUtilityContextWarning)
-		m.utilityContext.ReleaseContext()
+		if err := m.utilityContext.Release(); err != nil {
+			return err
+		}
 		m.utilityContext = nil
 	}
 
@@ -105,47 +105,14 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
 
-	// Store the block in the KV store
-	codec := codec.GetCodec()
-	blockProtoBytes, err := codec.Marshal(block)
-	if err != nil {
-		return err
-	}
-
-	// IMPROVE(olshansky): temporary solution. `ApplyBlock` above applies the
-	// transactions to the postgres database, and this stores it in the KV store upon commitment.
-	// Instead of calling this directly, an alternative solution is to store the block metadata in
-	// the persistence context and have `CommitPersistenceContext` do this under the hood. However,
-	// additional `Block` metadata will need to be passed through and may change when we merkle the
-	// state hash.
-	if err := m.storeBlock(block, blockProtoBytes); err != nil {
-		return err
-	}
-
 	// Commit and release the context
-	if err := m.utilityContext.CommitPersistenceContext(); err != nil {
+	if err := m.utilityContext.Commit(block.BlockHeader.QuorumCertificate); err != nil {
 		return err
 	}
-
-	m.utilityContext.ReleaseContext()
+	m.utilityContext.Release()
 	m.utilityContext = nil
 
-	m.appHash = block.BlockHeader.Hash
+	m.lastAppHash = block.BlockHeader.Hash
 
 	return nil
 }
-
-func (m *ConsensusModule) storeBlock(block *typesCons.Block, blockProtoBytes []byte) error {
-	store := m.utilityContext.GetPersistenceContext()
-	// Store in KV Store
-	if err := store.StoreBlock(blockProtoBytes); err != nil {
-		return err
-	}
-
-	// Store in SQL Store
-	header := block.BlockHeader
-	if err := store.InsertBlock(uint64(header.Height), header.Hash, header.ProposerAddress, header.QuorumCertificate); err != nil {
-		return err
-	}
-	return nil
-}
diff --git a/go.mod b/go.mod
index 1aa121424..30f937624 100644
--- a/go.mod
+++ b/go.mod
@@ -20,6 +20,7 @@ require (
 )
 
 require (
+	github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884
 	github.com/benbjohnson/clock v1.3.0
 	github.com/dgraph-io/badger/v3 v3.2103.2
 	github.com/jackc/pgconn v1.11.0
@@ -38,7 +39,7 @@ require (
 	github.com/docker/go-connections v0.4.0 // indirect
 	github.com/docker/go-units v0.4.0 // indirect
 	github.com/dustin/go-humanize v1.0.0 // indirect
-	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/gogo/protobuf v1.3.2
 	github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b // indirect
 	github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
diff --git a/go.sum b/go.sum
index 8d255a0b5..f7e72a772 100644
--- a/go.sum
+++ b/go.sum
@@ -63,6 +63,8 @@ github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+Ce
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/boombuler/barcode v1.0.0/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8=
+github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884 h1:iRNKw2WmAbVgGMNYzDH5Y2yY3+jyxwEK9Hc5pwIjZAE=
+github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884/go.mod h1:/sdYDakowo/XaxS2Fl7CBqtuf/O2uTqF2zmAUFAtAiw=
 github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4=
 github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
diff --git a/persistence/application.go b/persistence/application.go
index 78750a7b6..755288155 100644
--- a/persistence/application.go
+++ b/persistence/application.go
@@ -4,15 +4,66 @@ import (
 	"encoding/hex"
 
 	"github.com/pokt-network/pocket/persistence/types"
+	"google.golang.org/protobuf/proto"
+
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
+func (p PostgresContext) UpdateApplicationsTree(apps []modules.Actor) error {
+	for _, app := range apps {
+		bzAddr, err := hex.DecodeString(app.GetAddress())
+		if err != nil {
+			return err
+		}
+
+		appBz, err := proto.Marshal(app.(*types.Actor))
+		if err != nil {
+			return err
+		}
+
+		// OPTIMIZE: This is the only line unique to `Application`
+		if _, err := p.MerkleTrees[appMerkleTree].Update(bzAddr, appBz); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (p PostgresContext) getApplicationsUpdatedAtHeight(height int64) (apps []*types.Actor, err error) {
+	// OPTIMIZE: This is the only line unique to `Application`
+	actors, err := p.GetActorsUpdated(types.ApplicationActor, height)
+	if err != nil {
+		return nil, err
+	}
+
+	apps = make([]*types.Actor, len(actors))
+	for _, actor := range actors {
+		app := &types.Actor{
+			ActorType:       types.ActorType_App,
+			Address:         actor.Address,
+			PublicKey:       actor.PublicKey,
+			Chains:          actor.Chains,
+			GenericParam:    actor.ActorSpecificParam,
+			StakedAmount:    actor.StakedTokens,
+			PausedHeight:    actor.PausedHeight,
+			UnstakingHeight: actor.UnstakingHeight,
+			Output:          actor.OutputAddress,
+		}
+		apps = append(apps, app)
+	}
+	return
+}
+
 func (p PostgresContext) GetAppExists(address []byte, height int64) (exists bool, err error) {
 	return p.GetExists(types.ApplicationActor, address, height)
 }
 
 func (p PostgresContext) GetApp(address []byte, height int64) (operator, publicKey, stakedTokens, maxRelays, outputAddress string, pauseHeight, unstakingHeight int64, chains []string, err error) {
 	actor, err := p.GetActor(types.ApplicationActor, address, height)
+	if err != nil {
+		return
+	}
 	operator = actor.Address
 	publicKey = actor.PublicKey
 	stakedTokens = actor.StakedTokens
diff --git a/persistence/block.go b/persistence/block.go
index aaee96364..5efa1b71e 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -5,6 +5,7 @@ import (
 	"encoding/hex"
 	"log"
 
+	"github.com/gogo/protobuf/proto"
 	"github.com/pokt-network/pocket/persistence/types"
 )
 
@@ -49,23 +50,46 @@ func (p PostgresContext) StoreTransaction(transactionProtoBytes []byte) error {
 	return nil
 }
 
-func (p PostgresContext) StoreBlock(blockProtoBytes []byte) error {
-	// INVESTIGATE: Note that we are writing this directly to the blockStore. Depending on how
-	// the use of the PostgresContext evolves, we may need to write this to `ContextStore` and copy
-	// over to `BlockStore` when the block is committed.
-	return p.blockstore.Put(heightToBytes(p.Height), blockProtoBytes)
-}
-
-func (p PostgresContext) InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error {
+func (p PostgresContext) insertBlock(block *types.Block) error {
 	ctx, tx, err := p.GetCtxAndTx()
 	if err != nil {
 		return err
 	}
 
-	_, err = tx.Exec(ctx, types.InsertBlockQuery(height, hash, proposerAddr, quorumCert))
+	_, err = tx.Exec(ctx, types.InsertBlockQuery(block.Height, block.Hash, block.ProposerAddress, block.QuorumCertificate))
 	return err
 }
 
+func (p PostgresContext) storeBlock(block *types.Block) error {
+	blockBz, err := proto.Marshal(block)
+	if err != nil {
+		return err
+	}
+
+	return p.blockstore.Put(heightToBytes(p.Height), blockBz)
+}
+
+func (p PostgresContext) getBlock(proposerAddr []byte, quorumCert []byte) (*types.Block, error) {
+	prevHash, err := p.GetBlockHash(p.Height - 1)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: get this from the transactions that were store via `StoreTransaction`
+	txs := make([][]byte, 0)
+
+	block := &types.Block{
+		Height:            uint64(p.Height),
+		Hash:              string(p.stateHash),
+		PrevHash:          string(prevHash),
+		ProposerAddress:   proposerAddr,
+		QuorumCertificate: quorumCert,
+		Transactions:      txs,
+	}
+
+	return block, nil
+}
+
 // CLEANUP: Should this be moved to a shared directory?
 func heightToBytes(height int64) []byte {
 	heightBytes := make([]byte, 8)
diff --git a/persistence/context.go b/persistence/context.go
index fd44e3af1..8224a229a 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -15,25 +15,39 @@ func (p PostgresContext) RollbackToSavePoint(bytes []byte) error {
 	return p.GetTx().Rollback(context.TODO())
 }
 
-func (p PostgresContext) AppHash() ([]byte, error) {
-	log.Println("TODO: AppHash not implemented")
-	return []byte("A real app hash, I am not"), nil
+func (p PostgresContext) UpdateAppHash() ([]byte, error) {
+	if err := p.updateStateHash(); err != nil {
+		return nil, err
+	}
+	return p.stateHash, nil
 }
 
 func (p PostgresContext) Reset() error {
 	panic("TODO: PostgresContext Reset not implemented")
 }
 
-func (p PostgresContext) Commit() error {
+func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
+	block, err := p.getBlock(proposerAddr, quorumCert)
+	if err != nil {
+		return err
+	}
+
+	if err := p.insertBlock(block); err != nil {
+		return err
+	}
+
+	if err := p.storeBlock(block); err != nil {
+		return err
+	}
+
 	ctx := context.TODO()
-	if err := p.GetTx().Commit(context.TODO()); err != nil {
+	if err := p.GetTx().Commit(ctx); err != nil {
 		return err
 	}
 	if err := p.conn.Close(ctx); err != nil {
 		log.Println("[TODO][ERROR] Implement connection pooling. Error when closing DB connecting...", err)
-
 	}
 	return nil
 }
diff --git a/persistence/db.go b/persistence/db.go
index 3a495596c..b8a974939 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -7,6 +7,7 @@ import (
 
 	"github.com/pokt-network/pocket/persistence/types"
 
+	"github.com/celestiaorg/smt"
 	"github.com/jackc/pgconn"
 	"github.com/jackc/pgx/v4"
 	"github.com/pokt-network/pocket/persistence/kvstore"
@@ -40,6 +41,13 @@ type PostgresContext struct {
 	conn       *pgx.Conn
 	tx         pgx.Tx
 	blockstore kvstore.KVStore
+
+	stateHash []byte
+	// IMPROVE: Depending on how the use of `PostgresContext` evolves, we may be able to get
+	// access to these directly via the postgres module.
+	PostgresDB  *pgx.Conn
+	BlockStore  kvstore.KVStore                      // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context)
+	MerkleTrees map[MerkleTree]*smt.SparseMerkleTree // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context)
 }
 
 func (pg *PostgresContext) GetCtxAndTx() (context.Context, pgx.Tx, error) {
diff --git a/persistence/debug.go b/persistence/debug.go
index 3fdc583a4..e0e3b6e5e 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -44,7 +44,7 @@ func (m *PersistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 
 func (m *PersistenceModule) clearState(_ *debug.DebugMessage) {
 	context, err := m.NewRWContext(-1)
-	defer context.Commit()
+	defer context.Commit(nil, nil)
 	if err != nil {
 		log.Printf("Error creating new context: %s \n", err)
 		return
diff --git a/persistence/genesis.go b/persistence/genesis.go
index 1c7e82f14..a6eefaa90 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -149,7 +149,7 @@ func (m *PersistenceModule) populateGenesisState(state *types.PersistenceGenesis
 		log.Fatalf("an error occurred initializing flags: %s", err.Error())
 	}
 
-	if err = rwContext.Commit(); err != nil {
+	if err = rwContext.Commit(nil, nil); err != nil {
 		log.Fatalf("an error occurred during commit() on genesis state %s ", err.Error())
 	}
 }
@@ -316,7 +316,7 @@ func (p PostgresContext) GetAllFishermen(height int64) (f []modules.Actor, err e
 	return
 }
 
-// TODO (Team) deprecate with interface #163 <Bumped to #149> as #163 is getting large
+// CONSOLIDATE: Consolidate `types.BaseActor` with `types.Actor`
 func (p PostgresContext) BaseActorToActor(ba types.BaseActor, actorType types.ActorType) *types.Actor {
 	actor := new(types.Actor)
 	actor.ActorType = actorType
diff --git a/persistence/kvstore/kvstore.go b/persistence/kvstore/kvstore.go
index 24613afc9..8636e4519 100644
--- a/persistence/kvstore/kvstore.go
+++ b/persistence/kvstore/kvstore.go
@@ -1,33 +1,47 @@
 package kvstore
 
 import (
+	"errors"
 	"log"
 
+	"github.com/celestiaorg/smt"
 	badger "github.com/dgraph-io/badger/v3"
 )
 
-// CLEANUP: move this structure to a shared module
 type KVStore interface {
 	// Lifecycle methods
 	Stop() error
 
 	// Accessors
 	// TODO: Add a proper iterator interface
-	Put(key []byte, value []byte) error
-	Get(key []byte) ([]byte, error)
 	// TODO: Add pagination for `GetAll`
 	GetAll(prefixKey []byte, descending bool) ([][]byte, error)
+
 	Exists(key []byte) (bool, error)
 	ClearAll() error
+
+	// Same interface as in `smt.MapStore``
+	Put(key, value []byte) error
+	Get(key []byte) ([]byte, error)
+	Delete(key []byte) error
 }
 
 var _ KVStore = &badgerKVStore{}
+var _ smt.MapStore = &badgerKVStore{}
+
+var (
+	ErrKVStoreExists    = errors.New("kvstore already exists")
+	ErrKVStoreNotExists = errors.New("kvstore does not exist")
+)
 
 type badgerKVStore struct {
 	db *badger.DB
 }
 
-func NewKVStore(path string) (KVStore, error) {
+// REFACTOR: Loads or creates a badgerDb at `path`. This may potentially need to be refactored
+// into `NewKVStore` and `LoadKVStore` depending on how state sync evolves by leveraging `os.Stat`
+// on the file path.
+func OpenKVStore(path string) (KVStore, error) {
 	db, err := badger.Open(badger.DefaultOptions(path))
 	if err != nil {
 		return nil, err
@@ -43,7 +57,7 @@ func NewMemKVStore() KVStore {
 	return badgerKVStore{db: db}
 }
 
-func (store badgerKVStore) Put(key []byte, value []byte) error {
+func (store badgerKVStore) Put(key, value []byte) error {
 	tx := store.db.NewTransaction(true)
 	defer tx.Discard()
 
@@ -55,6 +69,12 @@ func (store badgerKVStore) Put(key []byte, value []byte) error {
 	return tx.Commit()
 }
 
+// CONSOLIDATE: We might be able to remove the `KVStore` interface altogether if we end up using `smt.MapStore`
+// A wrapper around `Put` to conform to the `smt.MapStore` interface
+func (store *badgerKVStore) Set(key, value []byte) error {
+	return store.Put(key, value)
+}
+
 func (store badgerKVStore) Get(key []byte) ([]byte, error) {
 	tx := store.db.NewTransaction(false)
 	defer tx.Discard()
@@ -76,6 +96,11 @@ func (store badgerKVStore) Get(key []byte) ([]byte, error) {
 	return value, nil
 }
 
+func (store badgerKVStore) Delete(key []byte) error {
+	log.Fatalf("badgerKVStore.Delete not implemented yet")
+	return nil
+}
+
 func (store badgerKVStore) GetAll(prefix []byte, descending bool) (values [][]byte, err error) {
 	// INVESTIGATE: research `badger.views` for further improvements and optimizations
 	txn := store.db.NewTransaction(false)
diff --git a/persistence/module.go b/persistence/module.go
index 33bd827bd..6761bb22b 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -7,10 +7,10 @@ import (
 	"io/ioutil"
 	"log"
 
-	"github.com/pokt-network/pocket/persistence/types"
-
+	"github.com/celestiaorg/smt"
 	"github.com/jackc/pgx/v4"
 	"github.com/pokt-network/pocket/persistence/kvstore"
+	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 	"github.com/pokt-network/pocket/shared/test_artifacts"
 )
@@ -26,10 +26,19 @@ type PersistenceModule struct {
 	postgresURL string
 	nodeSchema  string
 	genesisPath string
-	blockStore  kvstore.KVStore // INVESTIGATE: We may need to create a custom `BlockStore` package in the future
 
 	// TECHDEBT: Need to implement context pooling (for writes), timeouts (for read & writes), etc...
 	writeContext *PostgresContext // only one write context is allowed at a time
+
+	// The connection to the PostgreSQL database
+	postgresConn *pgx.Conn
+	// A reference to the block key-value store
+	// INVESTIGATE: We may need to create a custom `BlockStore` package in the future.
+	blockStore kvstore.KVStore
+	// A mapping of context IDs to persistence contexts
+	// contexts map[contextId]modules.PersistenceRWContext
+	// Merkle trees
+	trees map[MerkleTree]*smt.SparseMerkleTree
 }
 
 const (
@@ -42,8 +51,10 @@ func Create(configPath, genesisPath string) (modules.PersistenceModule, error) {
 	if err != nil {
 		return nil, err
 	}
+
 	cfg := c.(*types.PersistenceConfig)
 	g, err := m.InitGenesis(genesisPath)
+
 	if err != nil {
 		return nil, err
 	}
@@ -69,8 +80,20 @@ func Create(configPath, genesisPath string) (modules.PersistenceModule, error) {
 		genesisPath:  genesisPath,
 		blockStore:   blockStore,
 		writeContext: nil,
+		// contexts:     make(map[contextId]modules.PersistenceContext),
+		trees: make(map[MerkleTree]*smt.SparseMerkleTree),
 	}
 
+	// DISCUSS_IN_THIS_COMMIT: We've been using the module function pattern, but this making `initializeTrees`
+	// be able to create and/or load trees outside the scope of the persistence module makes it easier to test.
+	trees, err := newMerkleTrees()
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO_IN_THIS_COMMIT: load trees from state
+	persistenceMod.trees = trees
+
 	// Determine if we should hydrate the genesis db or use the current state of the DB attached
 	if shouldHydrateGenesis, err := persistenceMod.shouldHydrateGenesisDb(); err != nil {
 		return nil, err
@@ -214,7 +237,7 @@ func initializeBlockStore(blockStorePath string) (kvstore.KVStore, error) {
 	if blockStorePath == "" {
 		return kvstore.NewMemKVStore(), nil
 	}
-	return kvstore.NewKVStore(blockStorePath)
+	return kvstore.OpenKVStore(blockStorePath)
 }
 
 // TODO(drewsky): Simplify and externalize the logic for whether genesis should be populated and
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
index 9f2c19a00..8eac77562 100644
--- a/persistence/shared_sql.go
+++ b/persistence/shared_sql.go
@@ -44,6 +44,36 @@ func (p *PostgresContext) GetExists(actorSchema types.ProtocolActorSchema, addre
 	return
 }
 
+func (p *PostgresContext) GetActorsUpdated(actorSchema types.ProtocolActorSchema, height int64) (actors []types.BaseActor, err error) {
+	ctx, tx, err := p.GetCtxAndTx()
+	if err != nil {
+		return
+	}
+
+	rows, err := tx.Query(ctx, actorSchema.GetUpdatedAtHeightQuery(height))
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	// OPTIMIZE: Consolidate logic with `GetActor` to reduce code footprint
+	var addr string
+	for rows.Next() {
+		if err = rows.Scan(&addr); err != nil {
+			return
+		}
+
+		actor, err := p.GetActor(actorSchema, []byte(addr), height)
+		if err != nil {
+			return nil, err
+		}
+
+		actors = append(actors, actor)
+	}
+
+	return
+}
+
 func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, address []byte, height int64) (actor types.BaseActor, err error) {
 	ctx, tx, err := p.GetCtxAndTx()
 	if err != nil {
@@ -57,10 +87,16 @@ func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, addres
 	return p.GetChainsForActor(ctx, tx, actorSchema, actor, height)
 }
 
+// IMPORTANT: Need to consolidate `persistence/types.BaseActor` with `persistence/genesisTypes.Actor`
 func (p *PostgresContext) GetActorFromRow(row pgx.Row) (actor types.BaseActor, height int64, err error) {
 	err = row.Scan(
-		&actor.Address, &actor.PublicKey, &actor.StakedTokens, &actor.ActorSpecificParam,
-		&actor.OutputAddress, &actor.PausedHeight, &actor.UnstakingHeight,
+		&actor.Address,
+		&actor.PublicKey,
+		&actor.StakedTokens,
+		&actor.ActorSpecificParam,
+		&actor.OutputAddress,
+		&actor.PausedHeight,
+		&actor.UnstakingHeight,
 		&height)
 	return
 }
diff --git a/persistence/test/module_test.go b/persistence/test/module_test.go
index 3bee636c5..ccb7bd37f 100644
--- a/persistence/test/module_test.go
+++ b/persistence/test/module_test.go
@@ -18,12 +18,14 @@ func TestPersistenceContextParallelReadWrite(t *testing.T) {
 	poolAddress := []byte("address")
 	originalAmount := "15"
 	modifiedAmount := "10"
+	proposer := []byte("proposer")
+	quorumCert := []byte("quorumCert")
 
 	// setup a write context, insert a pool and commit it
 	context, err := testPersistenceMod.NewRWContext(0)
 	require.NoError(t, err)
 	require.NoError(t, context.InsertPool(poolName, poolAddress, originalAmount))
-	require.NoError(t, context.Commit())
+	require.NoError(t, context.Commit(proposer, quorumCert))
 
 	// verify the insert in the previously committed context worked
 	contextA, err := testPersistenceMod.NewRWContext(0)
diff --git a/persistence/types/base_actor.go b/persistence/types/base_actor.go
index 9514b15eb..1c73da9a7 100644
--- a/persistence/types/base_actor.go
+++ b/persistence/types/base_actor.go
@@ -1,5 +1,6 @@
 package types
 
+// IMPROVE: Move schema related functions to a separate sub-package
 import "github.com/pokt-network/pocket/shared/modules"
 
 // TECHDEBT: Consider moving this to a protobuf. This struct was created to make testing simple of protocol actors that
@@ -60,6 +61,10 @@ func (actor *BaseProtocolActorSchema) GetChainsTableSchema() string {
 	return ProtocolActorChainsTableSchema(actor.chainsHeightConstraintName)
 }
 
+func (actor *BaseProtocolActorSchema) GetUpdatedAtHeightQuery(height int64) string {
+	return SelectAtHeight(AddressCol, height, actor.tableName)
+}
+
 func (actor *BaseProtocolActorSchema) GetQuery(address string, height int64) string {
 	return Select(AllColsSelector, address, height, actor.tableName)
 }
@@ -150,5 +155,5 @@ func (x *Actor) GetActorTyp() modules.ActorType {
 	if x != nil {
 		return x.GetActorType()
 	}
-	return ActorType_App
+	return ActorType_App // HACK: Is this a hack?
 }
diff --git a/persistence/types/protocol_actor.go b/persistence/types/protocol_actor.go
index 1052dc3d6..709457b6c 100644
--- a/persistence/types/protocol_actor.go
+++ b/persistence/types/protocol_actor.go
@@ -15,6 +15,9 @@ type ProtocolActorSchema interface {
 	GetActorSpecificColName() string
 
 	/*** Read/Get Queries ***/
+
+	// Returns a query to retrieve the addresses of all the Actors updated at that specific height
+	GetUpdatedAtHeightQuery(height int64) string
 	// Returns a query to retrieve all of a single Actor's attributes.
 	GetQuery(address string, height int64) string
 	// Returns all actors at that height
diff --git a/persistence/types/shared_sql.go b/persistence/types/shared_sql.go
index e36907124..6e1f929c7 100644
--- a/persistence/types/shared_sql.go
+++ b/persistence/types/shared_sql.go
@@ -69,6 +69,11 @@ func ProtocolActorChainsTableSchema(constraintName string) string {
 		)`, AddressCol, ChainIDCol, HeightCol, DefaultBigInt, constraintName, AddressCol, ChainIDCol, HeightCol)
 }
 
+func SelectAtHeight(selector string, height int64, tableName string) string {
+	return fmt.Sprintf(`SELECT %s FROM %s WHERE height=%d`,
+		selector, tableName, height)
+}
+
 func Select(selector, address string, height int64, tableName string) string {
 	return fmt.Sprintf(`SELECT %s FROM %s WHERE address='%s' AND height<=%d ORDER BY height DESC LIMIT 1`,
 		selector, tableName, address, height)
diff --git a/shared/codec/codec.go b/shared/codec/codec.go
index ac7765673..a41fe2e0b 100644
--- a/shared/codec/codec.go
+++ b/shared/codec/codec.go
@@ -5,6 +5,8 @@ import (
 	"google.golang.org/protobuf/types/known/anypb"
 )
 
+// TODO: Use generics in place of `proto.Message` in the interface below
+//       so every caller does not need to do in place casting.
 type Codec interface { // TODO (Team) move to shared. Possibly rename
 	Marshal(proto.Message) ([]byte, error)
 	Unmarshal([]byte, proto.Message) error
@@ -14,6 +16,8 @@ type Codec interface { // TODO (Team) move to shared. Possibly rename
 
 var _ Codec = &ProtoCodec{}
 
+// TODO: Need to define a type like `type ProtoAny anypb.Any` so that we are
+//       mixing protobufs and a centralized codec structure throughout the codebase.
 type ProtoCodec struct{}
 
 func (p *ProtoCodec) Marshal(message proto.Message) ([]byte, error) {
diff --git a/shared/docs/flows/README.md b/shared/docs/flows/README.md
deleted file mode 100644
index cb4e5d663..000000000
--- a/shared/docs/flows/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# Flows
-
-The purpose of [shared/flows](./) is to document cross-module communication for end-to-end behaviour that has cross-module dependencies and and depends on the interfaces exposed by the interfaces exposed in [shared/modules](../modules).
diff --git a/shared/indexer/indexer.go b/shared/indexer/indexer.go
index 559ca1f6e..59355787f 100644
--- a/shared/indexer/indexer.go
+++ b/shared/indexer/indexer.go
@@ -5,6 +5,7 @@ package indexer
 import (
 	"encoding/hex"
 	"fmt"
+
 	"github.com/pokt-network/pocket/shared/codec"
 
 	"github.com/jordanorelli/lexnum"
@@ -111,7 +112,7 @@ type txIndexer struct {
 }
 
 func NewTxIndexer(databasePath string) (TxIndexer, error) {
-	db, err := kvstore.NewKVStore(databasePath)
+	db, err := kvstore.OpenKVStore(databasePath)
 	return &txIndexer{
 		db: db,
 	}, err
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index 9379f6362..dd4f7fd19 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -109,6 +109,29 @@ type PersistenceWriteContext interface {
 	// Flag Operations
 	InitFlags() error
 	SetFlag(paramName string, value interface{}, enabled bool) error
+
+	// Tree Operations
+
+	// # Option 1:
+
+	UpdateApplicationsTree([]Actor) error
+	// UpdateValidatorsTree([]Actor) error
+	// UpdateServiceNodesTree([]Actor) error
+	// UpdateFishermanTree([]Actor) error
+	// Update<FutureActors>Tree([]Actor) error
+	// Update<Other>Tree([]Other) error
+
+	// # Option 2:
+	// UpdateActorTree(types.ProtocolActorSchema, []Actor) error
+	// Update<Other>Tree([]Other) error
+
+	// # Option 3:
+	// UpdateApplicationsTree([]Application) error
+	// UpdateValidatorsTree([]Validator) error
+	// UpdateServiceNodesTree([]ServiceNode) error
+	// UpdateFishermanTree([]Fisherman) error
+	// Update<FutureActors>Tree([]FutureActor) error
+	// Update<Other>Tree([]Other) error
 }
 
 type PersistenceReadContext interface {
@@ -185,4 +208,28 @@ type PersistenceReadContext interface {
 	GetIntFlag(paramName string, height int64) (int, bool, error)
 	GetStringFlag(paramName string, height int64) (string, bool, error)
 	GetBytesFlag(paramName string, height int64) ([]byte, bool, error)
+
+	// Tree Operations
+
+	// # Option 1:
+
+	// GetApplicationsUpdatedAtHeight(height int64) ([]Actor, error)
+	// GetValidatorsUpdatedAtHeight(height int64) ([]Actor, error)
+	// GetServiceNodesUpdatedAtHeight(height int64) ([]Actor, error)
+	// GetFishermanUpdatedAtHeight(height int64) ([]Actor, error)
+	// Get<FutureActor>UpdatedAtHeight(height int64) ([]Actor, error)
+	// Get<Other>UpdatedAtHeight(height int64) ([]Actor, error)
+	// Update<Other>Tree(height int64) ([]Actor, error)
+
+	// # Option 2:
+	// Get<FutureActor>UpdatedAtHeight(types.ProtocolActorSchema, height int64) ([]Actor, error)
+	// Get<Other>UpdatedAtHeight(height int64) ([]Other, error)
+
+	// # Option 3:
+	// GetApplicationsUpdatedAtHeight(height int64) ([]Application, error)
+	// GetValidatorsUpdatedAtHeight(height int64) ([]Validator, error)
+	// GetServiceNodesUpdatedAtHeight(height int64) ([]ServiceNode, error)
+	// GetFishermanUpdatedAtHeight(height int64) ([]Fisherman, error)
+	// Get<FutureActor>UpdatedAtHeight(height int64) ([]FutureActor, error)
+	// Get<Other>UpdatedAtHeight(height int64) ([]Other, error)
 }
diff --git a/shared/test_artifacts/generator.go b/shared/test_artifacts/generator.go
index 6d6923d32..a48fbc7a3 100644
--- a/shared/test_artifacts/generator.go
+++ b/shared/test_artifacts/generator.go
@@ -2,11 +2,12 @@ package test_artifacts
 
 import (
 	"fmt"
+	"math/big"
+	"strconv"
+
 	typesPersistence "github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 	"github.com/pokt-network/pocket/utility/types"
-	"math/big"
-	"strconv"
 
 	"github.com/pokt-network/pocket/shared/crypto"
 	"google.golang.org/protobuf/types/known/timestamppb"
diff --git a/utility/block.go b/utility/block.go
index 1bca5f6c1..7394b04b0 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -33,6 +33,8 @@ var (
 
 func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) ([]byte, error) {
 	u.LatestHeight = latestHeight
+	u.CurrentProposer = proposerAddress
+
 	// begin block lifecycle phase
 	if err := u.BeginBlock(lastBlockByzantineValidators); err != nil {
 		return nil, err
@@ -50,22 +52,30 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 		if err := u.ApplyTransaction(tx); err != nil {
 			return nil, err
 		}
-		if err := u.GetPersistenceContext().StoreTransaction(transactionProtoBytes); err != nil {
+		if err := u.Context.PersistenceRWContext.StoreTransaction(transactionProtoBytes); err != nil {
 			return nil, err
 		}
 
-		// TODO: if found, remove transaction from mempool
 		// DISCUSS: What if the context is rolled back or cancelled. Do we add it back to the mempool?
+		// TODO: if found, remove transaction from mempool
 		// if err := u.Mempool.DeleteTransaction(transaction); err != nil {
 		// 	return nil, err
 		// }
 	}
+
 	// end block lifecycle phase
 	if err := u.EndBlock(proposerAddress); err != nil {
 		return nil, err
 	}
-	// return the app hash (consensus module will get the validator set directly
-	return u.GetAppHash()
+
+	// TODO: What if everything above succeeded but updating the app hash failed?
+	appHash, err := u.Context.UpdateAppHash()
+	if err != nil {
+		return nil, typesUtil.ErrAppHash(err)
+	}
+
+	// return the app hash; consensus module will get the validator set directly
+	return appHash, nil
 }
 
 func (u *UtilityContext) BeginBlock(previousBlockByzantineValidators [][]byte) typesUtil.Error {
@@ -91,15 +101,6 @@ func (u *UtilityContext) EndBlock(proposer []byte) typesUtil.Error {
 	return nil
 }
 
-func (u *UtilityContext) GetAppHash() ([]byte, typesUtil.Error) {
-	// Get the root hash of the merkle state tree for state consensus integrity
-	appHash, er := u.Context.AppHash()
-	if er != nil {
-		return nil, typesUtil.ErrAppHash(er)
-	}
-	return appHash, nil
-}
-
 // HandleByzantineValidators handles the validators who either didn't sign at all or disagreed with the 2/3+ majority
 func (u *UtilityContext) HandleByzantineValidators(lastBlockByzantineValidators [][]byte) typesUtil.Error {
 	latestBlockHeight, err := u.GetLatestBlockHeight()
diff --git a/utility/context.go b/utility/context.go
index c3f97f3a8..a8797a52c 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -2,19 +2,24 @@ package utility
 
 import (
 	"encoding/hex"
+
 	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/modules"
 	typesUtil "github.com/pokt-network/pocket/utility/types"
 )
 
 type UtilityContext struct {
-	LatestHeight int64
-	Mempool      typesUtil.Mempool
-	Context      *Context // IMPROVE: Consider renmaming to PersistenceContext
+	LatestHeight    int64 // IMPROVE: Rename to `currentHeight?`
+	CurrentProposer []byte
+
+	Mempool typesUtil.Mempool
+	Context *Context // IMPROVE: Rename to `persistenceContext` or `storeContext` or `reversibleContext`?
 }
 
-type Context struct {
+type Context struct { // IMPROVE: Rename to `persistenceContext` or `storeContext`?
+	// TODO: Since `Context` embeds `PersistenceRWContext`, we don't need to do `u.Context.PersistenceRWContext`, but can call `u.Context` directly
 	modules.PersistenceRWContext
+	// TODO/DISCUSS: `SavePoints`` have not been implemented yet
 	SavePointsM map[string]struct{}
 	SavePoints  [][]byte
 }
@@ -39,17 +44,16 @@ func (u *UtilityContext) Store() *Context {
 	return u.Context
 }
 
-func (u *UtilityContext) GetPersistenceContext() modules.PersistenceRWContext {
-	return u.Context.PersistenceRWContext
-}
-
-func (u *UtilityContext) CommitPersistenceContext() error {
-	return u.Context.PersistenceRWContext.Commit()
+func (u *UtilityContext) CommitContext(quorumCert []byte) error {
+	err := u.Context.PersistenceRWContext.Commit(u.CurrentProposer, quorumCert)
+	u.Context = nil // DISCUSS: Should we release the context if there was an error here?
+	return err
 }
 
-func (u *UtilityContext) ReleaseContext() {
-	u.Context.Release()
+func (u *UtilityContext) ReleaseContext() error {
+	err := u.Context.Release()
 	u.Context = nil
+	return err
 }
 
 func (u *UtilityContext) GetLatestBlockHeight() (int64, typesUtil.Error) {
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index b59f31bef..13c6b2175 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -2,12 +2,16 @@ package test
 
 import (
 	"encoding/hex"
+	"fmt"
 	"github.com/pokt-network/pocket/shared/modules"
-	"github.com/pokt-network/pocket/shared/test_artifacts"
+	"github.com/pokt-network/pocket/shared/test_artifacts"s/249/consensus_techdebt
 	"math"
 	"math/big"
 	"testing"
 
+	"github.com/pokt-network/pocket/shared/modules"
+	"github.com/pokt-network/pocket/shared/test_artifacts"
+
 	typesUtil "github.com/pokt-network/pocket/utility/types"
 	"github.com/stretchr/testify/require"
 )
@@ -171,19 +175,6 @@ func TestUtilityContext_EndBlock(t *testing.T) {
 	test_artifacts.CleanupTest(ctx)
 }
 
-func TestUtilityContext_GetAppHash(t *testing.T) {
-	ctx := NewTestingUtilityContext(t, 0)
-
-	appHashTest, err := ctx.GetAppHash()
-	require.NoError(t, err)
-
-	appHashSource, er := ctx.Context.AppHash()
-	require.NoError(t, er)
-	require.Equal(t, appHashTest, appHashSource, "unexpected appHash")
-
-	test_artifacts.CleanupTest(ctx)
-}
-
 func TestUtilityContext_UnstakeValidatorsActorsThatAreReady(t *testing.T) {
 	for _, actorType := range typesUtil.ActorTypes {
 		ctx := NewTestingUtilityContext(t, 1)

From 185919cc527aef98e9cfa61278971154337af838 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 4 Oct 2022 19:31:40 -0700
Subject: [PATCH 069/227] another merge

---
 consensus/block.go                        |  37 +----
 consensus/hotstuff_handler.go             |  55 ++++++
 consensus/types/block.go                  |  14 ++
 go.mod                                    |   2 +-
 go.sum                                    |   2 +
 persistence/StateHash.md                  | 194 ++++++++++++++++++++++
 persistence/application.go                |  51 ++++++
 persistence/block.go                      |  42 ++++-
 persistence/context.go                    |  26 ++-
 persistence/db.go                         |   8 +
 persistence/debug.go                      |   2 +-
 persistence/genesis.go                    |   4 +-
 persistence/kvstore/kvstore.go            |  35 +++-
 persistence/module.go                     |  31 +++-
 persistence/proto/block_persistence.proto |  13 ++
 persistence/shared_sql.go                 |  40 ++++-
 persistence/state.go                      | 119 +++++++++++++
 persistence/state_test.go                 |  15 ++
 persistence/test/module_test.go           |   4 +-
 persistence/types/base_actor.go           |   7 +-
 persistence/types/protocol_actor.go       |   3 +
 persistence/types/shared_sql.go           |   5 +
 shared/docs/flows/README.md               |   3 -
 shared/indexer/indexer.go                 |   3 +-
 shared/modules/persistence_module.go      |  47 ++++++
 shared/test_artifacts/generator.go        |   3 +-
 shared/types/genesis/validator.go         |  49 ++++++
 utility/block.go                          |  27 +--
 utility/context.go                        |  28 ++--
 utility/test/block_test.go                |  12 --
 30 files changed, 771 insertions(+), 110 deletions(-)
 create mode 100644 consensus/hotstuff_handler.go
 create mode 100644 consensus/types/block.go
 create mode 100644 persistence/StateHash.md
 create mode 100644 persistence/proto/block_persistence.proto
 create mode 100644 persistence/state.go
 create mode 100644 persistence/state_test.go
 delete mode 100644 shared/docs/flows/README.md
 create mode 100644 shared/types/genesis/validator.go

diff --git a/consensus/block.go b/consensus/block.go
index bdf90504c..db5b0a52a 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -4,8 +4,6 @@ import (
 	"encoding/hex"
 	"unsafe"
 
-	"github.com/pokt-network/pocket/shared/codec"
-
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
 
@@ -107,48 +105,17 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
 
-	// Store the block in the KV store
-	codec := codec.GetCodec()
-	blockProtoBytes, err := codec.Marshal(block)
-	if err != nil {
-		return err
-	}
-
-	// IMPROVE(olshansky): temporary solution. `ApplyBlock` above applies the
-	// transactions to the postgres database, and this stores it in the KV store upon commitment.
-	// Instead of calling this directly, an alternative solution is to store the block metadata in
-	// the persistence context and have `CommitPersistenceContext` do this under the hood. However,
-	// additional `Block` metadata will need to be passed through and may change when we merkle the
-	// state hash.
-	if err := m.storeBlock(block, blockProtoBytes); err != nil {
-		return err
-	}
-
 	// Commit and release the context
 	if err := m.utilityContext.Commit(block.BlockHeader.QuorumCertificate); err != nil {
 		return err
 	}
+
 	if err := m.utilityContext.Release(); err != nil {
 		return err
 	}
 	m.utilityContext = nil
 
-	m.appHash = block.BlockHeader.Hash
+	m.lastAppHash = block.BlockHeader.Hash
 
 	return nil
 }
-
-func (m *ConsensusModule) storeBlock(block *typesCons.Block, blockProtoBytes []byte) error {
-	store := m.utilityContext.GetPersistenceContext()
-	// Store in KV Store
-	if err := store.StoreBlock(blockProtoBytes); err != nil {
-		return err
-	}
-
-	// Store in SQL Store
-	header := block.BlockHeader
-	if err := store.InsertBlock(uint64(header.Height), header.Hash, header.ProposerAddress, header.QuorumCertificate); err != nil {
-		return err
-	}
-	return nil
-}
diff --git a/consensus/hotstuff_handler.go b/consensus/hotstuff_handler.go
new file mode 100644
index 000000000..274a1b45b
--- /dev/null
+++ b/consensus/hotstuff_handler.go
@@ -0,0 +1,55 @@
+package consensus
+
+import (
+	typesCons "github.com/pokt-network/pocket/consensus/types"
+)
+
+// DISCUSS: Should these functions return an error?
+type HotstuffMessageHandler interface {
+	HandleNewRoundMessage(*ConsensusModule, *typesCons.HotstuffMessage)
+	HandlePrepareMessage(*ConsensusModule, *typesCons.HotstuffMessage)
+	HandlePrecommitMessage(*ConsensusModule, *typesCons.HotstuffMessage)
+	HandleCommitMessage(*ConsensusModule, *typesCons.HotstuffMessage)
+	HandleDecideMessage(*ConsensusModule, *typesCons.HotstuffMessage)
+}
+
+func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage) error {
+	m.nodeLog(typesCons.DebugHandlingHotstuffMessage(msg))
+
+	step := msg.GetStep()
+
+	// Pacemaker - Liveness & safety checks
+	if err := m.paceMaker.ValidateMessage(msg); err != nil {
+		if m.shouldLogHotstuffDiscardMessage(step) {
+			m.nodeLog(typesCons.WarnDiscardHotstuffMessage(msg, err.Error()))
+		}
+		return err
+	}
+
+	if m.shouldElectNextLeader() {
+		if err := m.electNextLeader(msg); err != nil {
+			return err
+		}
+	}
+
+	// Hotstuff - Handle message
+	if m.isReplica() {
+		replicaHandlers[step](m, msg)
+	}
+	// Note that the leader also acts as a replica, but this logic is implemented in the underlying code.
+	leaderHandlers[step](m, msg)
+
+	return nil
+}
+
+func (m *ConsensusModule) shouldElectNextLeader() bool {
+	// Execute leader election if there is no leader and we are in a new round
+	return m.Step == NewRound && m.LeaderId == nil
+}
+
+func (m *ConsensusModule) shouldLogHotstuffDiscardMessage(step typesCons.HotstuffStep) bool {
+	// If a replica is not a leader for this round, but has already determined a leader,
+	// and continues to receive NewRound messages, we avoid logging the "message discard"
+	// because it creates unnecessary spam.
+	return !(m.LeaderId != nil && !m.isLeader() && step == NewRound)
+}
diff --git a/consensus/types/block.go b/consensus/types/block.go
new file mode 100644
index 000000000..f6091b6b3
--- /dev/null
+++ b/consensus/types/block.go
@@ -0,0 +1,14 @@
+package types
+
+import (
+	"github.com/pokt-network/pocket/shared/codec"
+)
+
+func (b *Block) Bytes() ([]byte, error) {
+	codec := codec.GetCodec()
+	blockProtoBz, err := codec.Marshal(b)
+	if err != nil {
+		return nil, err
+	}
+	return blockProtoBz, nil
+}
diff --git a/go.mod b/go.mod
index 067b1e7fa..30f937624 100644
--- a/go.mod
+++ b/go.mod
@@ -39,7 +39,7 @@ require (
 	github.com/docker/go-connections v0.4.0 // indirect
 	github.com/docker/go-units v0.4.0 // indirect
 	github.com/dustin/go-humanize v1.0.0 // indirect
-	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/gogo/protobuf v1.3.2
 	github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b // indirect
 	github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
diff --git a/go.sum b/go.sum
index 8d255a0b5..f7e72a772 100644
--- a/go.sum
+++ b/go.sum
@@ -63,6 +63,8 @@ github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+Ce
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/boombuler/barcode v1.0.0/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8=
+github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884 h1:iRNKw2WmAbVgGMNYzDH5Y2yY3+jyxwEK9Hc5pwIjZAE=
+github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884/go.mod h1:/sdYDakowo/XaxS2Fl7CBqtuf/O2uTqF2zmAUFAtAiw=
 github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4=
 github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
diff --git a/persistence/StateHash.md b/persistence/StateHash.md
new file mode 100644
index 000000000..cfc54af52
--- /dev/null
+++ b/persistence/StateHash.md
@@ -0,0 +1,194 @@
+Remaining tasks:
+
+1.  Simplify interfaces in utility & persistence (make it simple and clear)
+2.  How do we revert changes to the merkle trees?
+3.  Draw an end-to-end diagram of everything and the data flow
+
+## References:
+
+- https://github.com/cosmos/cosmos-sdk/discussions/9158
+- https://github.com/cosmos/cosmos-sdk/pull/8012
+- https://github.com/cosmos/cosmos-sdk/discussions/8297
+- https://github.com/cosmos/cosmos-sdk/discussions/8297
+- https://paper.dropbox.com/doc/State-commitments-and-storage-review--BpuF08OSksSkLeErjf66jrOAAg-wKl2RINZWD9I0DUmZIFwQ
+- https://arxiv.org/pdf/1803.05069.pdf
+
+## Open questions:
+
+1. Review flows
+2. How do we revert changes to the merkle trees?
+
+# This discussion is aimed at:
+
+1. Defining how we should compute the state hash
+2. Identify potential changes needed in the current codebase
+3. Propose next steps and actionable on implementation
+
+## Goals:
+
+- Define how the state hash will be computed
+- Propose the necessary changes in separate tasks
+- Implement each of the necessary pieces
+
+## Non-goals:
+
+- Choice/decision of Merkle Tree Design & Implementation
+- Selection of a key-value store engine
+
+## Primitives / non-negotiables:
+
+- We will be using Merkle Trees (and Merkle Proofs) for this design (i.e. not vector commitments)
+- We will be using a SQL engine for this (i.e. specifically PostgresSQL)
+- We will be using Protobufs (not Flatbuffers, json, yaml or other) for the schema
+
+## Necessary technical context:
+
+### DB Engines
+
+Insert table from here: [Merkle Tree Design & Implementation](https://tikv.org/deep-dive/key-value-engine/b-tree-vs-lsm/#summary)
+
+- Most **Key-Value Store DB** Engines use **LSM-trees** -> good for writes
+- Most **SQL DB** Engines use **B-Trees** -> good for reads
+
+_Basically all but there can be exceptions_
+
+### Addressable Merkle Trees
+
+State is stored use an Account Based (non UTXO) based Modle
+
+Insert image from: https://www.horizen.io/blockchain-academy/technology/expert/utxo-vs-account-model/#:~:text=The%20UTXO%20model%20is%20a,constructions%2C%20as%20well%20a%20sharding.
+
+---
+
+### Data Flow
+
+## Basics:
+
+1. Get each actor (flag, param, etc...) updated at a certain height (the context's height)
+2. Compute the protobuf (the deterministic schema we use as source of truth)
+3. Serialize the data struct
+4. Update the corresponding merkle tree
+5. Compute a state hash from the aggregated roots of all trees as per pokt-network/pocket-network-protocol@main/persistence#562-state-transition-sequence-diagram
+
+## Q&A
+
+Q: Can the SQL Engine be changed?
+A: Yes
+
+Q: Can the SQL Engine be removed altogether?
+A: Yes, but hard
+
+Q: Can the protobuf schema change?
+A: Yes, but out-of-scope
+
+Q: Can protobufs be replaced?
+A: Maybe, but out-of-scope
+
+---
+
+Learnings / Ideas:
+
+- Consolidate `UtilActorType` and `persistence.ActorType`
+- `modules.Actors` interface vs `types.Actor` in persistenceGenesis
+
+### Context Initialization
+
+```mermaid
+sequenceDiagram
+    %% autonumber
+    participant N as Node
+    participant C as Consensus
+    participant U as Utility
+    participant P as Persistence
+    participant PP as Persistence (PostgresDB)
+    participant PM as Persistence (MerkleTree)
+    participant P2P as P2P
+
+    %% Should this be P2P?
+    N-->>C: HandleMessage(anypb.Any)
+    critical NewRound Message
+        C->>+U: NewContext(height)
+        U->>P: NewRWContext(height)
+        P->>U: PersistenceRWContext
+        U->>U: Store persistenceContext
+        U->>-C: UtilityContext
+        C->>C: Store utilityContext
+        Note over C, PM: See 'Block Application'
+    end
+    Note over N, P2P: Hotstuff lifecycle
+    N-->>C: HandleMessage(anypb.Any)
+    critical Decide Message
+        Note over C, PM: See 'Block Commit'
+    end
+```
+
+### Block Application
+
+```mermaid
+sequenceDiagram
+    participant C as Consensus
+    participant U as Utility
+    participant P as Persistence
+    participant PP as Persistence (PostgresDB)
+    participant PM as Persistence (MerkleTree)
+
+    alt as leader
+        C->>+U: GetProposalTransactions(proposer, maxTxBz, [lastVal])
+        U->>U: reap mempool
+        U->>-C: txs
+        Note over C, U: Perform replica behaviour
+    else as replica
+        C->>+U: ApplyBlock(height, proposer, txs, lastVals)
+        loop Update DB: for each operation in tx
+            U->>P: ReadOp | WriteOp
+            P->>PP: ReadOp | WriteOp
+            PP->>P: data | ok
+            P->>U: data | ok
+            U->>U: validate
+            U->>P: StoreTransaction(tx)
+            P->>P: store locally
+            P->>U: ok
+        end
+        U->>+P: UpdateAppHash()
+        loop for each protocol actor type
+            P->>PP: GetActorsUpdate(height)
+            PP->>P: actors
+            loop Update Tree: for each actor
+                P->>PM: Update(addr, serialized(actor))
+                PM->>P: ok
+            end
+            P->>PM: GetRoot()
+            PM->>P: rootHash
+        end
+        P->>P: computeStateHash(rootHashes)
+        P->>-U: stateHash
+        U->>-C: hash
+    end
+```
+
+### Block Commit
+
+```mermaid
+sequenceDiagram
+    %% autonumber
+    participant C as Consensus
+    participant U as Utility
+    participant P as Persistence
+    participant PP as Persistence (PostgresDB)
+    participant PK as Persistence (Key-Value Store)
+
+    C->>U: CommitContext(quorumCert)
+    U->>P: Commit(proposerAddr, quorumCert)
+    P->>P: create typesPer.Block
+    P->>PP: insertBlock(block)
+    PP->>P: ok
+    P->>PK: Put(height, block)
+    PK->>P: ok
+    P->>P: commit tx
+    P->>U: ok
+    U->>P: Release()
+    P->>U: ok
+    C->>U: Release()
+    U->>C: ok
+    C->>C: release utilityContext
+```
diff --git a/persistence/application.go b/persistence/application.go
index 78750a7b6..755288155 100644
--- a/persistence/application.go
+++ b/persistence/application.go
@@ -4,15 +4,66 @@ import (
 	"encoding/hex"
 
 	"github.com/pokt-network/pocket/persistence/types"
+	"google.golang.org/protobuf/proto"
+
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
+func (p PostgresContext) UpdateApplicationsTree(apps []modules.Actor) error {
+	for _, app := range apps {
+		bzAddr, err := hex.DecodeString(app.GetAddress())
+		if err != nil {
+			return err
+		}
+
+		appBz, err := proto.Marshal(app.(*types.Actor))
+		if err != nil {
+			return err
+		}
+
+		// OPTIMIZE: This is the only line unique to `Application`
+		if _, err := p.MerkleTrees[appMerkleTree].Update(bzAddr, appBz); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (p PostgresContext) getApplicationsUpdatedAtHeight(height int64) (apps []*types.Actor, err error) {
+	// OPTIMIZE: This is the only line unique to `Application`
+	actors, err := p.GetActorsUpdated(types.ApplicationActor, height)
+	if err != nil {
+		return nil, err
+	}
+
+	apps = make([]*types.Actor, len(actors))
+	for _, actor := range actors {
+		app := &types.Actor{
+			ActorType:       types.ActorType_App,
+			Address:         actor.Address,
+			PublicKey:       actor.PublicKey,
+			Chains:          actor.Chains,
+			GenericParam:    actor.ActorSpecificParam,
+			StakedAmount:    actor.StakedTokens,
+			PausedHeight:    actor.PausedHeight,
+			UnstakingHeight: actor.UnstakingHeight,
+			Output:          actor.OutputAddress,
+		}
+		apps = append(apps, app)
+	}
+	return
+}
+
 func (p PostgresContext) GetAppExists(address []byte, height int64) (exists bool, err error) {
 	return p.GetExists(types.ApplicationActor, address, height)
 }
 
 func (p PostgresContext) GetApp(address []byte, height int64) (operator, publicKey, stakedTokens, maxRelays, outputAddress string, pauseHeight, unstakingHeight int64, chains []string, err error) {
 	actor, err := p.GetActor(types.ApplicationActor, address, height)
+	if err != nil {
+		return
+	}
 	operator = actor.Address
 	publicKey = actor.PublicKey
 	stakedTokens = actor.StakedTokens
diff --git a/persistence/block.go b/persistence/block.go
index aaee96364..5efa1b71e 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -5,6 +5,7 @@ import (
 	"encoding/hex"
 	"log"
 
+	"github.com/gogo/protobuf/proto"
 	"github.com/pokt-network/pocket/persistence/types"
 )
 
@@ -49,23 +50,46 @@ func (p PostgresContext) StoreTransaction(transactionProtoBytes []byte) error {
 	return nil
 }
 
-func (p PostgresContext) StoreBlock(blockProtoBytes []byte) error {
-	// INVESTIGATE: Note that we are writing this directly to the blockStore. Depending on how
-	// the use of the PostgresContext evolves, we may need to write this to `ContextStore` and copy
-	// over to `BlockStore` when the block is committed.
-	return p.blockstore.Put(heightToBytes(p.Height), blockProtoBytes)
-}
-
-func (p PostgresContext) InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error {
+func (p PostgresContext) insertBlock(block *types.Block) error {
 	ctx, tx, err := p.GetCtxAndTx()
 	if err != nil {
 		return err
 	}
 
-	_, err = tx.Exec(ctx, types.InsertBlockQuery(height, hash, proposerAddr, quorumCert))
+	_, err = tx.Exec(ctx, types.InsertBlockQuery(block.Height, block.Hash, block.ProposerAddress, block.QuorumCertificate))
 	return err
 }
 
+func (p PostgresContext) storeBlock(block *types.Block) error {
+	blockBz, err := proto.Marshal(block)
+	if err != nil {
+		return err
+	}
+
+	return p.blockstore.Put(heightToBytes(p.Height), blockBz)
+}
+
+func (p PostgresContext) getBlock(proposerAddr []byte, quorumCert []byte) (*types.Block, error) {
+	prevHash, err := p.GetBlockHash(p.Height - 1)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: get this from the transactions that were store via `StoreTransaction`
+	txs := make([][]byte, 0)
+
+	block := &types.Block{
+		Height:            uint64(p.Height),
+		Hash:              string(p.stateHash),
+		PrevHash:          string(prevHash),
+		ProposerAddress:   proposerAddr,
+		QuorumCertificate: quorumCert,
+		Transactions:      txs,
+	}
+
+	return block, nil
+}
+
 // CLEANUP: Should this be moved to a shared directory?
 func heightToBytes(height int64) []byte {
 	heightBytes := make([]byte, 8)
diff --git a/persistence/context.go b/persistence/context.go
index fd44e3af1..8224a229a 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -15,25 +15,39 @@ func (p PostgresContext) RollbackToSavePoint(bytes []byte) error {
 	return p.GetTx().Rollback(context.TODO())
 }
 
-func (p PostgresContext) AppHash() ([]byte, error) {
-	log.Println("TODO: AppHash not implemented")
-	return []byte("A real app hash, I am not"), nil
+func (p PostgresContext) UpdateAppHash() ([]byte, error) {
+	if err := p.updateStateHash(); err != nil {
+		return nil, err
+	}
+	return p.stateHash, nil
 }
 
 func (p PostgresContext) Reset() error {
 	panic("TODO: PostgresContext Reset not implemented")
 }
 
-func (p PostgresContext) Commit() error {
+func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
+	block, err := p.getBlock(proposerAddr, quorumCert)
+	if err != nil {
+		return err
+	}
+
+	if err := p.insertBlock(block); err != nil {
+		return err
+	}
+
+	if err := p.storeBlock(block); err != nil {
+		return err
+	}
+
 	ctx := context.TODO()
-	if err := p.GetTx().Commit(context.TODO()); err != nil {
+	if err := p.GetTx().Commit(ctx); err != nil {
 		return err
 	}
 	if err := p.conn.Close(ctx); err != nil {
 		log.Println("[TODO][ERROR] Implement connection pooling. Error when closing DB connecting...", err)
-
 	}
 	return nil
 }
diff --git a/persistence/db.go b/persistence/db.go
index 3a495596c..b8a974939 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -7,6 +7,7 @@ import (
 
 	"github.com/pokt-network/pocket/persistence/types"
 
+	"github.com/celestiaorg/smt"
 	"github.com/jackc/pgconn"
 	"github.com/jackc/pgx/v4"
 	"github.com/pokt-network/pocket/persistence/kvstore"
@@ -40,6 +41,13 @@ type PostgresContext struct {
 	conn       *pgx.Conn
 	tx         pgx.Tx
 	blockstore kvstore.KVStore
+
+	stateHash []byte
+	// IMPROVE: Depending on how the use of `PostgresContext` evolves, we may be able to get
+	// access to these directly via the postgres module.
+	PostgresDB  *pgx.Conn
+	BlockStore  kvstore.KVStore                      // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context)
+	MerkleTrees map[MerkleTree]*smt.SparseMerkleTree // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context)
 }
 
 func (pg *PostgresContext) GetCtxAndTx() (context.Context, pgx.Tx, error) {
diff --git a/persistence/debug.go b/persistence/debug.go
index 3fdc583a4..e0e3b6e5e 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -44,7 +44,7 @@ func (m *PersistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 
 func (m *PersistenceModule) clearState(_ *debug.DebugMessage) {
 	context, err := m.NewRWContext(-1)
-	defer context.Commit()
+	defer context.Commit(nil, nil)
 	if err != nil {
 		log.Printf("Error creating new context: %s \n", err)
 		return
diff --git a/persistence/genesis.go b/persistence/genesis.go
index 1c7e82f14..a6eefaa90 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -149,7 +149,7 @@ func (m *PersistenceModule) populateGenesisState(state *types.PersistenceGenesis
 		log.Fatalf("an error occurred initializing flags: %s", err.Error())
 	}
 
-	if err = rwContext.Commit(); err != nil {
+	if err = rwContext.Commit(nil, nil); err != nil {
 		log.Fatalf("an error occurred during commit() on genesis state %s ", err.Error())
 	}
 }
@@ -316,7 +316,7 @@ func (p PostgresContext) GetAllFishermen(height int64) (f []modules.Actor, err e
 	return
 }
 
-// TODO (Team) deprecate with interface #163 <Bumped to #149> as #163 is getting large
+// CONSOLIDATE: Consolidate `types.BaseActor` with `types.Actor`
 func (p PostgresContext) BaseActorToActor(ba types.BaseActor, actorType types.ActorType) *types.Actor {
 	actor := new(types.Actor)
 	actor.ActorType = actorType
diff --git a/persistence/kvstore/kvstore.go b/persistence/kvstore/kvstore.go
index 24613afc9..8636e4519 100644
--- a/persistence/kvstore/kvstore.go
+++ b/persistence/kvstore/kvstore.go
@@ -1,33 +1,47 @@
 package kvstore
 
 import (
+	"errors"
 	"log"
 
+	"github.com/celestiaorg/smt"
 	badger "github.com/dgraph-io/badger/v3"
 )
 
-// CLEANUP: move this structure to a shared module
 type KVStore interface {
 	// Lifecycle methods
 	Stop() error
 
 	// Accessors
 	// TODO: Add a proper iterator interface
-	Put(key []byte, value []byte) error
-	Get(key []byte) ([]byte, error)
 	// TODO: Add pagination for `GetAll`
 	GetAll(prefixKey []byte, descending bool) ([][]byte, error)
+
 	Exists(key []byte) (bool, error)
 	ClearAll() error
+
+	// Same interface as in `smt.MapStore``
+	Put(key, value []byte) error
+	Get(key []byte) ([]byte, error)
+	Delete(key []byte) error
 }
 
 var _ KVStore = &badgerKVStore{}
+var _ smt.MapStore = &badgerKVStore{}
+
+var (
+	ErrKVStoreExists    = errors.New("kvstore already exists")
+	ErrKVStoreNotExists = errors.New("kvstore does not exist")
+)
 
 type badgerKVStore struct {
 	db *badger.DB
 }
 
-func NewKVStore(path string) (KVStore, error) {
+// REFACTOR: Loads or creates a badgerDb at `path`. This may potentially need to be refactored
+// into `NewKVStore` and `LoadKVStore` depending on how state sync evolves by leveraging `os.Stat`
+// on the file path.
+func OpenKVStore(path string) (KVStore, error) {
 	db, err := badger.Open(badger.DefaultOptions(path))
 	if err != nil {
 		return nil, err
@@ -43,7 +57,7 @@ func NewMemKVStore() KVStore {
 	return badgerKVStore{db: db}
 }
 
-func (store badgerKVStore) Put(key []byte, value []byte) error {
+func (store badgerKVStore) Put(key, value []byte) error {
 	tx := store.db.NewTransaction(true)
 	defer tx.Discard()
 
@@ -55,6 +69,12 @@ func (store badgerKVStore) Put(key []byte, value []byte) error {
 	return tx.Commit()
 }
 
+// CONSOLIDATE: We might be able to remove the `KVStore` interface altogether if we end up using `smt.MapStore`
+// A wrapper around `Put` to conform to the `smt.MapStore` interface
+func (store *badgerKVStore) Set(key, value []byte) error {
+	return store.Put(key, value)
+}
+
 func (store badgerKVStore) Get(key []byte) ([]byte, error) {
 	tx := store.db.NewTransaction(false)
 	defer tx.Discard()
@@ -76,6 +96,11 @@ func (store badgerKVStore) Get(key []byte) ([]byte, error) {
 	return value, nil
 }
 
+func (store badgerKVStore) Delete(key []byte) error {
+	log.Fatalf("badgerKVStore.Delete not implemented yet")
+	return nil
+}
+
 func (store badgerKVStore) GetAll(prefix []byte, descending bool) (values [][]byte, err error) {
 	// INVESTIGATE: research `badger.views` for further improvements and optimizations
 	txn := store.db.NewTransaction(false)
diff --git a/persistence/module.go b/persistence/module.go
index 33bd827bd..6761bb22b 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -7,10 +7,10 @@ import (
 	"io/ioutil"
 	"log"
 
-	"github.com/pokt-network/pocket/persistence/types"
-
+	"github.com/celestiaorg/smt"
 	"github.com/jackc/pgx/v4"
 	"github.com/pokt-network/pocket/persistence/kvstore"
+	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 	"github.com/pokt-network/pocket/shared/test_artifacts"
 )
@@ -26,10 +26,19 @@ type PersistenceModule struct {
 	postgresURL string
 	nodeSchema  string
 	genesisPath string
-	blockStore  kvstore.KVStore // INVESTIGATE: We may need to create a custom `BlockStore` package in the future
 
 	// TECHDEBT: Need to implement context pooling (for writes), timeouts (for read & writes), etc...
 	writeContext *PostgresContext // only one write context is allowed at a time
+
+	// The connection to the PostgreSQL database
+	postgresConn *pgx.Conn
+	// A reference to the block key-value store
+	// INVESTIGATE: We may need to create a custom `BlockStore` package in the future.
+	blockStore kvstore.KVStore
+	// A mapping of context IDs to persistence contexts
+	// contexts map[contextId]modules.PersistenceRWContext
+	// Merkle trees
+	trees map[MerkleTree]*smt.SparseMerkleTree
 }
 
 const (
@@ -42,8 +51,10 @@ func Create(configPath, genesisPath string) (modules.PersistenceModule, error) {
 	if err != nil {
 		return nil, err
 	}
+
 	cfg := c.(*types.PersistenceConfig)
 	g, err := m.InitGenesis(genesisPath)
+
 	if err != nil {
 		return nil, err
 	}
@@ -69,8 +80,20 @@ func Create(configPath, genesisPath string) (modules.PersistenceModule, error) {
 		genesisPath:  genesisPath,
 		blockStore:   blockStore,
 		writeContext: nil,
+		// contexts:     make(map[contextId]modules.PersistenceContext),
+		trees: make(map[MerkleTree]*smt.SparseMerkleTree),
 	}
 
+	// DISCUSS_IN_THIS_COMMIT: We've been using the module function pattern, but this making `initializeTrees`
+	// be able to create and/or load trees outside the scope of the persistence module makes it easier to test.
+	trees, err := newMerkleTrees()
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO_IN_THIS_COMMIT: load trees from state
+	persistenceMod.trees = trees
+
 	// Determine if we should hydrate the genesis db or use the current state of the DB attached
 	if shouldHydrateGenesis, err := persistenceMod.shouldHydrateGenesisDb(); err != nil {
 		return nil, err
@@ -214,7 +237,7 @@ func initializeBlockStore(blockStorePath string) (kvstore.KVStore, error) {
 	if blockStorePath == "" {
 		return kvstore.NewMemKVStore(), nil
 	}
-	return kvstore.NewKVStore(blockStorePath)
+	return kvstore.OpenKVStore(blockStorePath)
 }
 
 // TODO(drewsky): Simplify and externalize the logic for whether genesis should be populated and
diff --git a/persistence/proto/block_persistence.proto b/persistence/proto/block_persistence.proto
new file mode 100644
index 000000000..0c314690d
--- /dev/null
+++ b/persistence/proto/block_persistence.proto
@@ -0,0 +1,13 @@
+syntax = "proto3";
+package persistence;
+
+option go_package = "github.com/pokt-network/pocket/persistence/types";
+
+message Block {
+    uint64 height = 1;
+    string hash = 2;
+    string prevHash = 3;
+    bytes proposerAddress = 4;
+    bytes quorumCertificate = 5;
+    repeated bytes transactions = 6;
+}
\ No newline at end of file
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
index 9f2c19a00..8eac77562 100644
--- a/persistence/shared_sql.go
+++ b/persistence/shared_sql.go
@@ -44,6 +44,36 @@ func (p *PostgresContext) GetExists(actorSchema types.ProtocolActorSchema, addre
 	return
 }
 
+func (p *PostgresContext) GetActorsUpdated(actorSchema types.ProtocolActorSchema, height int64) (actors []types.BaseActor, err error) {
+	ctx, tx, err := p.GetCtxAndTx()
+	if err != nil {
+		return
+	}
+
+	rows, err := tx.Query(ctx, actorSchema.GetUpdatedAtHeightQuery(height))
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	// OPTIMIZE: Consolidate logic with `GetActor` to reduce code footprint
+	var addr string
+	for rows.Next() {
+		if err = rows.Scan(&addr); err != nil {
+			return
+		}
+
+		actor, err := p.GetActor(actorSchema, []byte(addr), height)
+		if err != nil {
+			return nil, err
+		}
+
+		actors = append(actors, actor)
+	}
+
+	return
+}
+
 func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, address []byte, height int64) (actor types.BaseActor, err error) {
 	ctx, tx, err := p.GetCtxAndTx()
 	if err != nil {
@@ -57,10 +87,16 @@ func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, addres
 	return p.GetChainsForActor(ctx, tx, actorSchema, actor, height)
 }
 
+// IMPORTANT: Need to consolidate `persistence/types.BaseActor` with `persistence/genesisTypes.Actor`
 func (p *PostgresContext) GetActorFromRow(row pgx.Row) (actor types.BaseActor, height int64, err error) {
 	err = row.Scan(
-		&actor.Address, &actor.PublicKey, &actor.StakedTokens, &actor.ActorSpecificParam,
-		&actor.OutputAddress, &actor.PausedHeight, &actor.UnstakingHeight,
+		&actor.Address,
+		&actor.PublicKey,
+		&actor.StakedTokens,
+		&actor.ActorSpecificParam,
+		&actor.OutputAddress,
+		&actor.PausedHeight,
+		&actor.UnstakingHeight,
 		&height)
 	return
 }
diff --git a/persistence/state.go b/persistence/state.go
new file mode 100644
index 000000000..5c3913140
--- /dev/null
+++ b/persistence/state.go
@@ -0,0 +1,119 @@
+package persistence
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"log"
+	"sort"
+
+	"github.com/celestiaorg/smt"
+	typesUtil "github.com/pokt-network/pocket/utility/types"
+	"google.golang.org/protobuf/proto"
+)
+
+type MerkleTree float64
+
+// A work-in-progress list of all the trees we need to update to maintain the overall state
+const (
+	// Actor  Merkle Trees
+	appMerkleTree MerkleTree = iota
+	valMerkleTree
+	fishMerkleTree
+	serviceNodeMerkleTree
+	accountMerkleTree
+	poolMerkleTree
+
+	// Data / State Merkle Trees
+	blocksMerkleTree
+	paramsMerkleTree
+	flagsMerkleTree
+
+	// Used for iteration purposes only - see https://stackoverflow.com/a/64178235/768439
+	lastMerkleTree
+)
+
+func newMerkleTrees() (map[MerkleTree]*smt.SparseMerkleTree, error) {
+	// We need a separate Merkle tree for each type of actor or storage
+	trees := make(map[MerkleTree]*smt.SparseMerkleTree, int(lastMerkleTree))
+
+	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
+		// TODO_IN_THIS_COMMIT: Rather than using `NewSimpleMap`, use a disk based key-value store
+		nodeStore := smt.NewSimpleMap()
+		valueStore := smt.NewSimpleMap()
+
+		trees[treeType] = smt.NewSparseMerkleTree(nodeStore, valueStore, sha256.New())
+	}
+	return trees, nil
+}
+
+func loadMerkleTrees(map[MerkleTree]*smt.SparseMerkleTree, error) {
+	log.Fatalf("loadMerkleTrees not implemented yet")
+}
+
+func (p *PostgresContext) updateStateHash() error {
+	// Update all the merkle trees
+	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
+		switch treeType {
+		case appMerkleTree:
+			apps, err := p.getApplicationsUpdatedAtHeight(p.Height)
+			if err != nil {
+				// TODO_IN_THIS_COMMIT: Update this error
+				return typesUtil.NewError(typesUtil.Code(42), "Couldn't figure out apps updated")
+			}
+			for _, app := range apps {
+				appBz, err := proto.Marshal(app)
+				if err != nil {
+					return err
+				}
+				// An update results in a create/update that is idempotent
+				addrBz, err := hex.DecodeString(app.Address)
+				if err != nil {
+					return err
+				}
+				if _, err := p.MerkleTrees[treeType].Update(addrBz, appBz); err != nil {
+					return err
+				}
+			}
+		case valMerkleTree:
+			fmt.Println("TODO: valMerkleTree not implemented")
+		case fishMerkleTree:
+			fmt.Println("TODO: fishMerkleTree not implemented")
+		case serviceNodeMerkleTree:
+			fmt.Println("TODO: serviceNodeMerkleTree not implemented")
+		case accountMerkleTree:
+			fmt.Println("TODO: accountMerkleTree not implemented")
+		case poolMerkleTree:
+			fmt.Println("TODO: poolMerkleTree not implemented")
+		case blocksMerkleTree:
+			// VERY VERY IMPORTANT DISCUSSION: What do we do here provided that `Commit`, which stores the block in the DB and tree
+			//                                 requires the quorumCert, which we receive at the very end of hotstuff consensus
+			fmt.Println("TODO: blocksMerkleTree not implemented")
+		case paramsMerkleTree:
+			fmt.Println("TODO: paramsMerkleTree not implemented")
+		case flagsMerkleTree:
+			fmt.Println("TODO: flagsMerkleTree not implemented")
+		default:
+			log.Fatalln("Not handled yet in state commitment update", treeType)
+		}
+	}
+
+	// Get the root of each Merkle Tree
+	roots := make([][]byte, 0)
+	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
+		roots = append(roots, p.MerkleTrees[treeType].Root())
+	}
+
+	// Sort the merkle roots lexicographically
+	sort.Slice(roots, func(r1, r2 int) bool {
+		return bytes.Compare(roots[r1], roots[r2]) < 0
+	})
+
+	// Get the state hash
+	rootsConcat := bytes.Join(roots, []byte{})
+	stateHash := sha256.Sum256(rootsConcat)
+
+	p.stateHash = stateHash[:]
+	return nil
+}
diff --git a/persistence/state_test.go b/persistence/state_test.go
new file mode 100644
index 000000000..9570f4c00
--- /dev/null
+++ b/persistence/state_test.go
@@ -0,0 +1,15 @@
+package persistence
+
+import "testing"
+
+func TestStateHash_InitializeTrees(t *testing.T) {
+
+}
+
+func TestStateHash_LoadTrees(t *testing.T) {
+
+}
+
+func TestStateHash_ComputeStateHash(t *testing.T) {
+
+}
diff --git a/persistence/test/module_test.go b/persistence/test/module_test.go
index 3bee636c5..ccb7bd37f 100644
--- a/persistence/test/module_test.go
+++ b/persistence/test/module_test.go
@@ -18,12 +18,14 @@ func TestPersistenceContextParallelReadWrite(t *testing.T) {
 	poolAddress := []byte("address")
 	originalAmount := "15"
 	modifiedAmount := "10"
+	proposer := []byte("proposer")
+	quorumCert := []byte("quorumCert")
 
 	// setup a write context, insert a pool and commit it
 	context, err := testPersistenceMod.NewRWContext(0)
 	require.NoError(t, err)
 	require.NoError(t, context.InsertPool(poolName, poolAddress, originalAmount))
-	require.NoError(t, context.Commit())
+	require.NoError(t, context.Commit(proposer, quorumCert))
 
 	// verify the insert in the previously committed context worked
 	contextA, err := testPersistenceMod.NewRWContext(0)
diff --git a/persistence/types/base_actor.go b/persistence/types/base_actor.go
index 9514b15eb..1c73da9a7 100644
--- a/persistence/types/base_actor.go
+++ b/persistence/types/base_actor.go
@@ -1,5 +1,6 @@
 package types
 
+// IMPROVE: Move schema related functions to a separate sub-package
 import "github.com/pokt-network/pocket/shared/modules"
 
 // TECHDEBT: Consider moving this to a protobuf. This struct was created to make testing simple of protocol actors that
@@ -60,6 +61,10 @@ func (actor *BaseProtocolActorSchema) GetChainsTableSchema() string {
 	return ProtocolActorChainsTableSchema(actor.chainsHeightConstraintName)
 }
 
+func (actor *BaseProtocolActorSchema) GetUpdatedAtHeightQuery(height int64) string {
+	return SelectAtHeight(AddressCol, height, actor.tableName)
+}
+
 func (actor *BaseProtocolActorSchema) GetQuery(address string, height int64) string {
 	return Select(AllColsSelector, address, height, actor.tableName)
 }
@@ -150,5 +155,5 @@ func (x *Actor) GetActorTyp() modules.ActorType {
 	if x != nil {
 		return x.GetActorType()
 	}
-	return ActorType_App
+	return ActorType_App // HACK: Is this a hack?
 }
diff --git a/persistence/types/protocol_actor.go b/persistence/types/protocol_actor.go
index 1052dc3d6..709457b6c 100644
--- a/persistence/types/protocol_actor.go
+++ b/persistence/types/protocol_actor.go
@@ -15,6 +15,9 @@ type ProtocolActorSchema interface {
 	GetActorSpecificColName() string
 
 	/*** Read/Get Queries ***/
+
+	// Returns a query to retrieve the addresses of all the Actors updated at that specific height
+	GetUpdatedAtHeightQuery(height int64) string
 	// Returns a query to retrieve all of a single Actor's attributes.
 	GetQuery(address string, height int64) string
 	// Returns all actors at that height
diff --git a/persistence/types/shared_sql.go b/persistence/types/shared_sql.go
index e36907124..6e1f929c7 100644
--- a/persistence/types/shared_sql.go
+++ b/persistence/types/shared_sql.go
@@ -69,6 +69,11 @@ func ProtocolActorChainsTableSchema(constraintName string) string {
 		)`, AddressCol, ChainIDCol, HeightCol, DefaultBigInt, constraintName, AddressCol, ChainIDCol, HeightCol)
 }
 
+func SelectAtHeight(selector string, height int64, tableName string) string {
+	return fmt.Sprintf(`SELECT %s FROM %s WHERE height=%d`,
+		selector, tableName, height)
+}
+
 func Select(selector, address string, height int64, tableName string) string {
 	return fmt.Sprintf(`SELECT %s FROM %s WHERE address='%s' AND height<=%d ORDER BY height DESC LIMIT 1`,
 		selector, tableName, address, height)
diff --git a/shared/docs/flows/README.md b/shared/docs/flows/README.md
deleted file mode 100644
index cb4e5d663..000000000
--- a/shared/docs/flows/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# Flows
-
-The purpose of [shared/flows](./) is to document cross-module communication for end-to-end behaviour that has cross-module dependencies and and depends on the interfaces exposed by the interfaces exposed in [shared/modules](../modules).
diff --git a/shared/indexer/indexer.go b/shared/indexer/indexer.go
index 559ca1f6e..59355787f 100644
--- a/shared/indexer/indexer.go
+++ b/shared/indexer/indexer.go
@@ -5,6 +5,7 @@ package indexer
 import (
 	"encoding/hex"
 	"fmt"
+
 	"github.com/pokt-network/pocket/shared/codec"
 
 	"github.com/jordanorelli/lexnum"
@@ -111,7 +112,7 @@ type txIndexer struct {
 }
 
 func NewTxIndexer(databasePath string) (TxIndexer, error) {
-	db, err := kvstore.NewKVStore(databasePath)
+	db, err := kvstore.OpenKVStore(databasePath)
 	return &txIndexer{
 		db: db,
 	}, err
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index 9379f6362..dd4f7fd19 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -109,6 +109,29 @@ type PersistenceWriteContext interface {
 	// Flag Operations
 	InitFlags() error
 	SetFlag(paramName string, value interface{}, enabled bool) error
+
+	// Tree Operations
+
+	// # Option 1:
+
+	UpdateApplicationsTree([]Actor) error
+	// UpdateValidatorsTree([]Actor) error
+	// UpdateServiceNodesTree([]Actor) error
+	// UpdateFishermanTree([]Actor) error
+	// Update<FutureActors>Tree([]Actor) error
+	// Update<Other>Tree([]Other) error
+
+	// # Option 2:
+	// UpdateActorTree(types.ProtocolActorSchema, []Actor) error
+	// Update<Other>Tree([]Other) error
+
+	// # Option 3:
+	// UpdateApplicationsTree([]Application) error
+	// UpdateValidatorsTree([]Validator) error
+	// UpdateServiceNodesTree([]ServiceNode) error
+	// UpdateFishermanTree([]Fisherman) error
+	// Update<FutureActors>Tree([]FutureActor) error
+	// Update<Other>Tree([]Other) error
 }
 
 type PersistenceReadContext interface {
@@ -185,4 +208,28 @@ type PersistenceReadContext interface {
 	GetIntFlag(paramName string, height int64) (int, bool, error)
 	GetStringFlag(paramName string, height int64) (string, bool, error)
 	GetBytesFlag(paramName string, height int64) ([]byte, bool, error)
+
+	// Tree Operations
+
+	// # Option 1:
+
+	// GetApplicationsUpdatedAtHeight(height int64) ([]Actor, error)
+	// GetValidatorsUpdatedAtHeight(height int64) ([]Actor, error)
+	// GetServiceNodesUpdatedAtHeight(height int64) ([]Actor, error)
+	// GetFishermanUpdatedAtHeight(height int64) ([]Actor, error)
+	// Get<FutureActor>UpdatedAtHeight(height int64) ([]Actor, error)
+	// Get<Other>UpdatedAtHeight(height int64) ([]Actor, error)
+	// Update<Other>Tree(height int64) ([]Actor, error)
+
+	// # Option 2:
+	// Get<FutureActor>UpdatedAtHeight(types.ProtocolActorSchema, height int64) ([]Actor, error)
+	// Get<Other>UpdatedAtHeight(height int64) ([]Other, error)
+
+	// # Option 3:
+	// GetApplicationsUpdatedAtHeight(height int64) ([]Application, error)
+	// GetValidatorsUpdatedAtHeight(height int64) ([]Validator, error)
+	// GetServiceNodesUpdatedAtHeight(height int64) ([]ServiceNode, error)
+	// GetFishermanUpdatedAtHeight(height int64) ([]Fisherman, error)
+	// Get<FutureActor>UpdatedAtHeight(height int64) ([]FutureActor, error)
+	// Get<Other>UpdatedAtHeight(height int64) ([]Other, error)
 }
diff --git a/shared/test_artifacts/generator.go b/shared/test_artifacts/generator.go
index a48fbc7a3..8d6746ef3 100644
--- a/shared/test_artifacts/generator.go
+++ b/shared/test_artifacts/generator.go
@@ -6,10 +6,9 @@ import (
 	"strconv"
 
 	typesPersistence "github.com/pokt-network/pocket/persistence/types"
+	"github.com/pokt-network/pocket/shared/crypto"
 	"github.com/pokt-network/pocket/shared/modules"
 	"github.com/pokt-network/pocket/utility/types"
-
-	"github.com/pokt-network/pocket/shared/crypto"
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
diff --git a/shared/types/genesis/validator.go b/shared/types/genesis/validator.go
new file mode 100644
index 000000000..17c2af5fd
--- /dev/null
+++ b/shared/types/genesis/validator.go
@@ -0,0 +1,49 @@
+package genesis
+
+// import (
+// 	"encoding/hex"
+// 	"encoding/json"
+
+// 	"google.golang.org/protobuf/encoding/protojson"
+// )
+
+// // TODO_IN_THIS_COMMIT: See https://github.com/pokt-network/pocket/pull/139/files to remove this shit
+
+// // HACK: Since the protocol actor protobufs (e.g. validator, fisherman, etc) use `bytes` for some
+// // fields (e.g. `address`, `output`, `publicKey`), we need to use a helper struct to unmarshal the
+// // the types when they are defined via json (e.g. genesis file, testing configurations, etc...).
+// // Alternative solutions could include whole wrapper structs (i.e. duplication of schema definition),
+// // using strings instead of bytes (i.e. major change with downstream effects) or avoid defining these
+// // types in json altogether (i.e. limitation of usability).
+// type JsonBytesLoaderHelper struct {
+// 	Address   HexData `json:"address,omitempty"`
+// 	PublicKey HexData `json:"public_key,omitempty"`
+// 	Output    HexData `json:"output,omitempty"`
+// }
+
+// type HexData []byte
+
+// func (h *HexData) UnmarshalJSON(data []byte) error {
+// 	var s string
+// 	if err := json.Unmarshal(data, &s); err != nil {
+// 		return err
+// 	}
+// 	decoded, err := hex.DecodeString(s)
+// 	if err != nil {
+// 		return err
+// 	}
+// 	*h = HexData(decoded)
+// 	return nil
+// }
+
+// func (v *Validator) UnmarshalJSON(data []byte) error {
+// 	var jh JsonBytesLoaderHelper
+// 	json.Unmarshal(data, &jh)
+
+// 	protojson.Unmarshal(data, v)
+// 	v.Address = jh.Address
+// 	v.PublicKey = jh.PublicKey
+// 	v.Output = jh.Output
+
+// 	return nil
+// }
diff --git a/utility/block.go b/utility/block.go
index 1bca5f6c1..7394b04b0 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -33,6 +33,8 @@ var (
 
 func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) ([]byte, error) {
 	u.LatestHeight = latestHeight
+	u.CurrentProposer = proposerAddress
+
 	// begin block lifecycle phase
 	if err := u.BeginBlock(lastBlockByzantineValidators); err != nil {
 		return nil, err
@@ -50,22 +52,30 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 		if err := u.ApplyTransaction(tx); err != nil {
 			return nil, err
 		}
-		if err := u.GetPersistenceContext().StoreTransaction(transactionProtoBytes); err != nil {
+		if err := u.Context.PersistenceRWContext.StoreTransaction(transactionProtoBytes); err != nil {
 			return nil, err
 		}
 
-		// TODO: if found, remove transaction from mempool
 		// DISCUSS: What if the context is rolled back or cancelled. Do we add it back to the mempool?
+		// TODO: if found, remove transaction from mempool
 		// if err := u.Mempool.DeleteTransaction(transaction); err != nil {
 		// 	return nil, err
 		// }
 	}
+
 	// end block lifecycle phase
 	if err := u.EndBlock(proposerAddress); err != nil {
 		return nil, err
 	}
-	// return the app hash (consensus module will get the validator set directly
-	return u.GetAppHash()
+
+	// TODO: What if everything above succeeded but updating the app hash failed?
+	appHash, err := u.Context.UpdateAppHash()
+	if err != nil {
+		return nil, typesUtil.ErrAppHash(err)
+	}
+
+	// return the app hash; consensus module will get the validator set directly
+	return appHash, nil
 }
 
 func (u *UtilityContext) BeginBlock(previousBlockByzantineValidators [][]byte) typesUtil.Error {
@@ -91,15 +101,6 @@ func (u *UtilityContext) EndBlock(proposer []byte) typesUtil.Error {
 	return nil
 }
 
-func (u *UtilityContext) GetAppHash() ([]byte, typesUtil.Error) {
-	// Get the root hash of the merkle state tree for state consensus integrity
-	appHash, er := u.Context.AppHash()
-	if er != nil {
-		return nil, typesUtil.ErrAppHash(er)
-	}
-	return appHash, nil
-}
-
 // HandleByzantineValidators handles the validators who either didn't sign at all or disagreed with the 2/3+ majority
 func (u *UtilityContext) HandleByzantineValidators(lastBlockByzantineValidators [][]byte) typesUtil.Error {
 	latestBlockHeight, err := u.GetLatestBlockHeight()
diff --git a/utility/context.go b/utility/context.go
index c3f97f3a8..a8797a52c 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -2,19 +2,24 @@ package utility
 
 import (
 	"encoding/hex"
+
 	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/modules"
 	typesUtil "github.com/pokt-network/pocket/utility/types"
 )
 
 type UtilityContext struct {
-	LatestHeight int64
-	Mempool      typesUtil.Mempool
-	Context      *Context // IMPROVE: Consider renmaming to PersistenceContext
+	LatestHeight    int64 // IMPROVE: Rename to `currentHeight?`
+	CurrentProposer []byte
+
+	Mempool typesUtil.Mempool
+	Context *Context // IMPROVE: Rename to `persistenceContext` or `storeContext` or `reversibleContext`?
 }
 
-type Context struct {
+type Context struct { // IMPROVE: Rename to `persistenceContext` or `storeContext`?
+	// TODO: Since `Context` embeds `PersistenceRWContext`, we don't need to do `u.Context.PersistenceRWContext`, but can call `u.Context` directly
 	modules.PersistenceRWContext
+	// TODO/DISCUSS: `SavePoints`` have not been implemented yet
 	SavePointsM map[string]struct{}
 	SavePoints  [][]byte
 }
@@ -39,17 +44,16 @@ func (u *UtilityContext) Store() *Context {
 	return u.Context
 }
 
-func (u *UtilityContext) GetPersistenceContext() modules.PersistenceRWContext {
-	return u.Context.PersistenceRWContext
-}
-
-func (u *UtilityContext) CommitPersistenceContext() error {
-	return u.Context.PersistenceRWContext.Commit()
+func (u *UtilityContext) CommitContext(quorumCert []byte) error {
+	err := u.Context.PersistenceRWContext.Commit(u.CurrentProposer, quorumCert)
+	u.Context = nil // DISCUSS: Should we release the context if there was an error here?
+	return err
 }
 
-func (u *UtilityContext) ReleaseContext() {
-	u.Context.Release()
+func (u *UtilityContext) ReleaseContext() error {
+	err := u.Context.Release()
 	u.Context = nil
+	return err
 }
 
 func (u *UtilityContext) GetLatestBlockHeight() (int64, typesUtil.Error) {
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index 6fac303cb..0695d62e9 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -172,18 +172,6 @@ func TestUtilityContext_EndBlock(t *testing.T) {
 	test_artifacts.CleanupTest(ctx)
 }
 
-func TestUtilityContext_GetAppHash(t *testing.T) {
-	ctx := NewTestingUtilityContext(t, 0)
-
-	appHashTest, err := ctx.GetAppHash()
-	require.NoError(t, err)
-
-	appHashSource, er := ctx.Context.AppHash()
-	require.NoError(t, er)
-	require.Equal(t, appHashTest, appHashSource, "unexpected appHash")
-
-	test_artifacts.CleanupTest(ctx)
-}
 func TestUtilityContext_UnstakeValidatorsActorsThatAreReady(t *testing.T) {
 	for _, actorType := range typesUtil.ActorTypes {
 		ctx := NewTestingUtilityContext(t, 1)

From f909103ec23d68851f9286a8dfde7b164c97af28 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 4 Oct 2022 19:33:33 -0700
Subject: [PATCH 070/227] Tests failing but running

---
 go.mod                      | 2 +-
 p2p/module_raintree_test.go | 5 ++---
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/go.mod b/go.mod
index 30f937624..1f27b7f08 100644
--- a/go.mod
+++ b/go.mod
@@ -20,8 +20,8 @@ require (
 )
 
 require (
-	github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884
 	github.com/benbjohnson/clock v1.3.0
+	github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884
 	github.com/dgraph-io/badger/v3 v3.2103.2
 	github.com/jackc/pgconn v1.11.0
 	github.com/jordanorelli/lexnum v0.0.0-20141216151731-460eeb125754
diff --git a/p2p/module_raintree_test.go b/p2p/module_raintree_test.go
index 3fbb212fe..c9abba1b6 100644
--- a/p2p/module_raintree_test.go
+++ b/p2p/module_raintree_test.go
@@ -15,15 +15,14 @@ import (
 	"testing"
 	"time"
 
-	"github.com/pokt-network/pocket/shared/debug"
-	"github.com/pokt-network/pocket/shared/test_artifacts"
-
 	"github.com/golang/mock/gomock"
 	typesP2P "github.com/pokt-network/pocket/p2p/types"
 	mocksP2P "github.com/pokt-network/pocket/p2p/types/mocks"
 	cryptoPocket "github.com/pokt-network/pocket/shared/crypto"
+	"github.com/pokt-network/pocket/shared/debug"
 	"github.com/pokt-network/pocket/shared/modules"
 	modulesMock "github.com/pokt-network/pocket/shared/modules/mocks"
+	"github.com/pokt-network/pocket/shared/test_artifacts"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/protobuf/types/known/anypb"
 )

From 593dac7b3aba28ef75915ba86b3c073af7fd93ff Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 4 Oct 2022 19:38:51 -0700
Subject: [PATCH 071/227] Commented out the business logic in storeBlock

---
 consensus/block.go                      | 31 ++++++++++++++-----------
 consensus/consensus_tests/utils_test.go |  9 +++----
 persistence/context.go                  |  8 ++-----
 persistence/debug.go                    |  2 +-
 persistence/genesis.go                  |  2 +-
 persistence/module.go                   |  2 +-
 persistence/test/module_test.go         | 12 ++++++----
 persistence/test/setup_test.go          |  4 ++--
 utility/block.go                        |  4 ++--
 utility/context.go                      | 14 +++++------
 utility/test/block_test.go              |  7 +++---
 utility/test/module_test.go             |  2 +-
 12 files changed, 47 insertions(+), 50 deletions(-)

diff --git a/consensus/block.go b/consensus/block.go
index 536c3cc74..94f1c8d26 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -89,7 +89,7 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 	// should not be called.
 	if m.utilityContext != nil {
 		m.nodeLog(typesCons.NilUtilityContextWarning)
-		m.utilityContext.ReleaseContext()
+		m.utilityContext.Release()
 		m.utilityContext = nil
 	}
 
@@ -123,11 +123,11 @@ func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 	}
 
 	// Commit and release the context
-	if err := m.utilityContext.CommitPersistenceContext(); err != nil {
+	if err := m.utilityContext.Commit(block.BlockHeader.QuorumCertificate); err != nil {
 		return err
 	}
 
-	m.utilityContext.ReleaseContext()
+	m.utilityContext.Release()
 	m.utilityContext = nil
 
 	m.appHash = block.BlockHeader.Hash
@@ -135,17 +135,20 @@ func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 	return nil
 }
 
+// DISCUSS_IN_THIS_COMMIT(#284): THIS IS A BREAKING CHANGE. Need to figure out how we should handle
+// interface changes like this moving forward. Consider keeping components of the old interface in place
+// and deleting them in a later commit along with the implementation.
 func (m *ConsensusModule) storeBlock(block *typesCons.Block, blockProtoBytes []byte) error {
-	store := m.utilityContext.GetPersistenceContext()
-	// Store in KV Store
-	if err := store.StoreBlock(blockProtoBytes); err != nil {
-		return err
-	}
-
-	// Store in SQL Store
-	header := block.BlockHeader
-	if err := store.InsertBlock(uint64(header.Height), header.Hash, header.ProposerAddress, header.QuorumCertificate); err != nil {
-		return err
-	}
+	// 	store := m.utilityContext.GetPersistenceContext()
+	// 	// Store in KV Store
+	// 	if err := store.StoreBlock(blockProtoBytes); err != nil {
+	// 		return err
+	// 	}
+
+	// 	// Store in SQL Store
+	// 	header := block.BlockHeader
+	// 	if err := store.InsertBlock(uint64(header.Height), header.Hash, header.ProposerAddress, header.QuorumCertificate); err != nil {
+	// 		return err
+	// 	}
 	return nil
 }
diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 4903a9abd..1c79b3424 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -358,9 +358,8 @@ func baseUtilityMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockUti
 		Return(utilityContextMock, nil).
 		MaxTimes(4)
 
-	utilityContextMock.EXPECT().GetPersistenceContext().Return(persistenceContextMock).AnyTimes()
-	utilityContextMock.EXPECT().CommitPersistenceContext().Return(nil).AnyTimes()
-	utilityContextMock.EXPECT().ReleaseContext().Return().AnyTimes()
+	utilityContextMock.EXPECT().Commit(gomock.Any()).Return(nil).AnyTimes()
+	utilityContextMock.EXPECT().Release().Return(nil).AnyTimes()
 	utilityContextMock.EXPECT().
 		GetProposalTransactions(gomock.Any(), maxTxBytes, gomock.AssignableToTypeOf(emptyByzValidators)).
 		Return(make([][]byte, 0), nil).
@@ -370,9 +369,7 @@ func baseUtilityMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockUti
 		Return(appHash, nil).
 		AnyTimes()
 
-	persistenceContextMock.EXPECT().Commit().Return(nil).AnyTimes()
-	persistenceContextMock.EXPECT().StoreBlock(gomock.Any()).AnyTimes().Return(nil)
-	persistenceContextMock.EXPECT().InsertBlock(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes().Return(nil)
+	persistenceContextMock.EXPECT().Commit(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
 
 	return utilityMock
 }
diff --git a/persistence/context.go b/persistence/context.go
index fd44e3af1..22bfb1278 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -15,16 +15,12 @@ func (p PostgresContext) RollbackToSavePoint(bytes []byte) error {
 	return p.GetTx().Rollback(context.TODO())
 }
 
-func (p PostgresContext) AppHash() ([]byte, error) {
+func (p PostgresContext) UpdateAppHash() ([]byte, error) {
 	log.Println("TODO: AppHash not implemented")
 	return []byte("A real app hash, I am not"), nil
 }
 
-func (p PostgresContext) Reset() error {
-	panic("TODO: PostgresContext Reset not implemented")
-}
-
-func (p PostgresContext) Commit() error {
+func (p PostgresContext) Commit(proposerAddr, quorumCert []byte) error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
 	ctx := context.TODO()
diff --git a/persistence/debug.go b/persistence/debug.go
index 3fdc583a4..93c1d4a7e 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -44,7 +44,7 @@ func (m *PersistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 
 func (m *PersistenceModule) clearState(_ *debug.DebugMessage) {
 	context, err := m.NewRWContext(-1)
-	defer context.Commit()
+	defer context.Commit([]byte("DebugProposerAddr"), []byte("DebugQuorumCert"))
 	if err != nil {
 		log.Printf("Error creating new context: %s \n", err)
 		return
diff --git a/persistence/genesis.go b/persistence/genesis.go
index 1c7e82f14..d3bf11433 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -149,7 +149,7 @@ func (m *PersistenceModule) populateGenesisState(state *types.PersistenceGenesis
 		log.Fatalf("an error occurred initializing flags: %s", err.Error())
 	}
 
-	if err = rwContext.Commit(); err != nil {
+	if err = rwContext.Commit([]byte("TODO: GenesisProposer"), []byte("TODO: GenesisQuorumCert")); err != nil {
 		log.Fatalf("an error occurred during commit() on genesis state %s ", err.Error())
 	}
 }
diff --git a/persistence/module.go b/persistence/module.go
index 33bd827bd..571fc9b9b 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -194,7 +194,7 @@ func (m *PersistenceModule) NewReadContext(height int64) (modules.PersistenceRea
 	}, nil
 }
 
-func (m *PersistenceModule) ResetContext() error {
+func (m *PersistenceModule) ReleaseWriteContext() error {
 	if m.writeContext != nil {
 		if !m.writeContext.GetTx().Conn().IsClosed() {
 			if err := m.writeContext.Release(); err != nil {
diff --git a/persistence/test/module_test.go b/persistence/test/module_test.go
index 3bee636c5..c9fecf1fa 100644
--- a/persistence/test/module_test.go
+++ b/persistence/test/module_test.go
@@ -8,9 +8,9 @@ import (
 
 func TestPersistenceContextParallelReadWrite(t *testing.T) {
 	// Cleanup previous contexts
-	testPersistenceMod.ResetContext()
+	testPersistenceMod.ReleaseWriteContext()
 	t.Cleanup(func() {
-		testPersistenceMod.ResetContext()
+		testPersistenceMod.ReleaseWriteContext()
 	})
 
 	// variables for testing
@@ -18,12 +18,14 @@ func TestPersistenceContextParallelReadWrite(t *testing.T) {
 	poolAddress := []byte("address")
 	originalAmount := "15"
 	modifiedAmount := "10"
+	proposerAddr := []byte("placeholderProposerAddr")
+	quorumCert := []byte("placeholderQuorumCert")
 
 	// setup a write context, insert a pool and commit it
 	context, err := testPersistenceMod.NewRWContext(0)
 	require.NoError(t, err)
 	require.NoError(t, context.InsertPool(poolName, poolAddress, originalAmount))
-	require.NoError(t, context.Commit())
+	require.NoError(t, context.Commit(proposerAddr, quorumCert))
 
 	// verify the insert in the previously committed context worked
 	contextA, err := testPersistenceMod.NewRWContext(0)
@@ -53,9 +55,9 @@ func TestPersistenceContextParallelReadWrite(t *testing.T) {
 
 func TestPersistenceContextTwoWritesErrors(t *testing.T) {
 	// Cleanup previous contexts
-	testPersistenceMod.ResetContext()
+	testPersistenceMod.ReleaseWriteContext()
 	t.Cleanup(func() {
-		testPersistenceMod.ResetContext()
+		testPersistenceMod.ReleaseWriteContext()
 	})
 
 	// Opening up first write context succeeds
diff --git a/persistence/test/setup_test.go b/persistence/test/setup_test.go
index 459472cf6..e57e9d8f6 100644
--- a/persistence/test/setup_test.go
+++ b/persistence/test/setup_test.go
@@ -70,7 +70,7 @@ func NewTestPostgresContext(t *testing.T, height int64) *persistence.PostgresCon
 
 	t.Cleanup(func() {
 		require.NoError(t, db.Release())
-		require.NoError(t, testPersistenceMod.ResetContext())
+		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
 	})
 
 	return &db
@@ -91,7 +91,7 @@ func NewFuzzTestPostgresContext(f *testing.F, height int64) *persistence.Postgre
 		if err := db.Release(); err != nil {
 			f.FailNow()
 		}
-		if err := testPersistenceMod.ResetContext(); err != nil {
+		if err := testPersistenceMod.ReleaseWriteContext(); err != nil {
 			f.FailNow()
 		}
 	})
diff --git a/utility/block.go b/utility/block.go
index 1bca5f6c1..1af820efb 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -50,7 +50,7 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 		if err := u.ApplyTransaction(tx); err != nil {
 			return nil, err
 		}
-		if err := u.GetPersistenceContext().StoreTransaction(transactionProtoBytes); err != nil {
+		if err := u.Context.PersistenceRWContext.StoreTransaction(transactionProtoBytes); err != nil {
 			return nil, err
 		}
 
@@ -93,7 +93,7 @@ func (u *UtilityContext) EndBlock(proposer []byte) typesUtil.Error {
 
 func (u *UtilityContext) GetAppHash() ([]byte, typesUtil.Error) {
 	// Get the root hash of the merkle state tree for state consensus integrity
-	appHash, er := u.Context.AppHash()
+	appHash, er := u.Context.UpdateAppHash()
 	if er != nil {
 		return nil, typesUtil.ErrAppHash(er)
 	}
diff --git a/utility/context.go b/utility/context.go
index c3f97f3a8..e014fccdf 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -2,6 +2,7 @@ package utility
 
 import (
 	"encoding/hex"
+
 	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/modules"
 	typesUtil "github.com/pokt-network/pocket/utility/types"
@@ -39,17 +40,14 @@ func (u *UtilityContext) Store() *Context {
 	return u.Context
 }
 
-func (u *UtilityContext) GetPersistenceContext() modules.PersistenceRWContext {
-	return u.Context.PersistenceRWContext
-}
-
-func (u *UtilityContext) CommitPersistenceContext() error {
-	return u.Context.PersistenceRWContext.Commit()
+func (u *UtilityContext) Commit(quorumCert []byte) error {
+	return u.Context.PersistenceRWContext.Commit([]byte("TODO: proposerAddr placeholder"), quorumCert)
 }
 
-func (u *UtilityContext) ReleaseContext() {
+func (u *UtilityContext) Release() error {
 	u.Context.Release()
 	u.Context = nil
+	return nil
 }
 
 func (u *UtilityContext) GetLatestBlockHeight() (int64, typesUtil.Error) {
@@ -101,7 +99,7 @@ func (u *UtilityContext) NewSavePoint(transactionHash []byte) typesUtil.Error {
 }
 
 func (c *Context) Reset() typesUtil.Error {
-	if err := c.PersistenceRWContext.Reset(); err != nil {
+	if err := c.PersistenceRWContext.Release(); err != nil {
 		return typesUtil.ErrResetContext(err)
 	}
 	return nil
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index b59f31bef..cb24dadae 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -2,12 +2,13 @@ package test
 
 import (
 	"encoding/hex"
-	"github.com/pokt-network/pocket/shared/modules"
-	"github.com/pokt-network/pocket/shared/test_artifacts"
 	"math"
 	"math/big"
 	"testing"
 
+	"github.com/pokt-network/pocket/shared/modules"
+	"github.com/pokt-network/pocket/shared/test_artifacts"
+
 	typesUtil "github.com/pokt-network/pocket/utility/types"
 	"github.com/stretchr/testify/require"
 )
@@ -177,7 +178,7 @@ func TestUtilityContext_GetAppHash(t *testing.T) {
 	appHashTest, err := ctx.GetAppHash()
 	require.NoError(t, err)
 
-	appHashSource, er := ctx.Context.AppHash()
+	appHashSource, er := ctx.Context.UpdateAppHash()
 	require.NoError(t, er)
 	require.Equal(t, appHashTest, appHashSource, "unexpected appHash")
 
diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index 083f2dd21..101302a06 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -53,7 +53,7 @@ func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext
 	require.NoError(t, err)
 
 	t.Cleanup(func() {
-		testPersistenceMod.ResetContext()
+		testPersistenceMod.ReleaseWriteContext()
 	})
 
 	return utility.UtilityContext{

From 52ae6660c61c44fe07d032c0d5080f400922bfcf Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 4 Oct 2022 19:52:55 -0700
Subject: [PATCH 072/227] Tests running and mostly passing

---
 consensus/block.go            |  6 ++--
 consensus/hotstuff_handler.go | 55 -----------------------------------
 consensus/module.go           |  8 ++---
 3 files changed, 7 insertions(+), 62 deletions(-)
 delete mode 100644 consensus/hotstuff_handler.go

diff --git a/consensus/block.go b/consensus/block.go
index 74e4f1794..924a5e67d 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -39,7 +39,7 @@ func (m *ConsensusModule) prepareBlockAsLeader() (*typesCons.Block, error) {
 		Height:            int64(m.Height),
 		Hash:              hex.EncodeToString(appHash),
 		NumTxs:            uint32(len(txs)),
-		LastBlockHash:     m.appHash,
+		LastBlockHash:     m.lastAppHash,
 		ProposerAddress:   m.privateKey.Address().Bytes(),
 		QuorumCertificate: []byte("HACK: Temporary placeholder"),
 	}
@@ -112,10 +112,10 @@ func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 
 	if err := m.utilityContext.Release(); err != nil {
 		return err
-	}face
+	}
 	m.utilityContext = nil
 
 	m.lastAppHash = block.BlockHeader.Hash
 
 	return nil
-}
\ No newline at end of file
+}
diff --git a/consensus/hotstuff_handler.go b/consensus/hotstuff_handler.go
deleted file mode 100644
index 274a1b45b..000000000
--- a/consensus/hotstuff_handler.go
+++ /dev/null
@@ -1,55 +0,0 @@
-package consensus
-
-import (
-	typesCons "github.com/pokt-network/pocket/consensus/types"
-)
-
-// DISCUSS: Should these functions return an error?
-type HotstuffMessageHandler interface {
-	HandleNewRoundMessage(*ConsensusModule, *typesCons.HotstuffMessage)
-	HandlePrepareMessage(*ConsensusModule, *typesCons.HotstuffMessage)
-	HandlePrecommitMessage(*ConsensusModule, *typesCons.HotstuffMessage)
-	HandleCommitMessage(*ConsensusModule, *typesCons.HotstuffMessage)
-	HandleDecideMessage(*ConsensusModule, *typesCons.HotstuffMessage)
-}
-
-func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage) error {
-	m.nodeLog(typesCons.DebugHandlingHotstuffMessage(msg))
-
-	step := msg.GetStep()
-
-	// Pacemaker - Liveness & safety checks
-	if err := m.paceMaker.ValidateMessage(msg); err != nil {
-		if m.shouldLogHotstuffDiscardMessage(step) {
-			m.nodeLog(typesCons.WarnDiscardHotstuffMessage(msg, err.Error()))
-		}
-		return err
-	}
-
-	if m.shouldElectNextLeader() {
-		if err := m.electNextLeader(msg); err != nil {
-			return err
-		}
-	}
-
-	// Hotstuff - Handle message
-	if m.isReplica() {
-		replicaHandlers[step](m, msg)
-	}
-	// Note that the leader also acts as a replica, but this logic is implemented in the underlying code.
-	leaderHandlers[step](m, msg)
-
-	return nil
-}
-
-func (m *ConsensusModule) shouldElectNextLeader() bool {
-	// Execute leader election if there is no leader and we are in a new round
-	return m.Step == NewRound && m.LeaderId == nil
-}
-
-func (m *ConsensusModule) shouldLogHotstuffDiscardMessage(step typesCons.HotstuffStep) bool {
-	// If a replica is not a leader for this round, but has already determined a leader,
-	// and continues to receive NewRound messages, we avoid logging the "message discard"
-	// because it creates unnecessary spam.
-	return !(m.LeaderId != nil && !m.isLeader() && step == NewRound)
-}
diff --git a/consensus/module.go b/consensus/module.go
index c6e240d3d..c4a741c2a 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -58,7 +58,7 @@ type ConsensusModule struct {
 	IdToValAddrMap typesCons.IdToValAddrMap // TODO(design): This needs to be updated every time the ValMap is modified
 
 	// Consensus State
-	appHash      string
+	lastAppHash  string
 	validatorMap typesCons.ValidatorMap
 
 	// Module Dependencies
@@ -128,7 +128,7 @@ func Create(configPath, genesisPath string, useRandomPK bool) (modules.Consensus
 		ValAddrToIdMap: valIdMap,
 		IdToValAddrMap: idValMap,
 
-		appHash:      "",
+		lastAppHash:  "",
 		validatorMap: valMap,
 
 		utilityContext:    nil,
@@ -244,7 +244,7 @@ func (m *ConsensusModule) loadPersistedState() error {
 
 	// TODO: Populate the rest of the state from the persistence module: validator set, quorum cert, last block hash, etc...
 	m.Height = uint64(latestHeight) + 1 // +1 because the height of the consensus module is where it is actively participating in consensus
-	m.appHash = string(appHash)
+	m.lastAppHash = string(appHash)
 
 	m.nodeLog(fmt.Sprintf("Starting node at height %d", latestHeight))
 	return nil
@@ -326,7 +326,7 @@ func (m *ConsensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage)
 }
 
 func (m *ConsensusModule) AppHash() string {
-	return m.appHash
+	return m.lastAppHash
 }
 
 func (m *ConsensusModule) CurrentHeight() uint64 {

From 35f1311dd306257633a9fec0c74703678a5fe556 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 6 Oct 2022 12:23:17 -0700
Subject: [PATCH 073/227] Made things work again

---
 consensus/consensus_tests/utils_test.go |  5 ++-
 shared/docs/flows/AppHash.md            | 43 +++++++++++++------------
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 5b9de2bcf..4368cf0c4 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -380,9 +380,8 @@ func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 		ApplyBlock(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
 		Return(appHash, nil).
 		AnyTimes()
-	// utilityContextMock.EXPECT().CommitPersistenceContext().Return(nil).AnyTimes()
-	// utilityContextMock.EXPECT().Release().Return().AnyTimes()
-	// utilityContextMock.EXPECT().GetPersistenceContext().Return(persistenceContextMock).AnyTimes()
+	utilityContextMock.EXPECT().Commit(gomock.Any()).Return(nil).AnyTimes()
+	utilityContextMock.EXPECT().Release().Return(nil).AnyTimes()
 
 	persistenceContextMock.EXPECT().Commit(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
 	persistenceContextMock.EXPECT().StoreTransaction(gomock.Any()).Return(nil).AnyTimes()
diff --git a/shared/docs/flows/AppHash.md b/shared/docs/flows/AppHash.md
index 382ea0023..84d733c61 100644
--- a/shared/docs/flows/AppHash.md
+++ b/shared/docs/flows/AppHash.md
@@ -1,9 +1,12 @@
-# AppHash
+# AppHash <!-- omit in toc -->
+
+- [Context Initialization](#context-initialization)
+- [Block Application](#block-application)
+- [Block Commit](#block-commit)
 
 ## Context Initialization
 
-````mermaid
-sequenceDiagram
+```mermaid
     %% autonumber
     participant N as Node
     participant C as Consensus
@@ -12,23 +15,22 @@ sequenceDiagram
     participant PP as Persistence (PostgresDB)
     participant PM as Persistence (MerkleTree)
     participant P2P as P2P
-
-        %% Should this be P2P?
-        N-->>C: HandleMessage(anypb.Any)
-        critical NewRound Message
-            C->>+U: NewContext(height)
-            U->>P: NewRWContext(height)
-            P->>U: PersistenceRWContext
-            U->>U: Store persistenceContext
-            U->>-C: UtilityContext
-            C->>C: Store utilityContext
-            Note over C, PM: See 'Block Application'
-        end
-        Note over N, P2P: Hotstuff lifecycle
-        N-->>C: HandleMessage(anypb.Any)
-        critical Decide Message
-            Note over C, PM: See 'Block Commit'
-        end
+    %% Should this be P2P?
+    N-->>C: HandleMessage(anypb.Any)
+    critical NewRound Message
+        C->>+U: NewContext(height)
+        U->>P: NewRWContext(height)
+        P->>U: PersistenceRWContext
+        U->>U: Store persistenceContext
+        U->>-C: UtilityContext
+        C->>C: Store utilityContext
+        Note over C, PM: See 'Block Application'
+    end
+    Note over N, P2P: Hotstuff lifecycle
+    N-->>C: HandleMessage(anypb.Any)
+    critical Decide Message
+        Note over C, PM: See 'Block Commit'
+    end
 ```
 
 ## Block Application
@@ -100,4 +102,3 @@ sequenceDiagram
     U->>C: ok
     C->>C: release utilityContext
 ```
-````

From 553024194d3efe057dfe53a84f94e109b458afb2 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 6 Oct 2022 12:29:39 -0700
Subject: [PATCH 074/227] Reverted files that shouldn't be part of the
 interface change

---
 consensus/block.go                      | 31 +++++++++++--------------
 consensus/consensus_tests/utils_test.go |  8 ++++---
 persistence/context.go                  |  8 +++++--
 persistence/debug.go                    |  2 +-
 persistence/genesis.go                  |  2 +-
 persistence/module.go                   |  2 +-
 persistence/test/module_test.go         | 12 ++++------
 persistence/test/setup_test.go          |  4 ++--
 utility/block.go                        |  4 ++--
 utility/context.go                      | 14 ++++++-----
 utility/test/block_test.go              |  7 +++---
 utility/test/module_test.go             |  2 +-
 12 files changed, 49 insertions(+), 47 deletions(-)

diff --git a/consensus/block.go b/consensus/block.go
index a2bcd53cb..a70c6cecc 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -29,11 +29,11 @@ func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 	}
 
 	// Commit and release the context
-	if err := m.utilityContext.Commit(block.BlockHeader.QuorumCertificate); err != nil {
+	if err := m.utilityContext.CommitPersistenceContext(); err != nil {
 		return err
 	}
 
-	m.utilityContext.Release()
+	m.utilityContext.ReleaseContext()
 	m.utilityContext = nil
 
 	m.lastAppHash = block.BlockHeader.Hash
@@ -41,21 +41,18 @@ func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 	return nil
 }
 
-// DISCUSS_IN_THIS_COMMIT(#284): THIS IS A BREAKING CHANGE. Need to figure out how we should handle
-// interface changes like this moving forward. Consider keeping components of the old interface in place
-// and deleting them in a later commit along with the implementation.
 func (m *ConsensusModule) storeBlock(block *typesCons.Block, blockProtoBytes []byte) error {
-	// 	store := m.utilityContext.GetPersistenceContext()
-	// 	// Store in KV Store
-	// 	if err := store.StoreBlock(blockProtoBytes); err != nil {
-	// 		return err
-	// 	}
-
-	// 	// Store in SQL Store
-	// 	header := block.BlockHeader
-	// 	if err := store.InsertBlock(uint64(header.Height), header.Hash, header.ProposerAddress, header.QuorumCertificate); err != nil {
-	// 		return err
-	// 	}
+	store := m.utilityContext.GetPersistenceContext()
+	// Store in KV Store
+	if err := store.StoreBlock(blockProtoBytes); err != nil {
+		return err
+	}
+
+	// Store in SQL Store
+	header := block.BlockHeader
+	if err := store.InsertBlock(uint64(header.Height), header.Hash, header.ProposerAddress, header.QuorumCertificate); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -92,7 +89,7 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 	// Ideally, this should not be called.
 	if m.utilityContext != nil {
 		m.nodeLog(typesCons.NilUtilityContextWarning)
-		m.utilityContext.Release()
+		m.utilityContext.ReleaseContext()
 		m.utilityContext = nil
 	}
 
diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 4368cf0c4..3bda5de07 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -380,11 +380,13 @@ func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 		ApplyBlock(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
 		Return(appHash, nil).
 		AnyTimes()
-	utilityContextMock.EXPECT().Commit(gomock.Any()).Return(nil).AnyTimes()
-	utilityContextMock.EXPECT().Release().Return(nil).AnyTimes()
+	utilityContextMock.EXPECT().CommitPersistenceContext().Return(nil).AnyTimes()
+	utilityContextMock.EXPECT().ReleaseContext().Return().AnyTimes()
+	utilityContextMock.EXPECT().GetPersistenceContext().Return(persistenceContextMock).AnyTimes()
 
-	persistenceContextMock.EXPECT().Commit(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
 	persistenceContextMock.EXPECT().StoreTransaction(gomock.Any()).Return(nil).AnyTimes()
+	persistenceContextMock.EXPECT().StoreBlock(gomock.Any()).Return(nil).AnyTimes()
+	persistenceContextMock.EXPECT().InsertBlock(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes().Return(nil)
 
 	return utilityContextMock
 }
diff --git a/persistence/context.go b/persistence/context.go
index 22bfb1278..fd44e3af1 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -15,12 +15,16 @@ func (p PostgresContext) RollbackToSavePoint(bytes []byte) error {
 	return p.GetTx().Rollback(context.TODO())
 }
 
-func (p PostgresContext) UpdateAppHash() ([]byte, error) {
+func (p PostgresContext) AppHash() ([]byte, error) {
 	log.Println("TODO: AppHash not implemented")
 	return []byte("A real app hash, I am not"), nil
 }
 
-func (p PostgresContext) Commit(proposerAddr, quorumCert []byte) error {
+func (p PostgresContext) Reset() error {
+	panic("TODO: PostgresContext Reset not implemented")
+}
+
+func (p PostgresContext) Commit() error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
 	ctx := context.TODO()
diff --git a/persistence/debug.go b/persistence/debug.go
index 93c1d4a7e..3fdc583a4 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -44,7 +44,7 @@ func (m *PersistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 
 func (m *PersistenceModule) clearState(_ *debug.DebugMessage) {
 	context, err := m.NewRWContext(-1)
-	defer context.Commit([]byte("DebugProposerAddr"), []byte("DebugQuorumCert"))
+	defer context.Commit()
 	if err != nil {
 		log.Printf("Error creating new context: %s \n", err)
 		return
diff --git a/persistence/genesis.go b/persistence/genesis.go
index 4c9a6f895..463f88ff2 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -149,7 +149,7 @@ func (m *PersistenceModule) populateGenesisState(state *types.PersistenceGenesis
 		log.Fatalf("an error occurred initializing flags: %s", err.Error())
 	}
 
-	if err = rwContext.Commit([]byte("TODO: GenesisProposer"), []byte("TODO: GenesisQuorumCert")); err != nil {
+	if err = rwContext.Commit(); err != nil {
 		log.Fatalf("an error occurred during commit() on genesis state %s ", err.Error())
 	}
 }
diff --git a/persistence/module.go b/persistence/module.go
index 571fc9b9b..33bd827bd 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -194,7 +194,7 @@ func (m *PersistenceModule) NewReadContext(height int64) (modules.PersistenceRea
 	}, nil
 }
 
-func (m *PersistenceModule) ReleaseWriteContext() error {
+func (m *PersistenceModule) ResetContext() error {
 	if m.writeContext != nil {
 		if !m.writeContext.GetTx().Conn().IsClosed() {
 			if err := m.writeContext.Release(); err != nil {
diff --git a/persistence/test/module_test.go b/persistence/test/module_test.go
index c9fecf1fa..3bee636c5 100644
--- a/persistence/test/module_test.go
+++ b/persistence/test/module_test.go
@@ -8,9 +8,9 @@ import (
 
 func TestPersistenceContextParallelReadWrite(t *testing.T) {
 	// Cleanup previous contexts
-	testPersistenceMod.ReleaseWriteContext()
+	testPersistenceMod.ResetContext()
 	t.Cleanup(func() {
-		testPersistenceMod.ReleaseWriteContext()
+		testPersistenceMod.ResetContext()
 	})
 
 	// variables for testing
@@ -18,14 +18,12 @@ func TestPersistenceContextParallelReadWrite(t *testing.T) {
 	poolAddress := []byte("address")
 	originalAmount := "15"
 	modifiedAmount := "10"
-	proposerAddr := []byte("placeholderProposerAddr")
-	quorumCert := []byte("placeholderQuorumCert")
 
 	// setup a write context, insert a pool and commit it
 	context, err := testPersistenceMod.NewRWContext(0)
 	require.NoError(t, err)
 	require.NoError(t, context.InsertPool(poolName, poolAddress, originalAmount))
-	require.NoError(t, context.Commit(proposerAddr, quorumCert))
+	require.NoError(t, context.Commit())
 
 	// verify the insert in the previously committed context worked
 	contextA, err := testPersistenceMod.NewRWContext(0)
@@ -55,9 +53,9 @@ func TestPersistenceContextParallelReadWrite(t *testing.T) {
 
 func TestPersistenceContextTwoWritesErrors(t *testing.T) {
 	// Cleanup previous contexts
-	testPersistenceMod.ReleaseWriteContext()
+	testPersistenceMod.ResetContext()
 	t.Cleanup(func() {
-		testPersistenceMod.ReleaseWriteContext()
+		testPersistenceMod.ResetContext()
 	})
 
 	// Opening up first write context succeeds
diff --git a/persistence/test/setup_test.go b/persistence/test/setup_test.go
index ae759da16..56ab81cc4 100644
--- a/persistence/test/setup_test.go
+++ b/persistence/test/setup_test.go
@@ -70,7 +70,7 @@ func NewTestPostgresContext(t *testing.T, height int64) *persistence.PostgresCon
 
 	t.Cleanup(func() {
 		require.NoError(t, db.Release())
-		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
+		require.NoError(t, testPersistenceMod.ResetContext())
 	})
 
 	return &db
@@ -91,7 +91,7 @@ func NewFuzzTestPostgresContext(f *testing.F, height int64) *persistence.Postgre
 		if err := db.Release(); err != nil {
 			f.FailNow()
 		}
-		if err := testPersistenceMod.ReleaseWriteContext(); err != nil {
+		if err := testPersistenceMod.ResetContext(); err != nil {
 			f.FailNow()
 		}
 	})
diff --git a/utility/block.go b/utility/block.go
index 9e723e5e8..7822c4791 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -37,7 +37,7 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 		if err := u.ApplyTransaction(tx); err != nil {
 			return nil, err
 		}
-		if err := u.Context.PersistenceRWContext.StoreTransaction(transactionProtoBytes); err != nil {
+		if err := u.GetPersistenceContext().StoreTransaction(transactionProtoBytes); err != nil {
 			return nil, err
 		}
 
@@ -80,7 +80,7 @@ func (u *UtilityContext) EndBlock(proposer []byte) typesUtil.Error {
 
 func (u *UtilityContext) GetAppHash() ([]byte, typesUtil.Error) {
 	// Get the root hash of the merkle state tree for state consensus integrity
-	appHash, er := u.Context.UpdateAppHash()
+	appHash, er := u.Context.AppHash()
 	if er != nil {
 		return nil, typesUtil.ErrAppHash(er)
 	}
diff --git a/utility/context.go b/utility/context.go
index e014fccdf..c3f97f3a8 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -2,7 +2,6 @@ package utility
 
 import (
 	"encoding/hex"
-
 	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/modules"
 	typesUtil "github.com/pokt-network/pocket/utility/types"
@@ -40,14 +39,17 @@ func (u *UtilityContext) Store() *Context {
 	return u.Context
 }
 
-func (u *UtilityContext) Commit(quorumCert []byte) error {
-	return u.Context.PersistenceRWContext.Commit([]byte("TODO: proposerAddr placeholder"), quorumCert)
+func (u *UtilityContext) GetPersistenceContext() modules.PersistenceRWContext {
+	return u.Context.PersistenceRWContext
+}
+
+func (u *UtilityContext) CommitPersistenceContext() error {
+	return u.Context.PersistenceRWContext.Commit()
 }
 
-func (u *UtilityContext) Release() error {
+func (u *UtilityContext) ReleaseContext() {
 	u.Context.Release()
 	u.Context = nil
-	return nil
 }
 
 func (u *UtilityContext) GetLatestBlockHeight() (int64, typesUtil.Error) {
@@ -99,7 +101,7 @@ func (u *UtilityContext) NewSavePoint(transactionHash []byte) typesUtil.Error {
 }
 
 func (c *Context) Reset() typesUtil.Error {
-	if err := c.PersistenceRWContext.Release(); err != nil {
+	if err := c.PersistenceRWContext.Reset(); err != nil {
 		return typesUtil.ErrResetContext(err)
 	}
 	return nil
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index e9f98939f..7ed4290f2 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -2,13 +2,12 @@ package test
 
 import (
 	"encoding/hex"
+	"github.com/pokt-network/pocket/shared/modules"
+	"github.com/pokt-network/pocket/shared/test_artifacts"
 	"math"
 	"math/big"
 	"testing"
 
-	"github.com/pokt-network/pocket/shared/modules"
-	"github.com/pokt-network/pocket/shared/test_artifacts"
-
 	typesUtil "github.com/pokt-network/pocket/utility/types"
 	"github.com/stretchr/testify/require"
 )
@@ -178,7 +177,7 @@ func TestUtilityContext_GetAppHash(t *testing.T) {
 	appHashTest, err := ctx.GetAppHash()
 	require.NoError(t, err)
 
-	appHashSource, er := ctx.Context.UpdateAppHash()
+	appHashSource, er := ctx.Context.AppHash()
 	require.NoError(t, er)
 	require.Equal(t, appHashTest, appHashSource, "unexpected appHash")
 
diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index fa0ab7783..616c739e4 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -60,7 +60,7 @@ func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext
 	require.NoError(t, err)
 
 	t.Cleanup(func() {
-		testPersistenceMod.ReleaseWriteContext()
+		testPersistenceMod.ResetContext()
 	})
 
 	return utility.UtilityContext{

From ab42525b1d09387aa670fccee81aa6db25b2328d Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 6 Oct 2022 13:58:53 -0700
Subject: [PATCH 075/227] Cleaning up the interface

---
 persistence/context.go               |  8 ++++++++
 persistence/module.go                |  4 ++++
 shared/modules/persistence_module.go | 14 +++++++++++---
 shared/modules/utility_module.go     |  8 ++++++--
 utility/context.go                   | 11 ++++++++++-
 5 files changed, 39 insertions(+), 6 deletions(-)

diff --git a/persistence/context.go b/persistence/context.go
index fd44e3af1..1bd30ed33 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -5,6 +5,14 @@ import (
 	"log"
 )
 
+func (p PostgresContext) UpdateAppHash() ([]byte, error) {
+	panic("INTRODUCE(#284): Add this function in #284 per the interface changes in #252.")
+}
+
+// func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
+// 	panic("INTRODUCE(#284): Add this function in #284 per the interface changes in #252.")
+// }
+
 func (p PostgresContext) NewSavePoint(bytes []byte) error {
 	log.Println("TODO: NewSavePoint not implemented")
 	return nil
diff --git a/persistence/module.go b/persistence/module.go
index 33bd827bd..c56d9eab1 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -194,6 +194,10 @@ func (m *PersistenceModule) NewReadContext(height int64) (modules.PersistenceRea
 	}, nil
 }
 
+func (m *PersistenceModule) ReleaseWriteContext() error {
+	panic("INTRODUCE(#284): Add this function in #284 per the interface changes in #252.")
+}
+
 func (m *PersistenceModule) ResetContext() error {
 	if m.writeContext != nil {
 		if !m.writeContext.GetTx().Conn().IsClosed() {
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index f1f25e1b0..d56bde225 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -41,8 +41,7 @@ type PersistenceRWContext interface {
 // - Add general purpose methods such as `ActorOperation(enum_actor_type, ...)` which can be use like so: `Insert(FISHERMAN, ...)`
 // - Use general purpose parameter methods such as `Set(enum_gov_type, ...)` such as `Set(STAKING_ADJUSTMENT, ...)`
 
-// NOTE: There's not really a use case for a write only interface,
-//       but it abstracts and contrasts nicely against the read only context
+// NOTE: There's not really a use case for a write only interface, but it abstracts and contrasts nicely against the read only context
 type PersistenceWriteContext interface {
 	// Context Operations
 	NewSavePoint([]byte) error
@@ -52,11 +51,20 @@ type PersistenceWriteContext interface {
 
 	// Block / indexer operations
 	UpdateAppHash() ([]byte, error)
+
 	// Commits the current context (height, hash, transactions, etc...) to finality.
-	Commit(proposerAddr []byte, quorumCert []byte) error
+	// Commit(proposerAddr []byte, quorumCert []byte) error // INTRODUCE(#284): Add this function in #284 per the interface changes in #252.
+
 	// Indexes the transaction
 	StoreTransaction(transactionProtoBytes []byte) error // Stores a transaction
 
+	// DEPRECATED(#252): Remove these functions in #284 per the interface changes in #252.
+	StoreBlock(blockProtoBytes []byte) error
+	InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error
+	AppHash() ([]byte, error)
+	Reset() error
+	Commit() error
+
 	// Pool Operations
 	AddPoolAmount(name string, amount string) error
 	SubtractPoolAmount(name string, amount string) error
diff --git a/shared/modules/utility_module.go b/shared/modules/utility_module.go
index 37729fba1..e4d3c4f67 100644
--- a/shared/modules/utility_module.go
+++ b/shared/modules/utility_module.go
@@ -21,8 +21,12 @@ type UtilityContext interface {
 	ApplyBlock(height int64, proposer []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) (appHash []byte, err error)
 
 	// Context operations
-	Release() error
-	Commit(quorumCert []byte) error
+	Release() error                 // INTRODUCE(#284): Add in #284 per the interface changes in #252.
+	Commit(quorumCert []byte) error // INTRODUCE(#284): Add in #284 per the interface changes in #252.
+
+	ReleaseContext()                             // DEPRECATE(#252): Remove in #284 per the interface changes in #252
+	GetPersistenceContext() PersistenceRWContext // DEPRECATE(#252): Remove in #284 per the interface changes in #252
+	CommitPersistenceContext() error             // DEPRECATE(#252): Remove in #284 per the interface changes in #252
 
 	// Validation operations
 	CheckTransaction(tx []byte) error
diff --git a/utility/context.go b/utility/context.go
index c3f97f3a8..029a769b2 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -2,6 +2,7 @@ package utility
 
 import (
 	"encoding/hex"
+
 	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/modules"
 	typesUtil "github.com/pokt-network/pocket/utility/types"
@@ -10,7 +11,7 @@ import (
 type UtilityContext struct {
 	LatestHeight int64
 	Mempool      typesUtil.Mempool
-	Context      *Context // IMPROVE: Consider renmaming to PersistenceContext
+	Context      *Context // IMPROVE: Consider renaming to PersistenceContext
 }
 
 type Context struct {
@@ -52,6 +53,14 @@ func (u *UtilityContext) ReleaseContext() {
 	u.Context = nil
 }
 
+func (u *UtilityContext) Release() error {
+	panic("INTRODUCE(#284): Add in #284 per the interface changes in #252.")
+}
+
+func (u *UtilityContext) Commit(quorumCert []byte) error {
+	panic("INTRODUCE(#284): Add in #284 per the interface changes in #252.")
+}
+
 func (u *UtilityContext) GetLatestBlockHeight() (int64, typesUtil.Error) {
 	height, er := u.Store().GetHeight()
 	if er != nil {

From f9a80ff352b8b423d84eb04f1a233160625c4ce7 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 6 Oct 2022 14:00:55 -0700
Subject: [PATCH 076/227] make develop_test passed

---
 shared/modules/persistence_module.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index d56bde225..07fba607a 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -16,6 +16,7 @@ type PersistenceModule interface {
 	ReleaseWriteContext() error // Only one write context can exist at a time
 
 	// BlockStore interface
+	ResetContext() error // DEPRECATE(#252): Remove in #284 per the interface changes in #252
 	GetBlockStore() kvstore.KVStore
 
 	// Debugging / development only

From 6ead8ce5b9f794e855908d0cdfb7cb1f10fc1c79 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 6 Oct 2022 14:04:03 -0700
Subject: [PATCH 077/227] Replace data | ok with result, err_code

---
 shared/docs/flows/AppHash.md | 23 +++++++++++++----------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/shared/docs/flows/AppHash.md b/shared/docs/flows/AppHash.md
index 84d733c61..e47a2bb2a 100644
--- a/shared/docs/flows/AppHash.md
+++ b/shared/docs/flows/AppHash.md
@@ -7,6 +7,7 @@
 ## Context Initialization
 
 ```mermaid
+sequenceDiagram
     %% autonumber
     participant N as Node
     participant C as Consensus
@@ -15,7 +16,7 @@
     participant PP as Persistence (PostgresDB)
     participant PM as Persistence (MerkleTree)
     participant P2P as P2P
-    %% Should this be P2P?
+
     N-->>C: HandleMessage(anypb.Any)
     critical NewRound Message
         C->>+U: NewContext(height)
@@ -26,8 +27,10 @@
         C->>C: Store utilityContext
         Note over C, PM: See 'Block Application'
     end
+
     Note over N, P2P: Hotstuff lifecycle
     N-->>C: HandleMessage(anypb.Any)
+
     critical Decide Message
         Note over C, PM: See 'Block Commit'
     end
@@ -53,12 +56,12 @@ sequenceDiagram
         loop Update DB: for each operation in tx
             U->>P: ReadOp | WriteOp
             P->>PP: ReadOp | WriteOp
-            PP->>P: data | ok
-            P->>U: data | ok
+            PP->>P: result, err_code
+            P->>U: result, err_code
             U->>U: validate
             U->>P: StoreTransaction(tx)
             P->>P: store locally
-            P->>U: ok
+            P->>U: result, err_code
         end
         U->>+P: UpdateAppHash()
         loop for each protocol actor type
@@ -66,7 +69,7 @@ sequenceDiagram
             PP->>P: actors
             loop Update Tree: for each actor
                 P->>PM: Update(addr, serialized(actor))
-                PM->>P: ok
+                PM->>P: result, err_code
             end
             P->>PM: GetRoot()
             PM->>P: rootHash
@@ -91,14 +94,14 @@ sequenceDiagram
     U->>P: Commit(proposerAddr, quorumCert)
     P->>P: create typesPer.Block
     P->>PP: insertBlock(block)
-    PP->>P: ok
+    PP->>P: result, err_code
     P->>PK: Put(height, block)
-    PK->>P: ok
+    PK->>P: result, err_code
     P->>P: commit tx
-    P->>U: ok
+    P->>U: result, err_code
     U->>P: Release()
-    P->>U: ok
+    P->>U: result, err_code
     C->>U: Release()
-    U->>C: ok
+    U->>C: result, err_code
     C->>C: release utilityContext
 ```

From bf27e105fd707bd71be0a68f7d97cd211111e3ba Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 6 Oct 2022 14:38:07 -0700
Subject: [PATCH 078/227] Split and update the sequence diagrams

---
 persistence/docs/AppHash.md  | 44 +++++++++++++++++++++++++++++
 shared/docs/flows/AppHash.md | 55 +++++++++++++-----------------------
 2 files changed, 64 insertions(+), 35 deletions(-)
 create mode 100644 persistence/docs/AppHash.md

diff --git a/persistence/docs/AppHash.md b/persistence/docs/AppHash.md
new file mode 100644
index 000000000..d8b68d5e3
--- /dev/null
+++ b/persistence/docs/AppHash.md
@@ -0,0 +1,44 @@
+# AppHash <!-- omit in toc -->
+
+## Update State Hash
+
+This flow shows the interaction between the PostgresDB and MerkleTrees to compute the state hash.
+
+```mermaid
+sequenceDiagram
+    participant P as Persistence Module
+    participant PP as Persistence (PostgresDB)
+    participant PM as Persistence (MerkleTree)
+
+    loop for each protocol actor type
+        P->>PP: GetActorsUpdated(height)
+        PP->>P: actors
+        loop update tree for each actor
+            P->>PM: Update(addr, serialized(actor))
+            PM->>P: result, err_code
+        end
+        P->>PM: GetRoot()
+        PM->>P: rootHash
+    end
+    P->>P: stateHash = hash(aggregated(rootHashes))
+```
+
+## Store Block
+
+This flow shows the interaction between the PostgresDB and Key-Value Store to compute the state hash.
+
+```mermaid
+sequenceDiagram
+    %% autonumber
+    participant P as Persistence
+    participant PP as Persistence (PostgresDB)
+    participant PK as Persistence (Key-Value Store)
+
+    P->>P: reap stored transactions
+    P->>P: create & serialize<br>`typesPer.Block`
+    P->>PP: insertBlock(height, serialized(block))
+    PP->>P: result, err_code
+    P->>PK: Put(height, serialized(block))
+    PK->>P: result, err_code
+
+```
diff --git a/shared/docs/flows/AppHash.md b/shared/docs/flows/AppHash.md
index e47a2bb2a..1e8eceb9f 100644
--- a/shared/docs/flows/AppHash.md
+++ b/shared/docs/flows/AppHash.md
@@ -6,6 +6,8 @@
 
 ## Context Initialization
 
+This flow shows the process of context initialization between all the modules requirer to apply a block and compute a state hash during the consensus lifecycle.
+
 ```mermaid
 sequenceDiagram
     %% autonumber
@@ -13,8 +15,6 @@ sequenceDiagram
     participant C as Consensus
     participant U as Utility
     participant P as Persistence
-    participant PP as Persistence (PostgresDB)
-    participant PM as Persistence (MerkleTree)
     participant P2P as P2P
 
     N-->>C: HandleMessage(anypb.Any)
@@ -22,17 +22,17 @@ sequenceDiagram
         C->>+U: NewContext(height)
         U->>P: NewRWContext(height)
         P->>U: PersistenceRWContext
-        U->>U: Store persistenceContext
+        U->>U: store context<br>locally
         U->>-C: UtilityContext
-        C->>C: Store utilityContext
-        Note over C, PM: See 'Block Application'
+        C->>C: store context<br>locally
+        Note over C, P: See 'Block Application'
     end
 
     Note over N, P2P: Hotstuff lifecycle
     N-->>C: HandleMessage(anypb.Any)
 
     critical Decide Message
-        Note over C, PM: See 'Block Commit'
+        Note over C, P: See 'Block Commit'
     end
 ```
 
@@ -43,43 +43,31 @@ sequenceDiagram
     participant C as Consensus
     participant U as Utility
     participant P as Persistence
-    participant PP as Persistence (PostgresDB)
-    participant PM as Persistence (MerkleTree)
 
     alt as leader
         C->>+U: GetProposalTransactions(proposer, maxTxBz, [lastVal])
         U->>U: reap mempool
         U->>-C: txs
-        Note over C, U: Perform replica behaviour
+        Note over C, U: fallthrough to replica behaviour
     else as replica
         C->>+U: ApplyBlock(height, proposer, txs, lastVals)
-        loop Update DB: for each operation in tx
-            U->>P: ReadOp | WriteOp
-            P->>PP: ReadOp | WriteOp
-            PP->>P: result, err_code
+        loop for each operation in tx
+            U->>P: Get*/Set*
             P->>U: result, err_code
-            U->>U: validate
+            U->>U: validation<br>logic
             U->>P: StoreTransaction(tx)
-            P->>P: store locally
+            P->>P: store tx<br>locally
             P->>U: result, err_code
         end
         U->>+P: UpdateAppHash()
-        loop for each protocol actor type
-            P->>PP: GetActorsUpdate(height)
-            PP->>P: actors
-            loop Update Tree: for each actor
-                P->>PM: Update(addr, serialized(actor))
-                PM->>P: result, err_code
-            end
-            P->>PM: GetRoot()
-            PM->>P: rootHash
-        end
-        P->>P: computeStateHash(rootHashes)
+        Note over P: Update State Hash
         P->>-U: stateHash
-        U->>-C: hash
+        U->>-C: stateHash
     end
 ```
 
+The [V1 Persistence Specification](https://github.com/pokt-network/pocket-network-protocol/tree/main/persistence) outlines the use of a **PostgresDB** and **Merkle Trees** to implement the `Update State Hash` component. This is an internal detail which can be done differently depending on the implementation. For the core V1 implementation, see the flows outlined [here](../../../persistence/docs/AppHash.md).
+
 ## Block Commit
 
 ```mermaid
@@ -88,16 +76,11 @@ sequenceDiagram
     participant C as Consensus
     participant U as Utility
     participant P as Persistence
-    participant PP as Persistence (PostgresDB)
-    participant PK as Persistence (Key-Value Store)
+
     C->>U: CommitContext(quorumCert)
     U->>P: Commit(proposerAddr, quorumCert)
-    P->>P: create typesPer.Block
-    P->>PP: insertBlock(block)
-    PP->>P: result, err_code
-    P->>PK: Put(height, block)
-    PK->>P: result, err_code
-    P->>P: commit tx
+    P->>P: reap stored transactions
+    Note over P: Create And Store Block
     P->>U: result, err_code
     U->>P: Release()
     P->>U: result, err_code
@@ -105,3 +88,5 @@ sequenceDiagram
     U->>C: result, err_code
     C->>C: release utilityContext
 ```
+
+The [V1 Persistence Specification](https://github.com/pokt-network/pocket-network-protocol/tree/main/persistence) outlines the use of a **key-value store** to implement the `Create And Store Block` component. This is an internal detail which can be done differently depending on the implementation. For the core V1 implementation, see the flows outlined [here](../../../persistence/docs/AppHash.md).

From e69456a8f8f7f1a7ce589200b7bc28ece2d62434 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 6 Oct 2022 14:45:05 -0700
Subject: [PATCH 079/227] Update TODO keyword

---
 Makefile | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index 2f583bdff..5088ba9a3 100644
--- a/Makefile
+++ b/Makefile
@@ -354,9 +354,10 @@ benchmark_p2p_addrbook:
 # CONSIDERATION - A comment that involves extra work but was thoughts / considered as part of some implementation
 # CONSOLIDATE   - We likely have similar implementations/types of the same thing, and we should consolidate them.
 # DEPRECATE     - Code that should be removed in the future
+# INTRODUCE     - Code that should be introduced in the future
 # DISCUSS_IN_THIS_COMMIT - SHOULD NEVER BE COMMITTED TO MASTER. It is a way for the reviewer of a PR to start / reply to a discussion.
 # TODO_IN_THIS_COMMIT    - SHOULD NEVER BE COMMITTED TO MASTER. It is a way to start the review process while non-critical changes are still in progress
-TODO_KEYWORDS = -e "TODO" -e "TECHDEBT" -e "IMPROVE" -e "DISCUSS" -e "INCOMPLETE" -e "INVESTIGATE" -e "CLEANUP" -e "HACK" -e "REFACTOR" -e "CONSIDERATION" -e "TODO_IN_THIS_COMMIT" -e "DISCUSS_IN_THIS_COMMIT" -e "CONSOLIDATE" -e "DEPRECATE"
+TODO_KEYWORDS = -e "TODO" -e "TECHDEBT" -e "IMPROVE" -e "DISCUSS" -e "INCOMPLETE" -e "INVESTIGATE" -e "CLEANUP" -e "HACK" -e "REFACTOR" -e "CONSIDERATION" -e "TODO_IN_THIS_COMMIT" -e "DISCUSS_IN_THIS_COMMIT" -e "CONSOLIDATE" -e "DEPRECATE" -e "INTRODUCE"
 
 # How do I use TODOs?
 # 1. <KEYWORD>: <Description of follow up work>;

From 2760dc4ca7e71f03c49ba62e71313ca5c0c912fb Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 6 Oct 2022 15:28:57 -0700
Subject: [PATCH 080/227] make develop_test passed

---
 consensus/block.go                      |  7 +++++--
 consensus/consensus_tests/utils_test.go |  8 +++-----
 persistence/context.go                  | 12 ------------
 persistence/debug.go                    |  2 +-
 persistence/genesis.go                  |  2 +-
 persistence/module.go                   |  4 ----
 persistence/test/module_test.go         | 12 +++++++-----
 persistence/test/setup_test.go          |  4 ++--
 shared/modules/persistence_module.go    | 10 +---------
 shared/modules/utility_module.go        |  8 ++------
 utility/block.go                        |  7 ++++---
 utility/context.go                      | 21 +++++----------------
 utility/test/module_test.go             |  2 +-
 13 files changed, 32 insertions(+), 67 deletions(-)

diff --git a/consensus/block.go b/consensus/block.go
index 3a4629ec9..af78a29a7 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -11,7 +11,7 @@ func (m *ConsensusModule) commitBlock(block *typesCons.Block) error {
 	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
 
 	// Commit and release the context
-	if err := m.utilityContext.CommitPersistenceContext(); err != nil {
+	if err := m.utilityContext.Commit(block.BlockHeader.QuorumCertificate); err != nil {
 		return err
 	}
 
@@ -58,8 +58,11 @@ func (m *ConsensusModule) refreshUtilityContext() error {
 	// Ideally, this should not be called.
 	if m.utilityContext != nil {
 		m.nodeLog(typesCons.NilUtilityContextWarning)
-		m.utilityContext.ReleaseContext()
+		err := m.utilityContext.Release()
 		m.utilityContext = nil
+		if err != nil {
+			return err
+		}
 	}
 
 	utilityContext, err := m.GetBus().GetUtilityModule().NewContext(int64(m.Height))
diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 3bda5de07..e4501b136 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -380,13 +380,11 @@ func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 		ApplyBlock(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
 		Return(appHash, nil).
 		AnyTimes()
-	utilityContextMock.EXPECT().CommitPersistenceContext().Return(nil).AnyTimes()
-	utilityContextMock.EXPECT().ReleaseContext().Return().AnyTimes()
-	utilityContextMock.EXPECT().GetPersistenceContext().Return(persistenceContextMock).AnyTimes()
+	utilityContextMock.EXPECT().Commit(gomock.Any()).Return(nil).AnyTimes()
+	utilityContextMock.EXPECT().Release().Return(nil).AnyTimes()
 
 	persistenceContextMock.EXPECT().StoreTransaction(gomock.Any()).Return(nil).AnyTimes()
-	persistenceContextMock.EXPECT().StoreBlock(gomock.Any()).Return(nil).AnyTimes()
-	persistenceContextMock.EXPECT().InsertBlock(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes().Return(nil)
+	persistenceContextMock.EXPECT().Release().Return(nil).AnyTimes()
 
 	return utilityContextMock
 }
diff --git a/persistence/context.go b/persistence/context.go
index 062337447..c38237dfd 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -5,14 +5,6 @@ import (
 	"log"
 )
 
-func (p PostgresContext) UpdateAppHash() ([]byte, error) {
-	panic("INTRODUCE(#284): Add this function in #284 per the interface changes in #252.")
-}
-
-// func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
-// 	panic("INTRODUCE(#284): Add this function in #284 per the interface changes in #252.")
-// }
-
 func (p PostgresContext) NewSavePoint(bytes []byte) error {
 	log.Println("TODO: NewSavePoint not implemented")
 	return nil
@@ -31,10 +23,6 @@ func (p PostgresContext) UpdateAppHash() ([]byte, error) {
 	return p.stateHash, nil
 }
 
-func (p PostgresContext) Reset() error {
-	panic("TODO: PostgresContext Reset not implemented")
-}
-
 func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
diff --git a/persistence/debug.go b/persistence/debug.go
index 3fdc583a4..287148a6f 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -44,7 +44,7 @@ func (m *PersistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 
 func (m *PersistenceModule) clearState(_ *debug.DebugMessage) {
 	context, err := m.NewRWContext(-1)
-	defer context.Commit()
+	defer context.Commit([]byte("HACK: debugClearStateProposerPlaceholder"), []byte("HACK: debugClearStateQuorumCertPlaceholder"))
 	if err != nil {
 		log.Printf("Error creating new context: %s \n", err)
 		return
diff --git a/persistence/genesis.go b/persistence/genesis.go
index 2ae09ec34..fb19f5c7b 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -149,7 +149,7 @@ func (m *PersistenceModule) populateGenesisState(state *types.PersistenceGenesis
 		log.Fatalf("an error occurred initializing flags: %s", err.Error())
 	}
 
-	if err = rwContext.Commit(); err != nil {
+	if err = rwContext.Commit([]byte("HACK: genesisProposerPlaceholder"), []byte("HACK: genesisQuorumCertPlaceholder")); err != nil {
 		log.Fatalf("an error occurred during commit() on genesis state %s ", err.Error())
 	}
 }
diff --git a/persistence/module.go b/persistence/module.go
index 0dc352c85..52fdb4adb 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -218,10 +218,6 @@ func (m *PersistenceModule) NewReadContext(height int64) (modules.PersistenceRea
 }
 
 func (m *PersistenceModule) ReleaseWriteContext() error {
-	panic("INTRODUCE(#284): Add this function in #284 per the interface changes in #252.")
-}
-
-func (m *PersistenceModule) ResetContext() error {
 	if m.writeContext != nil {
 		if !m.writeContext.GetTx().Conn().IsClosed() {
 			if err := m.writeContext.Release(); err != nil {
diff --git a/persistence/test/module_test.go b/persistence/test/module_test.go
index 3bee636c5..6f5252872 100644
--- a/persistence/test/module_test.go
+++ b/persistence/test/module_test.go
@@ -8,9 +8,9 @@ import (
 
 func TestPersistenceContextParallelReadWrite(t *testing.T) {
 	// Cleanup previous contexts
-	testPersistenceMod.ResetContext()
+	testPersistenceMod.ReleaseWriteContext()
 	t.Cleanup(func() {
-		testPersistenceMod.ResetContext()
+		testPersistenceMod.ReleaseWriteContext()
 	})
 
 	// variables for testing
@@ -18,12 +18,14 @@ func TestPersistenceContextParallelReadWrite(t *testing.T) {
 	poolAddress := []byte("address")
 	originalAmount := "15"
 	modifiedAmount := "10"
+	proposerAddr := []byte("proposerAddr")
+	quorumCert := []byte("quorumCert")
 
 	// setup a write context, insert a pool and commit it
 	context, err := testPersistenceMod.NewRWContext(0)
 	require.NoError(t, err)
 	require.NoError(t, context.InsertPool(poolName, poolAddress, originalAmount))
-	require.NoError(t, context.Commit())
+	require.NoError(t, context.Commit(proposerAddr, quorumCert))
 
 	// verify the insert in the previously committed context worked
 	contextA, err := testPersistenceMod.NewRWContext(0)
@@ -53,9 +55,9 @@ func TestPersistenceContextParallelReadWrite(t *testing.T) {
 
 func TestPersistenceContextTwoWritesErrors(t *testing.T) {
 	// Cleanup previous contexts
-	testPersistenceMod.ResetContext()
+	testPersistenceMod.ReleaseWriteContext()
 	t.Cleanup(func() {
-		testPersistenceMod.ResetContext()
+		testPersistenceMod.ReleaseWriteContext()
 	})
 
 	// Opening up first write context succeeds
diff --git a/persistence/test/setup_test.go b/persistence/test/setup_test.go
index 56ab81cc4..ae759da16 100644
--- a/persistence/test/setup_test.go
+++ b/persistence/test/setup_test.go
@@ -70,7 +70,7 @@ func NewTestPostgresContext(t *testing.T, height int64) *persistence.PostgresCon
 
 	t.Cleanup(func() {
 		require.NoError(t, db.Release())
-		require.NoError(t, testPersistenceMod.ResetContext())
+		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
 	})
 
 	return &db
@@ -91,7 +91,7 @@ func NewFuzzTestPostgresContext(f *testing.F, height int64) *persistence.Postgre
 		if err := db.Release(); err != nil {
 			f.FailNow()
 		}
-		if err := testPersistenceMod.ResetContext(); err != nil {
+		if err := testPersistenceMod.ReleaseWriteContext(); err != nil {
 			f.FailNow()
 		}
 	})
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index ce28f08ee..e4dd5385c 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -16,7 +16,6 @@ type PersistenceModule interface {
 	ReleaseWriteContext() error // Only one write context can exist at a time
 
 	// BlockStore interface
-	ResetContext() error // DEPRECATE(#252): Remove in #284 per the interface changes in #252
 	GetBlockStore() kvstore.KVStore
 
 	// Debugging / development only
@@ -54,18 +53,11 @@ type PersistenceWriteContext interface {
 	UpdateAppHash() ([]byte, error)
 
 	// Commits the current context (height, hash, transactions, etc...) to finality.
-	// Commit(proposerAddr []byte, quorumCert []byte) error // INTRODUCE(#284): Add this function in #284 per the interface changes in #252.
+	Commit(proposerAddr []byte, quorumCert []byte) error
 
 	// Indexes the transaction
 	StoreTransaction(transactionProtoBytes []byte) error // Stores a transaction
 
-	// DEPRECATED(#252): Remove these functions in #284 per the interface changes in #252.
-	StoreBlock(blockProtoBytes []byte) error
-	InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error
-	AppHash() ([]byte, error)
-	Reset() error
-	Commit() error
-
 	// Pool Operations
 	AddPoolAmount(name string, amount string) error
 	SubtractPoolAmount(name string, amount string) error
diff --git a/shared/modules/utility_module.go b/shared/modules/utility_module.go
index e4d3c4f67..37729fba1 100644
--- a/shared/modules/utility_module.go
+++ b/shared/modules/utility_module.go
@@ -21,12 +21,8 @@ type UtilityContext interface {
 	ApplyBlock(height int64, proposer []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) (appHash []byte, err error)
 
 	// Context operations
-	Release() error                 // INTRODUCE(#284): Add in #284 per the interface changes in #252.
-	Commit(quorumCert []byte) error // INTRODUCE(#284): Add in #284 per the interface changes in #252.
-
-	ReleaseContext()                             // DEPRECATE(#252): Remove in #284 per the interface changes in #252
-	GetPersistenceContext() PersistenceRWContext // DEPRECATE(#252): Remove in #284 per the interface changes in #252
-	CommitPersistenceContext() error             // DEPRECATE(#252): Remove in #284 per the interface changes in #252
+	Release() error
+	Commit(quorumCert []byte) error
 
 	// Validation operations
 	CheckTransaction(tx []byte) error
diff --git a/utility/block.go b/utility/block.go
index 4b4540018..51bbb4f49 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -1,9 +1,10 @@
 package utility
 
 import (
+	"math/big"
+
 	"github.com/pokt-network/pocket/shared/modules"
 	typesUtil "github.com/pokt-network/pocket/utility/types"
-	"math/big"
 )
 
 /*
@@ -39,7 +40,7 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 		if err := u.ApplyTransaction(tx); err != nil {
 			return nil, err
 		}
-		if err := u.GetPersistenceContext().StoreTransaction(transactionProtoBytes); err != nil {
+		if err := u.Store().StoreTransaction(transactionProtoBytes); err != nil {
 			return nil, err
 		}
 
@@ -90,7 +91,7 @@ func (u *UtilityContext) EndBlock(proposer []byte) typesUtil.Error {
 
 func (u *UtilityContext) GetAppHash() ([]byte, typesUtil.Error) {
 	// Get the root hash of the merkle state tree for state consensus integrity
-	appHash, er := u.Context.AppHash()
+	appHash, er := u.Context.UpdateAppHash()
 	if er != nil {
 		return nil, typesUtil.ErrAppHash(er)
 	}
diff --git a/utility/context.go b/utility/context.go
index 1df58d5ef..88518e6d9 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -44,25 +44,14 @@ func (u *UtilityContext) Store() *Context {
 	return u.Context
 }
 
-func (u *UtilityContext) GetPersistenceContext() modules.PersistenceRWContext {
-	return u.Context.PersistenceRWContext
-}
-
-func (u *UtilityContext) CommitPersistenceContext() error {
-	return u.Context.PersistenceRWContext.Commit()
-}
-
-func (u *UtilityContext) ReleaseContext() {
-	u.Context.Release()
-	u.Context = nil
-}
-
 func (u *UtilityContext) Release() error {
-	panic("INTRODUCE(#284): Add in #284 per the interface changes in #252.")
+	err := u.Context.Release()
+	u.Context = nil
+	return err
 }
 
 func (u *UtilityContext) Commit(quorumCert []byte) error {
-	panic("INTRODUCE(#284): Add in #284 per the interface changes in #252.")
+	return nil
 }
 
 func (u *UtilityContext) GetLatestBlockHeight() (int64, typesUtil.Error) {
@@ -114,7 +103,7 @@ func (u *UtilityContext) NewSavePoint(transactionHash []byte) typesUtil.Error {
 }
 
 func (c *Context) Reset() typesUtil.Error {
-	if err := c.PersistenceRWContext.Reset(); err != nil {
+	if err := c.PersistenceRWContext.Release(); err != nil {
 		return typesUtil.ErrResetContext(err)
 	}
 	return nil
diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index 616c739e4..fa0ab7783 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -60,7 +60,7 @@ func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext
 	require.NoError(t, err)
 
 	t.Cleanup(func() {
-		testPersistenceMod.ResetContext()
+		testPersistenceMod.ReleaseWriteContext()
 	})
 
 	return utility.UtilityContext{

From c35f9db66ead4022d183431d13ba5ed1787a2305 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 6 Oct 2022 16:39:47 -0700
Subject: [PATCH 081/227] Things kind of linking together

---
 consensus/types/block.go             |  14 ---
 persistence/StateHash.md             | 104 +--------------------
 persistence/application.go           |  47 ----------
 persistence/block.go                 |  25 +++---
 persistence/context.go               |   4 +-
 persistence/db.go                    |  22 ++---
 persistence/module.go                |  15 ++--
 persistence/state.go                 | 129 ++++++++++++++++++++-------
 persistence/types/base_actor.go      |   2 +-
 shared/docs/flows/README.md          |   3 +
 shared/modules/persistence_module.go |  47 ----------
 shared/types/genesis/validator.go    |  49 ----------
 utility/block.go                     |   2 +-
 utility/context.go                   |   9 +-
 14 files changed, 144 insertions(+), 328 deletions(-)
 delete mode 100644 consensus/types/block.go
 create mode 100644 shared/docs/flows/README.md
 delete mode 100644 shared/types/genesis/validator.go

diff --git a/consensus/types/block.go b/consensus/types/block.go
deleted file mode 100644
index f6091b6b3..000000000
--- a/consensus/types/block.go
+++ /dev/null
@@ -1,14 +0,0 @@
-package types
-
-import (
-	"github.com/pokt-network/pocket/shared/codec"
-)
-
-func (b *Block) Bytes() ([]byte, error) {
-	codec := codec.GetCodec()
-	blockProtoBz, err := codec.Marshal(b)
-	if err != nil {
-		return nil, err
-	}
-	return blockProtoBz, nil
-}
diff --git a/persistence/StateHash.md b/persistence/StateHash.md
index cfc54af52..24f1d2e65 100644
--- a/persistence/StateHash.md
+++ b/persistence/StateHash.md
@@ -1,4 +1,4 @@
-Remaining tasks:
+DO NOT READ YET
 
 1.  Simplify interfaces in utility & persistence (make it simple and clear)
 2.  How do we revert changes to the merkle trees?
@@ -90,105 +90,3 @@ Learnings / Ideas:
 
 - Consolidate `UtilActorType` and `persistence.ActorType`
 - `modules.Actors` interface vs `types.Actor` in persistenceGenesis
-
-### Context Initialization
-
-```mermaid
-sequenceDiagram
-    %% autonumber
-    participant N as Node
-    participant C as Consensus
-    participant U as Utility
-    participant P as Persistence
-    participant PP as Persistence (PostgresDB)
-    participant PM as Persistence (MerkleTree)
-    participant P2P as P2P
-
-    %% Should this be P2P?
-    N-->>C: HandleMessage(anypb.Any)
-    critical NewRound Message
-        C->>+U: NewContext(height)
-        U->>P: NewRWContext(height)
-        P->>U: PersistenceRWContext
-        U->>U: Store persistenceContext
-        U->>-C: UtilityContext
-        C->>C: Store utilityContext
-        Note over C, PM: See 'Block Application'
-    end
-    Note over N, P2P: Hotstuff lifecycle
-    N-->>C: HandleMessage(anypb.Any)
-    critical Decide Message
-        Note over C, PM: See 'Block Commit'
-    end
-```
-
-### Block Application
-
-```mermaid
-sequenceDiagram
-    participant C as Consensus
-    participant U as Utility
-    participant P as Persistence
-    participant PP as Persistence (PostgresDB)
-    participant PM as Persistence (MerkleTree)
-
-    alt as leader
-        C->>+U: GetProposalTransactions(proposer, maxTxBz, [lastVal])
-        U->>U: reap mempool
-        U->>-C: txs
-        Note over C, U: Perform replica behaviour
-    else as replica
-        C->>+U: ApplyBlock(height, proposer, txs, lastVals)
-        loop Update DB: for each operation in tx
-            U->>P: ReadOp | WriteOp
-            P->>PP: ReadOp | WriteOp
-            PP->>P: data | ok
-            P->>U: data | ok
-            U->>U: validate
-            U->>P: StoreTransaction(tx)
-            P->>P: store locally
-            P->>U: ok
-        end
-        U->>+P: UpdateAppHash()
-        loop for each protocol actor type
-            P->>PP: GetActorsUpdate(height)
-            PP->>P: actors
-            loop Update Tree: for each actor
-                P->>PM: Update(addr, serialized(actor))
-                PM->>P: ok
-            end
-            P->>PM: GetRoot()
-            PM->>P: rootHash
-        end
-        P->>P: computeStateHash(rootHashes)
-        P->>-U: stateHash
-        U->>-C: hash
-    end
-```
-
-### Block Commit
-
-```mermaid
-sequenceDiagram
-    %% autonumber
-    participant C as Consensus
-    participant U as Utility
-    participant P as Persistence
-    participant PP as Persistence (PostgresDB)
-    participant PK as Persistence (Key-Value Store)
-
-    C->>U: CommitContext(quorumCert)
-    U->>P: Commit(proposerAddr, quorumCert)
-    P->>P: create typesPer.Block
-    P->>PP: insertBlock(block)
-    PP->>P: ok
-    P->>PK: Put(height, block)
-    PK->>P: ok
-    P->>P: commit tx
-    P->>U: ok
-    U->>P: Release()
-    P->>U: ok
-    C->>U: Release()
-    U->>C: ok
-    C->>C: release utilityContext
-```
diff --git a/persistence/application.go b/persistence/application.go
index 29624de82..59683c7eb 100644
--- a/persistence/application.go
+++ b/persistence/application.go
@@ -5,57 +5,10 @@ import (
 	"log"
 
 	"github.com/pokt-network/pocket/persistence/types"
-	"google.golang.org/protobuf/proto"
 
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
-func (p PostgresContext) UpdateApplicationsTree(apps []modules.Actor) error {
-	for _, app := range apps {
-		bzAddr, err := hex.DecodeString(app.GetAddress())
-		if err != nil {
-			return err
-		}
-
-		appBz, err := proto.Marshal(app.(*types.Actor))
-		if err != nil {
-			return err
-		}
-
-		// OPTIMIZE: This is the only line unique to `Application`
-		if _, err := p.MerkleTrees[appMerkleTree].Update(bzAddr, appBz); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (p PostgresContext) getApplicationsUpdatedAtHeight(height int64) (apps []*types.Actor, err error) {
-	// OPTIMIZE: This is the only line unique to `Application`
-	actors, err := p.GetActorsUpdated(types.ApplicationActor, height)
-	if err != nil {
-		return nil, err
-	}
-
-	apps = make([]*types.Actor, len(actors))
-	for _, actor := range actors {
-		app := &types.Actor{
-			ActorType:       types.ActorType_App,
-			Address:         actor.Address,
-			PublicKey:       actor.PublicKey,
-			Chains:          actor.Chains,
-			GenericParam:    actor.ActorSpecificParam,
-			StakedAmount:    actor.StakedTokens,
-			PausedHeight:    actor.PausedHeight,
-			UnstakingHeight: actor.UnstakingHeight,
-			Output:          actor.OutputAddress,
-		}
-		apps = append(apps, app)
-	}
-	return
-}
-
 func (p PostgresContext) GetAppExists(address []byte, height int64) (exists bool, err error) {
 	return p.GetExists(types.ApplicationActor, address, height)
 }
diff --git a/persistence/block.go b/persistence/block.go
index 5efa1b71e..c3e6ca92a 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -46,7 +46,7 @@ func (p PostgresContext) TransactionExists(transactionHash string) (bool, error)
 }
 
 func (p PostgresContext) StoreTransaction(transactionProtoBytes []byte) error {
-	log.Println("TODO: StoreTransaction not implemented")
+	p.currentBlockTxs = append(p.currentBlockTxs, transactionProtoBytes)
 	return nil
 }
 
@@ -62,29 +62,32 @@ func (p PostgresContext) insertBlock(block *types.Block) error {
 
 func (p PostgresContext) storeBlock(block *types.Block) error {
 	blockBz, err := proto.Marshal(block)
+
 	if err != nil {
 		return err
 	}
-
-	return p.blockstore.Put(heightToBytes(p.Height), blockBz)
+	return p.blockStore.Put(heightToBytes(p.Height), blockBz)
 }
 
 func (p PostgresContext) getBlock(proposerAddr []byte, quorumCert []byte) (*types.Block, error) {
-	prevHash, err := p.GetBlockHash(p.Height - 1)
-	if err != nil {
-		return nil, err
+	var prevHash []byte
+	if p.Height > 0 {
+		var err error
+		prevHash, err = p.GetBlockHash(p.Height - 1)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		prevHash = []byte("HACK: get hash from genesis")
 	}
 
-	// TODO: get this from the transactions that were store via `StoreTransaction`
-	txs := make([][]byte, 0)
-
 	block := &types.Block{
 		Height:            uint64(p.Height),
-		Hash:              string(p.stateHash),
+		Hash:              string(p.currentStateHash),
 		PrevHash:          string(prevHash),
 		ProposerAddress:   proposerAddr,
 		QuorumCertificate: quorumCert,
-		Transactions:      txs,
+		Transactions:      p.currentBlockTxs,
 	}
 
 	return block, nil
diff --git a/persistence/context.go b/persistence/context.go
index c38237dfd..5492ce475 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -16,11 +16,10 @@ func (p PostgresContext) RollbackToSavePoint(bytes []byte) error {
 }
 
 func (p PostgresContext) UpdateAppHash() ([]byte, error) {
-
 	if err := p.updateStateHash(); err != nil {
 		return nil, err
 	}
-	return p.stateHash, nil
+	return p.currentStateHash, nil
 }
 
 func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
@@ -30,7 +29,6 @@ func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
 	if err != nil {
 		return err
 	}
-
 	if err := p.insertBlock(block); err != nil {
 		return err
 	}
diff --git a/persistence/db.go b/persistence/db.go
index b8a974939..ff9b673cf 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -37,17 +37,17 @@ var protocolActorSchemas = []types.ProtocolActorSchema{
 var _ modules.PersistenceRWContext = &PostgresContext{}
 
 type PostgresContext struct {
-	Height     int64 // TODO(olshansky): `Height` is only externalized for testing purposes. Replace with helpers...
-	conn       *pgx.Conn
-	tx         pgx.Tx
-	blockstore kvstore.KVStore
-
-	stateHash []byte
-	// IMPROVE: Depending on how the use of `PostgresContext` evolves, we may be able to get
-	// access to these directly via the postgres module.
-	PostgresDB  *pgx.Conn
-	BlockStore  kvstore.KVStore                      // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context)
-	MerkleTrees map[MerkleTree]*smt.SparseMerkleTree // REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context)
+	Height int64 // TODO(olshansky): `Height` is only externalized for testing purposes. Replace with helpers...
+	conn   *pgx.Conn
+	tx     pgx.Tx
+
+	currentBlockTxs  [][]byte
+	currentStateHash []byte
+
+	// REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context).
+	// Consider making this accessible via the persistence module interface and accessing it via the bus.
+	blockStore  kvstore.KVStore
+	merkleTrees map[MerkleTree]*smt.SparseMerkleTree
 }
 
 func (pg *PostgresContext) GetCtxAndTx() (context.Context, pgx.Tx, error) {
diff --git a/persistence/module.go b/persistence/module.go
index 52fdb4adb..1d1454679 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -185,10 +185,15 @@ func (m *PersistenceModule) NewRWContext(height int64) (modules.PersistenceRWCon
 	}
 
 	m.writeContext = &PostgresContext{
-		Height:     height,
-		conn:       conn,
-		tx:         tx,
-		blockstore: m.blockStore,
+		Height: height,
+		conn:   conn,
+		tx:     tx,
+
+		currentBlockTxs:  make([][]byte, 0),
+		currentStateHash: make([]byte, 0),
+
+		blockStore:  m.blockStore,
+		merkleTrees: m.trees,
 	}
 
 	return *m.writeContext, nil
@@ -213,7 +218,7 @@ func (m *PersistenceModule) NewReadContext(height int64) (modules.PersistenceRea
 		Height:     height,
 		conn:       conn,
 		tx:         tx,
-		blockstore: m.blockStore,
+		blockStore: m.blockStore,
 	}, nil
 }
 
diff --git a/persistence/state.go b/persistence/state.go
index 5c3913140..0d596d124 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -9,7 +9,7 @@ import (
 	"sort"
 
 	"github.com/celestiaorg/smt"
-	typesUtil "github.com/pokt-network/pocket/utility/types"
+	"github.com/pokt-network/pocket/persistence/types"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -34,6 +34,27 @@ const (
 	lastMerkleTree
 )
 
+var actorTypeToMerkleTreeName map[types.ActorType]MerkleTree = map[types.ActorType]MerkleTree{
+	types.ActorType_App:  appMerkleTree,
+	types.ActorType_Val:  valMerkleTree,
+	types.ActorType_Fish: fishMerkleTree,
+	types.ActorType_Node: serviceNodeMerkleTree,
+}
+
+var merkleTreeToActorTypeName map[MerkleTree]types.ActorType = map[MerkleTree]types.ActorType{
+	appMerkleTree:         types.ActorType_App,
+	valMerkleTree:         types.ActorType_Val,
+	fishMerkleTree:        types.ActorType_Fish,
+	serviceNodeMerkleTree: types.ActorType_Node,
+}
+
+var actorTypeToSchemaName map[types.ActorType]types.ProtocolActorSchema = map[types.ActorType]types.ProtocolActorSchema{
+	types.ActorType_App:  types.ApplicationActor,
+	types.ActorType_Val:  types.ValidatorActor,
+	types.ActorType_Fish: types.FishermanActor,
+	types.ActorType_Node: types.ServiceNodeActor,
+}
+
 func newMerkleTrees() (map[MerkleTree]*smt.SparseMerkleTree, error) {
 	// We need a separate Merkle tree for each type of actor or storage
 	trees := make(map[MerkleTree]*smt.SparseMerkleTree, int(lastMerkleTree))
@@ -57,43 +78,33 @@ func (p *PostgresContext) updateStateHash() error {
 	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
 		switch treeType {
 		case appMerkleTree:
-			apps, err := p.getApplicationsUpdatedAtHeight(p.Height)
-			if err != nil {
-				// TODO_IN_THIS_COMMIT: Update this error
-				return typesUtil.NewError(typesUtil.Code(42), "Couldn't figure out apps updated")
-			}
-			for _, app := range apps {
-				appBz, err := proto.Marshal(app)
-				if err != nil {
-					return err
-				}
-				// An update results in a create/update that is idempotent
-				addrBz, err := hex.DecodeString(app.Address)
-				if err != nil {
-					return err
-				}
-				if _, err := p.MerkleTrees[treeType].Update(addrBz, appBz); err != nil {
-					return err
-				}
-			}
+			fallthrough
 		case valMerkleTree:
-			fmt.Println("TODO: valMerkleTree not implemented")
+			fallthrough
 		case fishMerkleTree:
-			fmt.Println("TODO: fishMerkleTree not implemented")
+			fallthrough
 		case serviceNodeMerkleTree:
-			fmt.Println("TODO: serviceNodeMerkleTree not implemented")
+			actorType, ok := merkleTreeToActorTypeName[treeType]
+			if !ok {
+				return fmt.Errorf("no actor type found for merkle tree: %v\n", treeType)
+			}
+			actors, err := p.getActorsUpdatedAtHeight(actorType, p.Height)
+			if err != nil {
+				return err
+			}
+			if err != p.updateActorsTree(actorType, actors) {
+				return err
+			}
 		case accountMerkleTree:
-			fmt.Println("TODO: accountMerkleTree not implemented")
+			log.Fatalf("TODO: accountMerkleTree not implemented")
 		case poolMerkleTree:
-			fmt.Println("TODO: poolMerkleTree not implemented")
+			log.Fatalf("TODO: poolMerkleTree not implemented")
 		case blocksMerkleTree:
-			// VERY VERY IMPORTANT DISCUSSION: What do we do here provided that `Commit`, which stores the block in the DB and tree
-			//                                 requires the quorumCert, which we receive at the very end of hotstuff consensus
-			fmt.Println("TODO: blocksMerkleTree not implemented")
+			log.Fatalf("TODO: blocksMerkleTree not implemented")
 		case paramsMerkleTree:
-			fmt.Println("TODO: paramsMerkleTree not implemented")
+			log.Fatalf("TODO: paramsMerkleTree not implemented")
 		case flagsMerkleTree:
-			fmt.Println("TODO: flagsMerkleTree not implemented")
+			log.Fatalf("TODO: flagsMerkleTree not implemented")
 		default:
 			log.Fatalln("Not handled yet in state commitment update", treeType)
 		}
@@ -102,7 +113,7 @@ func (p *PostgresContext) updateStateHash() error {
 	// Get the root of each Merkle Tree
 	roots := make([][]byte, 0)
 	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
-		roots = append(roots, p.MerkleTrees[treeType].Root())
+		roots = append(roots, p.merkleTrees[treeType].Root())
 	}
 
 	// Sort the merkle roots lexicographically
@@ -114,6 +125,60 @@ func (p *PostgresContext) updateStateHash() error {
 	rootsConcat := bytes.Join(roots, []byte{})
 	stateHash := sha256.Sum256(rootsConcat)
 
-	p.stateHash = stateHash[:]
+	p.currentStateHash = stateHash[:]
 	return nil
 }
+
+func (p PostgresContext) updateActorsTree(actorType types.ActorType, actors []*types.Actor) error {
+	for _, actor := range actors {
+		bzAddr, err := hex.DecodeString(actor.GetAddress())
+		if err != nil {
+			return err
+		}
+
+		appBz, err := proto.Marshal(actor)
+		if err != nil {
+			return err
+		}
+
+		merkleTreeName, ok := actorTypeToMerkleTreeName[actorType]
+		if !ok {
+			return fmt.Errorf("no merkle tree found for actor type: %s", actorType)
+		}
+
+		if _, err := p.merkleTrees[merkleTreeName].Update(bzAddr, appBz); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (p PostgresContext) getActorsUpdatedAtHeight(actorType types.ActorType, height int64) (actors []*types.Actor, err error) {
+	actorSchema, ok := actorTypeToSchemaName[actorType]
+	if !ok {
+		return nil, fmt.Errorf("no schema found for actor type: %s", actorType)
+	}
+
+	schemaActors, err := p.GetActorsUpdated(actorSchema, height)
+	if err != nil {
+		return nil, err
+	}
+
+	actors = make([]*types.Actor, len(schemaActors))
+	for _, actor := range actors {
+		actor := &types.Actor{
+			ActorType:       actorType,
+			Address:         actor.Address,
+			PublicKey:       actor.PublicKey,
+			Chains:          actor.Chains,
+			GenericParam:    actor.GenericParam,
+			StakedAmount:    actor.StakedAmount,
+			PausedHeight:    actor.PausedHeight,
+			UnstakingHeight: actor.UnstakingHeight,
+			Output:          actor.Output,
+		}
+		actors = append(actors, actor)
+	}
+	return
+}
diff --git a/persistence/types/base_actor.go b/persistence/types/base_actor.go
index 1c73da9a7..bd0d83aa9 100644
--- a/persistence/types/base_actor.go
+++ b/persistence/types/base_actor.go
@@ -155,5 +155,5 @@ func (x *Actor) GetActorTyp() modules.ActorType {
 	if x != nil {
 		return x.GetActorType()
 	}
-	return ActorType_App // HACK: Is this a hack?
+	return ActorType_Undefined
 }
diff --git a/shared/docs/flows/README.md b/shared/docs/flows/README.md
new file mode 100644
index 000000000..cb4e5d663
--- /dev/null
+++ b/shared/docs/flows/README.md
@@ -0,0 +1,3 @@
+# Flows
+
+The purpose of [shared/flows](./) is to document cross-module communication for end-to-end behaviour that has cross-module dependencies and and depends on the interfaces exposed by the interfaces exposed in [shared/modules](../modules).
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index e4dd5385c..a25e4d0ff 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -110,29 +110,6 @@ type PersistenceWriteContext interface {
 	// Flag Operations
 	InitFlags() error
 	SetFlag(paramName string, value interface{}, enabled bool) error
-
-	// Tree Operations
-
-	// # Option 1:
-
-	UpdateApplicationsTree([]Actor) error
-	// UpdateValidatorsTree([]Actor) error
-	// UpdateServiceNodesTree([]Actor) error
-	// UpdateFishermanTree([]Actor) error
-	// Update<FutureActors>Tree([]Actor) error
-	// Update<Other>Tree([]Other) error
-
-	// # Option 2:
-	// UpdateActorTree(types.ProtocolActorSchema, []Actor) error
-	// Update<Other>Tree([]Other) error
-
-	// # Option 3:
-	// UpdateApplicationsTree([]Application) error
-	// UpdateValidatorsTree([]Validator) error
-	// UpdateServiceNodesTree([]ServiceNode) error
-	// UpdateFishermanTree([]Fisherman) error
-	// Update<FutureActors>Tree([]FutureActor) error
-	// Update<Other>Tree([]Other) error
 }
 
 type PersistenceReadContext interface {
@@ -209,28 +186,4 @@ type PersistenceReadContext interface {
 	GetIntFlag(paramName string, height int64) (int, bool, error)
 	GetStringFlag(paramName string, height int64) (string, bool, error)
 	GetBytesFlag(paramName string, height int64) ([]byte, bool, error)
-
-	// Tree Operations
-
-	// # Option 1:
-
-	// GetApplicationsUpdatedAtHeight(height int64) ([]Actor, error)
-	// GetValidatorsUpdatedAtHeight(height int64) ([]Actor, error)
-	// GetServiceNodesUpdatedAtHeight(height int64) ([]Actor, error)
-	// GetFishermanUpdatedAtHeight(height int64) ([]Actor, error)
-	// Get<FutureActor>UpdatedAtHeight(height int64) ([]Actor, error)
-	// Get<Other>UpdatedAtHeight(height int64) ([]Actor, error)
-	// Update<Other>Tree(height int64) ([]Actor, error)
-
-	// # Option 2:
-	// Get<FutureActor>UpdatedAtHeight(types.ProtocolActorSchema, height int64) ([]Actor, error)
-	// Get<Other>UpdatedAtHeight(height int64) ([]Other, error)
-
-	// # Option 3:
-	// GetApplicationsUpdatedAtHeight(height int64) ([]Application, error)
-	// GetValidatorsUpdatedAtHeight(height int64) ([]Validator, error)
-	// GetServiceNodesUpdatedAtHeight(height int64) ([]ServiceNode, error)
-	// GetFishermanUpdatedAtHeight(height int64) ([]Fisherman, error)
-	// Get<FutureActor>UpdatedAtHeight(height int64) ([]FutureActor, error)
-	// Get<Other>UpdatedAtHeight(height int64) ([]Other, error)
 }
diff --git a/shared/types/genesis/validator.go b/shared/types/genesis/validator.go
deleted file mode 100644
index 17c2af5fd..000000000
--- a/shared/types/genesis/validator.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package genesis
-
-// import (
-// 	"encoding/hex"
-// 	"encoding/json"
-
-// 	"google.golang.org/protobuf/encoding/protojson"
-// )
-
-// // TODO_IN_THIS_COMMIT: See https://github.com/pokt-network/pocket/pull/139/files to remove this shit
-
-// // HACK: Since the protocol actor protobufs (e.g. validator, fisherman, etc) use `bytes` for some
-// // fields (e.g. `address`, `output`, `publicKey`), we need to use a helper struct to unmarshal the
-// // the types when they are defined via json (e.g. genesis file, testing configurations, etc...).
-// // Alternative solutions could include whole wrapper structs (i.e. duplication of schema definition),
-// // using strings instead of bytes (i.e. major change with downstream effects) or avoid defining these
-// // types in json altogether (i.e. limitation of usability).
-// type JsonBytesLoaderHelper struct {
-// 	Address   HexData `json:"address,omitempty"`
-// 	PublicKey HexData `json:"public_key,omitempty"`
-// 	Output    HexData `json:"output,omitempty"`
-// }
-
-// type HexData []byte
-
-// func (h *HexData) UnmarshalJSON(data []byte) error {
-// 	var s string
-// 	if err := json.Unmarshal(data, &s); err != nil {
-// 		return err
-// 	}
-// 	decoded, err := hex.DecodeString(s)
-// 	if err != nil {
-// 		return err
-// 	}
-// 	*h = HexData(decoded)
-// 	return nil
-// }
-
-// func (v *Validator) UnmarshalJSON(data []byte) error {
-// 	var jh JsonBytesLoaderHelper
-// 	json.Unmarshal(data, &jh)
-
-// 	protojson.Unmarshal(data, v)
-// 	v.Address = jh.Address
-// 	v.PublicKey = jh.PublicKey
-// 	v.Output = jh.Output
-
-// 	return nil
-// }
diff --git a/utility/block.go b/utility/block.go
index 51bbb4f49..0b074bb68 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -21,7 +21,7 @@ import (
 
 func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte, transactions [][]byte, lastBlockByzantineValidators [][]byte) ([]byte, error) {
 	u.LatestHeight = latestHeight
-	u.CurrentProposer = proposerAddress
+	u.currentProposer = proposerAddress
 
 	// begin block lifecycle phase
 	if err := u.BeginBlock(lastBlockByzantineValidators); err != nil {
diff --git a/utility/context.go b/utility/context.go
index 88518e6d9..d0e994f47 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -10,14 +10,15 @@ import (
 
 type UtilityContext struct {
 	LatestHeight    int64 // IMPROVE: Rename to `currentHeight?`
-	CurrentProposer []byte
+	currentProposer []byte
 
 	Mempool typesUtil.Mempool
 	Context *Context // IMPROVE: Rename to `persistenceContext` or `storeContext` or `reversibleContext`?
 }
 
-type Context struct { // IMPROVE: Rename to `persistenceContext` or `storeContext`?
-	// TODO: Since `Context` embeds `PersistenceRWContext`, we don't need to do `u.Context.PersistenceRWContext`, but can call `u.Context` directly
+// IMPROVE: Consider renaming to `persistenceContext` or `storeContext`?
+type Context struct {
+	// CLEANUP: Since `Context` embeds `PersistenceRWContext`, we don't need to do `u.Context.PersistenceRWContext`, but can call `u.Context` directly
 	modules.PersistenceRWContext
 	// TODO/DISCUSS: `SavePoints`` have not been implemented yet
 	SavePointsM map[string]struct{}
@@ -51,7 +52,7 @@ func (u *UtilityContext) Release() error {
 }
 
 func (u *UtilityContext) Commit(quorumCert []byte) error {
-	return nil
+	return u.Context.Commit(u.currentProposer, quorumCert)
 }
 
 func (u *UtilityContext) GetLatestBlockHeight() (int64, typesUtil.Error) {

From 5171d2d8ef90512c33c9a61e5528ef7ea58a5595 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 6 Oct 2022 18:33:07 -0700
Subject: [PATCH 082/227] Almost got a deterministic state hash

---
 persistence/block.go               | 17 ++++----
 persistence/context.go             | 15 +++++--
 persistence/debug.go               |  4 +-
 persistence/module.go              |  4 +-
 persistence/shared_sql.go          | 24 ++++++----
 persistence/state.go               | 28 ++++++------
 persistence/state_test.go          | 15 -------
 persistence/test/account_test.go   |  5 ++-
 persistence/test/setup_test.go     | 14 +++---
 persistence/test/state_test.go     | 70 ++++++++++++++++++++++++++++++
 shared/crypto/ed25519.go           |  6 +++
 shared/test_artifacts/generator.go | 33 +++++++++++---
 12 files changed, 169 insertions(+), 66 deletions(-)
 delete mode 100644 persistence/state_test.go
 create mode 100644 persistence/test/state_test.go

diff --git a/persistence/block.go b/persistence/block.go
index c3e6ca92a..70168b036 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -5,8 +5,8 @@ import (
 	"encoding/hex"
 	"log"
 
-	"github.com/gogo/protobuf/proto"
 	"github.com/pokt-network/pocket/persistence/types"
+	"github.com/pokt-network/pocket/shared/codec"
 )
 
 // OPTIMIZE(team): get from blockstore or keep in memory
@@ -45,12 +45,12 @@ func (p PostgresContext) TransactionExists(transactionHash string) (bool, error)
 	return false, nil
 }
 
-func (p PostgresContext) StoreTransaction(transactionProtoBytes []byte) error {
+func (p *PostgresContext) StoreTransaction(transactionProtoBytes []byte) error {
 	p.currentBlockTxs = append(p.currentBlockTxs, transactionProtoBytes)
 	return nil
 }
 
-func (p PostgresContext) insertBlock(block *types.Block) error {
+func (p *PostgresContext) insertBlock(block *types.Block) error {
 	ctx, tx, err := p.GetCtxAndTx()
 	if err != nil {
 		return err
@@ -61,15 +61,15 @@ func (p PostgresContext) insertBlock(block *types.Block) error {
 }
 
 func (p PostgresContext) storeBlock(block *types.Block) error {
-	blockBz, err := proto.Marshal(block)
-
+	blockBz, err := codec.GetCodec().Marshal(block)
 	if err != nil {
 		return err
 	}
-	return p.blockStore.Put(heightToBytes(p.Height), blockBz)
+
+	return p.blockStore.Put(HeightToBytes(p.Height), blockBz)
 }
 
-func (p PostgresContext) getBlock(proposerAddr []byte, quorumCert []byte) (*types.Block, error) {
+func (p *PostgresContext) getBlock(proposerAddr []byte, quorumCert []byte) (*types.Block, error) {
 	var prevHash []byte
 	if p.Height > 0 {
 		var err error
@@ -94,7 +94,8 @@ func (p PostgresContext) getBlock(proposerAddr []byte, quorumCert []byte) (*type
 }
 
 // CLEANUP: Should this be moved to a shared directory?
-func heightToBytes(height int64) []byte {
+// Exposed for testing purposes
+func HeightToBytes(height int64) []byte {
 	heightBytes := make([]byte, 8)
 	binary.LittleEndian.PutUint64(heightBytes, uint64(height))
 	return heightBytes
diff --git a/persistence/context.go b/persistence/context.go
index 5492ce475..55d4ae1a5 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -2,6 +2,7 @@ package persistence
 
 import (
 	"context"
+	"fmt"
 	"log"
 )
 
@@ -29,21 +30,29 @@ func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
 	if err != nil {
 		return err
 	}
-	if err := p.insertBlock(block); err != nil {
-		return err
-	}
+	fmt.Println(block.Transactions, "OLSH")
+
+	// if err := p.insertBlock(block); err != nil {
+	// 	return err
+	// }
 
+	fmt.Println("OLSH 0")
 	if err := p.storeBlock(block); err != nil {
+		fmt.Println("OLSH 1")
 		return err
 	}
+	fmt.Println("OLSH 2")
 
+	fmt.Println("OLSH 3")
 	ctx := context.TODO()
 	if err := p.GetTx().Commit(ctx); err != nil {
 		return err
 	}
+	fmt.Println("OLSH 4")
 	if err := p.conn.Close(ctx); err != nil {
 		log.Println("[TODO][ERROR] Implement connection pooling. Error when closing DB connecting...", err)
 	}
+	fmt.Println("OLSH 5")
 	return nil
 }
 
diff --git a/persistence/debug.go b/persistence/debug.go
index 287148a6f..14573d41e 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -30,7 +30,7 @@ func (m *PersistenceModule) HandleDebugMessage(debugMessage *debug.DebugMessage)
 func (m *PersistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 	// TODO: Add an iterator to the `kvstore` and use that instead
 	height := m.GetBus().GetConsensusModule().CurrentHeight() - 1 // -1 because we want the latest committed height
-	blockBytes, err := m.GetBlockStore().Get(heightToBytes(int64(height)))
+	blockBytes, err := m.GetBlockStore().Get(HeightToBytes(int64(height)))
 	if err != nil {
 		log.Printf("Error getting block %d from block store: %s \n", height, err)
 		return
@@ -49,7 +49,7 @@ func (m *PersistenceModule) clearState(_ *debug.DebugMessage) {
 		log.Printf("Error creating new context: %s \n", err)
 		return
 	}
-	if err := context.(PostgresContext).DebugClearAll(); err != nil {
+	if err := context.(*PostgresContext).DebugClearAll(); err != nil {
 		log.Printf("Error clearing state: %s \n", err)
 		return
 	}
diff --git a/persistence/module.go b/persistence/module.go
index 1d1454679..338350899 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -196,7 +196,7 @@ func (m *PersistenceModule) NewRWContext(height int64) (modules.PersistenceRWCon
 		merkleTrees: m.trees,
 	}
 
-	return *m.writeContext, nil
+	return m.writeContext, nil
 
 }
 
@@ -259,5 +259,5 @@ func (m *PersistenceModule) shouldHydrateGenesisDb() (bool, error) {
 		return true, nil
 	}
 
-	return m.blockStore.Exists(heightToBytes(int64(maxHeight)))
+	return m.blockStore.Exists(HeightToBytes(int64(maxHeight)))
 }
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
index 9e279cfd4..0cff6e62f 100644
--- a/persistence/shared_sql.go
+++ b/persistence/shared_sql.go
@@ -54,21 +54,28 @@ func (p *PostgresContext) GetActorsUpdated(actorSchema types.ProtocolActorSchema
 	if err != nil {
 		return nil, err
 	}
-	defer rows.Close()
-
-	// OPTIMIZE: Consolidate logic with `GetActor` to reduce code footprint
-	var addr string
+	addrs := make([][]byte, 0)
 	for rows.Next() {
+		var addr string
 		if err = rows.Scan(&addr); err != nil {
-			return
+			return nil, err
 		}
+		addrBz, err := hex.DecodeString(addr)
+		if err != nil {
+			return nil, err
+		}
+		addrs = append(addrs, addrBz)
+	}
+	rows.Close()
 
+	// OPTIMIZE: Consolidate logic with `GetActor` to reduce code footprint
+	actors = make([]types.BaseActor, len(addrs))
+	for i, addr := range addrs {
 		actor, err := p.GetActor(actorSchema, []byte(addr), height)
 		if err != nil {
 			return nil, err
 		}
-
-		actors = append(actors, actor)
+		actors[i] = actor
 	}
 
 	return
@@ -106,7 +113,8 @@ func (p *PostgresContext) GetChainsForActor(
 	tx pgx.Tx,
 	actorSchema types.ProtocolActorSchema,
 	actor types.BaseActor,
-	height int64) (a types.BaseActor, err error) {
+	height int64,
+) (a types.BaseActor, err error) {
 	if actorSchema.GetChainsTableName() == "" {
 		return actor, nil
 	}
diff --git a/persistence/state.go b/persistence/state.go
index 0d596d124..86a249a1d 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -6,7 +6,6 @@ import (
 	"encoding/hex"
 	"fmt"
 	"log"
-	"sort"
 
 	"github.com/celestiaorg/smt"
 	"github.com/pokt-network/pocket/persistence/types"
@@ -22,6 +21,8 @@ const (
 	valMerkleTree
 	fishMerkleTree
 	serviceNodeMerkleTree
+
+	// Account Merkle Trees
 	accountMerkleTree
 	poolMerkleTree
 
@@ -96,15 +97,15 @@ func (p *PostgresContext) updateStateHash() error {
 				return err
 			}
 		case accountMerkleTree:
-			log.Fatalf("TODO: accountMerkleTree not implemented")
+			fallthrough
 		case poolMerkleTree:
-			log.Fatalf("TODO: poolMerkleTree not implemented")
+			fallthrough
 		case blocksMerkleTree:
-			log.Fatalf("TODO: blocksMerkleTree not implemented")
+			fallthrough
 		case paramsMerkleTree:
-			log.Fatalf("TODO: paramsMerkleTree not implemented")
+			fallthrough
 		case flagsMerkleTree:
-			log.Fatalf("TODO: flagsMerkleTree not implemented")
+			log.Println("TODO: merkle tree not implemented", treeType)
 		default:
 			log.Fatalln("Not handled yet in state commitment update", treeType)
 		}
@@ -116,10 +117,11 @@ func (p *PostgresContext) updateStateHash() error {
 		roots = append(roots, p.merkleTrees[treeType].Root())
 	}
 
+	// Currently using the order of the merkle tree definition (i.e. defined in code)
 	// Sort the merkle roots lexicographically
-	sort.Slice(roots, func(r1, r2 int) bool {
-		return bytes.Compare(roots[r1], roots[r2]) < 0
-	})
+	// sort.Slice(roots, func(r1, r2 int) bool {
+	// 	return bytes.Compare(roots[r1], roots[r2]) < 0
+	// })
 
 	// Get the state hash
 	rootsConcat := bytes.Join(roots, []byte{})
@@ -166,17 +168,17 @@ func (p PostgresContext) getActorsUpdatedAtHeight(actorType types.ActorType, hei
 	}
 
 	actors = make([]*types.Actor, len(schemaActors))
-	for _, actor := range actors {
+	for _, actor := range schemaActors {
 		actor := &types.Actor{
 			ActorType:       actorType,
 			Address:         actor.Address,
 			PublicKey:       actor.PublicKey,
 			Chains:          actor.Chains,
-			GenericParam:    actor.GenericParam,
-			StakedAmount:    actor.StakedAmount,
+			GenericParam:    actor.ActorSpecificParam,
+			StakedAmount:    actor.StakedTokens,
 			PausedHeight:    actor.PausedHeight,
 			UnstakingHeight: actor.UnstakingHeight,
-			Output:          actor.Output,
+			Output:          actor.OutputAddress,
 		}
 		actors = append(actors, actor)
 	}
diff --git a/persistence/state_test.go b/persistence/state_test.go
deleted file mode 100644
index 9570f4c00..000000000
--- a/persistence/state_test.go
+++ /dev/null
@@ -1,15 +0,0 @@
-package persistence
-
-import "testing"
-
-func TestStateHash_InitializeTrees(t *testing.T) {
-
-}
-
-func TestStateHash_LoadTrees(t *testing.T) {
-
-}
-
-func TestStateHash_ComputeStateHash(t *testing.T) {
-
-}
diff --git a/persistence/test/account_test.go b/persistence/test/account_test.go
index d6146581f..7745b1ecd 100644
--- a/persistence/test/account_test.go
+++ b/persistence/test/account_test.go
@@ -3,13 +3,14 @@ package test
 import (
 	"encoding/hex"
 	"fmt"
-	"github.com/pokt-network/pocket/persistence/types"
-	"github.com/pokt-network/pocket/shared/modules"
 	"log"
 	"math/big"
 	"math/rand"
 	"testing"
 
+	"github.com/pokt-network/pocket/persistence/types"
+	"github.com/pokt-network/pocket/shared/modules"
+
 	"github.com/pokt-network/pocket/persistence"
 	"github.com/pokt-network/pocket/shared/crypto"
 	"github.com/stretchr/testify/require"
diff --git a/persistence/test/setup_test.go b/persistence/test/setup_test.go
index ae759da16..71f7743e2 100644
--- a/persistence/test/setup_test.go
+++ b/persistence/test/setup_test.go
@@ -65,15 +65,17 @@ func NewTestPostgresContext(t *testing.T, height int64) *persistence.PostgresCon
 	ctx, err := testPersistenceMod.NewRWContext(height)
 	require.NoError(t, err)
 
-	db, ok := ctx.(persistence.PostgresContext)
+	db, ok := ctx.(*persistence.PostgresContext)
 	require.True(t, ok)
 
 	t.Cleanup(func() {
-		require.NoError(t, db.Release())
-		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
+		db.Release()
+		testPersistenceMod.ReleaseWriteContext()
+		// require.NoError(t, db.Release())
+		// require.NoError(t, testPersistenceMod.ReleaseWriteContext())
 	})
 
-	return &db
+	return db
 }
 
 func NewFuzzTestPostgresContext(f *testing.F, height int64) *persistence.PostgresContext {
@@ -82,7 +84,7 @@ func NewFuzzTestPostgresContext(f *testing.F, height int64) *persistence.Postgre
 		log.Fatalf("Error creating new context: %v\n", err)
 	}
 
-	db, ok := ctx.(persistence.PostgresContext)
+	db, ok := ctx.(*persistence.PostgresContext)
 	if !ok {
 		log.Fatalf("Error casting RW context to Postgres context")
 	}
@@ -96,7 +98,7 @@ func NewFuzzTestPostgresContext(f *testing.F, height int64) *persistence.Postgre
 		}
 	})
 
-	return &db
+	return db
 }
 
 // TODO(andrew): Take in `t testing.T` as a parameter and error if there's an issue
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
new file mode 100644
index 000000000..ff184f21f
--- /dev/null
+++ b/persistence/test/state_test.go
@@ -0,0 +1,70 @@
+package test
+
+import (
+	"encoding/hex"
+	"fmt"
+	"math/big"
+	"testing"
+
+	"github.com/pokt-network/pocket/persistence"
+	"github.com/pokt-network/pocket/persistence/types"
+	"github.com/pokt-network/pocket/shared/codec"
+	"github.com/stretchr/testify/require"
+)
+
+func TestStateHash_DeterministicStateHash(t *testing.T) {
+	// These hashes were determined manually by running the test, but hardcoded to guarantee
+	// that the business logic doesn't change and that they remain deterministic.
+	encodedAppHash := []string{
+		"a405c3db598c9898c61b76c77f3e1ed94277a2bc683fbc4f9bd502c47633d617",
+		"e431c357c0e0d9ef5999b52bc18d36aa0e1bedbd555a82dd5e8a8130b6b8fa6b",
+		"a46c8024472f50a4ab887b8b1e06fdc578f0344eada2d68784325c27e74d6529",
+	}
+
+	// Make sure the app Hash is the same every time
+
+	for i := 0; i < 3; i++ {
+		height := int64(i + 1)
+		heightBz := persistence.HeightToBytes(height)
+		db := NewTestPostgresContext(t, height)
+
+		apps, err := db.GetAllApps(height)
+		require.NoError(t, err)
+		app := apps[0]
+
+		addrBz, err := hex.DecodeString(app.GetAddress())
+		require.NoError(t, err)
+
+		newStakeAmount := types.BigIntToString(big.NewInt(height + int64(420000000000)))
+		err = db.SetAppStakeAmount(addrBz, newStakeAmount)
+		require.NoError(t, err)
+
+		appHash, err := db.UpdateAppHash()
+		require.NoError(t, err)
+		require.Equal(t, encodedAppHash[i], hex.EncodeToString(appHash))
+
+		txBz := []byte("a tx, i am, which set the app stake amount to " + newStakeAmount)
+		err = db.StoreTransaction(txBz)
+		require.NoError(t, err)
+
+		fmt.Println(err, "OLSH1")
+		err = db.Commit([]byte("proposer"), []byte("quorumCert"))
+		fmt.Println(err, "OLSH2")
+		require.NoError(t, err)
+
+		blockBz, err := testPersistenceMod.GetBlockStore().Get(heightBz)
+		require.NoError(t, err)
+
+		var block types.Block
+		err = codec.GetCodec().Unmarshal(blockBz, &block)
+		require.NoError(t, err)
+		require.Len(t, block.Transactions, 1)
+		require.Equal(t, txBz, block.Transactions[0])
+
+		// Clear and release the context
+		// db.DebugClearAll()
+		// testPersistenceMod.GetBlockStore().ClearAll()
+		db.Release()
+		testPersistenceMod.ReleaseWriteContext()
+	}
+}
diff --git a/shared/crypto/ed25519.go b/shared/crypto/ed25519.go
index 97b0c385b..6967f2763 100644
--- a/shared/crypto/ed25519.go
+++ b/shared/crypto/ed25519.go
@@ -5,6 +5,7 @@ import (
 	"crypto/sha256"
 	"encoding/hex"
 	"encoding/json"
+	"io"
 )
 
 const (
@@ -55,6 +56,11 @@ func GeneratePrivateKey() (PrivateKey, error) {
 	return Ed25519PrivateKey(pk), err
 }
 
+func GeneratePrivateKeyWithReader(rand io.Reader) (PrivateKey, error) {
+	_, pk, err := ed25519.GenerateKey(rand)
+	return Ed25519PrivateKey(pk), err
+}
+
 func NewPrivateKeyFromBytes(bz []byte) (PrivateKey, error) {
 	bzLen := len(bz)
 	if bzLen != ed25519.PrivateKeySize {
diff --git a/shared/test_artifacts/generator.go b/shared/test_artifacts/generator.go
index 26e23a143..dde3dd232 100644
--- a/shared/test_artifacts/generator.go
+++ b/shared/test_artifacts/generator.go
@@ -1,6 +1,8 @@
 package test_artifacts
 
 import (
+	"bytes"
+	"encoding/binary"
 	"fmt"
 	"math/big"
 	"strconv"
@@ -121,7 +123,7 @@ func NewPools() (pools []modules.Account) { // TODO (Team) in the real testing s
 
 func NewAccounts(n int, privateKeys ...string) (accounts []modules.Account) {
 	for i := 0; i < n; i++ {
-		_, _, addr := GenerateNewKeysStrings()
+		_, _, addr := GenerateNewKeysDeterministic(69)
 		if privateKeys != nil {
 			pk, _ := crypto.NewPrivateKey(privateKeys[i])
 			addr = pk.Address().String()
@@ -148,7 +150,7 @@ func NewActors(actorType MockActorType, n int) (actors []modules.Actor, privateK
 }
 
 func NewDefaultActor(actorType int32, genericParam string) (actor modules.Actor, privateKey string) {
-	privKey, pubKey, addr := GenerateNewKeysStrings()
+	privKey, pubKey, addr := GenerateNewKeysDeterministic(69)
 	chains := DefaultChains
 	if actorType == int32(typesPersistence.ActorType_Val) {
 		chains = nil
@@ -168,6 +170,14 @@ func NewDefaultActor(actorType int32, genericParam string) (actor modules.Actor,
 	}, privKey
 }
 
+func GenerateNewKeysStrings() (privateKey, publicKey, address string) {
+	privKey, pubKey, addr := GenerateNewKeys()
+	privateKey = privKey.String()
+	publicKey = pubKey.String()
+	address = addr.String()
+	return
+}
+
 func GenerateNewKeys() (privateKey crypto.PrivateKey, publicKey crypto.PublicKey, address crypto.Address) {
 	privateKey, _ = crypto.GeneratePrivateKey()
 	publicKey = privateKey.PublicKey()
@@ -175,10 +185,19 @@ func GenerateNewKeys() (privateKey crypto.PrivateKey, publicKey crypto.PublicKey
 	return
 }
 
-func GenerateNewKeysStrings() (privateKey, publicKey, address string) {
-	privKey, pubKey, addr := GenerateNewKeys()
-	privateKey = privKey.String()
-	publicKey = pubKey.String()
-	address = addr.String()
+func GenerateNewKeysDeterministic(seed uint32) (privateKey, publicKey, address string) {
+	cryptoSeed := make([]byte, crypto.SeedSize)
+	binary.LittleEndian.PutUint32(cryptoSeed, seed)
+
+	reader := bytes.NewReader(cryptoSeed)
+	privateKeyBz, err := crypto.GeneratePrivateKeyWithReader(reader)
+	if err != nil {
+		panic(err)
+	}
+
+	privateKey = privateKeyBz.String()
+	publicKey = privateKeyBz.PublicKey().String()
+	address = privateKeyBz.PublicKey().Address().String()
+
 	return
 }

From ffcb91f96e9d8cab393d18c3a21c7d2aed85c293 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 6 Oct 2022 20:17:44 -0700
Subject: [PATCH 083/227] Test passed

---
 persistence/block.go           |  4 ++--
 persistence/context.go         | 18 ++++++------------
 persistence/state.go           |  2 +-
 persistence/test/setup_test.go | 12 ++++++------
 persistence/test/state_test.go | 31 ++++++++++++++++---------------
 5 files changed, 31 insertions(+), 36 deletions(-)

diff --git a/persistence/block.go b/persistence/block.go
index 70168b036..3ca1d8b34 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -83,8 +83,8 @@ func (p *PostgresContext) getBlock(proposerAddr []byte, quorumCert []byte) (*typ
 
 	block := &types.Block{
 		Height:            uint64(p.Height),
-		Hash:              string(p.currentStateHash),
-		PrevHash:          string(prevHash),
+		Hash:              hex.EncodeToString(p.currentStateHash),
+		PrevHash:          hex.EncodeToString(prevHash),
 		ProposerAddress:   proposerAddr,
 		QuorumCertificate: quorumCert,
 		Transactions:      p.currentBlockTxs,
diff --git a/persistence/context.go b/persistence/context.go
index 55d4ae1a5..7bb8b1442 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -2,7 +2,6 @@ package persistence
 
 import (
 	"context"
-	"fmt"
 	"log"
 )
 
@@ -16,7 +15,7 @@ func (p PostgresContext) RollbackToSavePoint(bytes []byte) error {
 	return p.GetTx().Rollback(context.TODO())
 }
 
-func (p PostgresContext) UpdateAppHash() ([]byte, error) {
+func (p *PostgresContext) UpdateAppHash() ([]byte, error) {
 	if err := p.updateStateHash(); err != nil {
 		return nil, err
 	}
@@ -30,29 +29,24 @@ func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
 	if err != nil {
 		return err
 	}
-	fmt.Println(block.Transactions, "OLSH")
 
-	// if err := p.insertBlock(block); err != nil {
-	// 	return err
-	// }
+	if err := p.insertBlock(block); err != nil {
+		return err
+	}
 
-	fmt.Println("OLSH 0")
 	if err := p.storeBlock(block); err != nil {
-		fmt.Println("OLSH 1")
 		return err
 	}
-	fmt.Println("OLSH 2")
 
-	fmt.Println("OLSH 3")
 	ctx := context.TODO()
 	if err := p.GetTx().Commit(ctx); err != nil {
 		return err
 	}
-	fmt.Println("OLSH 4")
+
 	if err := p.conn.Close(ctx); err != nil {
 		log.Println("[TODO][ERROR] Implement connection pooling. Error when closing DB connecting...", err)
 	}
-	fmt.Println("OLSH 5")
+
 	return nil
 }
 
diff --git a/persistence/state.go b/persistence/state.go
index 86a249a1d..2e6ea75fc 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -127,7 +127,7 @@ func (p *PostgresContext) updateStateHash() error {
 	rootsConcat := bytes.Join(roots, []byte{})
 	stateHash := sha256.Sum256(rootsConcat)
 
-	p.currentStateHash = stateHash[:]
+	p.currentStateHash = stateHash[:] //[]byte(fmt.Sprintf("%x", ))
 	return nil
 }
 
diff --git a/persistence/test/setup_test.go b/persistence/test/setup_test.go
index 71f7743e2..70e4d31be 100644
--- a/persistence/test/setup_test.go
+++ b/persistence/test/setup_test.go
@@ -68,12 +68,12 @@ func NewTestPostgresContext(t *testing.T, height int64) *persistence.PostgresCon
 	db, ok := ctx.(*persistence.PostgresContext)
 	require.True(t, ok)
 
-	t.Cleanup(func() {
-		db.Release()
-		testPersistenceMod.ReleaseWriteContext()
-		// require.NoError(t, db.Release())
-		// require.NoError(t, testPersistenceMod.ReleaseWriteContext())
-	})
+	// t.Cleanup(func() {
+	// 	// db.Release()
+	// 	// testPersistenceMod.ReleaseWriteContext()
+	// 	require.NoError(t, db.Release())
+	// 	require.NoError(t, testPersistenceMod.ReleaseWriteContext())
+	// })
 
 	return db
 }
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index ff184f21f..ab3365af7 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -2,7 +2,6 @@ package test
 
 import (
 	"encoding/hex"
-	"fmt"
 	"math/big"
 	"testing"
 
@@ -12,7 +11,7 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestStateHash_DeterministicStateHash(t *testing.T) {
+func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 	// These hashes were determined manually by running the test, but hardcoded to guarantee
 	// that the business logic doesn't change and that they remain deterministic.
 	encodedAppHash := []string{
@@ -21,11 +20,12 @@ func TestStateHash_DeterministicStateHash(t *testing.T) {
 		"a46c8024472f50a4ab887b8b1e06fdc578f0344eada2d68784325c27e74d6529",
 	}
 
-	// Make sure the app Hash is the same every time
-
 	for i := 0; i < 3; i++ {
+		// Get the context at the new height and retrieve one of the apps
 		height := int64(i + 1)
 		heightBz := persistence.HeightToBytes(height)
+		expectedAppHash := encodedAppHash[i]
+
 		db := NewTestPostgresContext(t, height)
 
 		apps, err := db.GetAllApps(height)
@@ -35,23 +35,25 @@ func TestStateHash_DeterministicStateHash(t *testing.T) {
 		addrBz, err := hex.DecodeString(app.GetAddress())
 		require.NoError(t, err)
 
+		// Update the app's stake
 		newStakeAmount := types.BigIntToString(big.NewInt(height + int64(420000000000)))
 		err = db.SetAppStakeAmount(addrBz, newStakeAmount)
 		require.NoError(t, err)
 
-		appHash, err := db.UpdateAppHash()
-		require.NoError(t, err)
-		require.Equal(t, encodedAppHash[i], hex.EncodeToString(appHash))
-
+		// NOTE: The tx does not currently affect the state hash
 		txBz := []byte("a tx, i am, which set the app stake amount to " + newStakeAmount)
 		err = db.StoreTransaction(txBz)
 		require.NoError(t, err)
 
-		fmt.Println(err, "OLSH1")
+		// Update & commit the state hash
+		appHash, err := db.UpdateAppHash()
+		require.NoError(t, err)
+		require.Equal(t, expectedAppHash, hex.EncodeToString(appHash))
+
 		err = db.Commit([]byte("proposer"), []byte("quorumCert"))
-		fmt.Println(err, "OLSH2")
 		require.NoError(t, err)
 
+		// Verify the block contents
 		blockBz, err := testPersistenceMod.GetBlockStore().Get(heightBz)
 		require.NoError(t, err)
 
@@ -60,11 +62,10 @@ func TestStateHash_DeterministicStateHash(t *testing.T) {
 		require.NoError(t, err)
 		require.Len(t, block.Transactions, 1)
 		require.Equal(t, txBz, block.Transactions[0])
+		require.Equal(t, expectedAppHash, block.Hash) // block
+		if i > 0 {
+			require.Equal(t, encodedAppHash[i-1], block.PrevHash) // chain
+		}
 
-		// Clear and release the context
-		// db.DebugClearAll()
-		// testPersistenceMod.GetBlockStore().ClearAll()
-		db.Release()
-		testPersistenceMod.ReleaseWriteContext()
 	}
 }

From 6317a8471a379afb1bf8a1526e4cec99ba75b193 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 6 Oct 2022 20:31:00 -0700
Subject: [PATCH 084/227] Quick self review

---
 persistence/block.go      |  3 +--
 persistence/context.go    |  2 +-
 persistence/shared_sql.go |  1 +
 persistence/state.go      | 15 ++++++++-------
 4 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/persistence/block.go b/persistence/block.go
index 3ca1d8b34..65a4c87f8 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -65,11 +65,10 @@ func (p PostgresContext) storeBlock(block *types.Block) error {
 	if err != nil {
 		return err
 	}
-
 	return p.blockStore.Put(HeightToBytes(p.Height), blockBz)
 }
 
-func (p *PostgresContext) getBlock(proposerAddr []byte, quorumCert []byte) (*types.Block, error) {
+func (p *PostgresContext) prepareBlock(proposerAddr []byte, quorumCert []byte) (*types.Block, error) {
 	var prevHash []byte
 	if p.Height > 0 {
 		var err error
diff --git a/persistence/context.go b/persistence/context.go
index 7bb8b1442..18fbf3200 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -25,7 +25,7 @@ func (p *PostgresContext) UpdateAppHash() ([]byte, error) {
 func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
-	block, err := p.getBlock(proposerAddr, quorumCert)
+	block, err := p.prepareBlock(proposerAddr, quorumCert)
 	if err != nil {
 		return err
 	}
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
index 0cff6e62f..81f669217 100644
--- a/persistence/shared_sql.go
+++ b/persistence/shared_sql.go
@@ -54,6 +54,7 @@ func (p *PostgresContext) GetActorsUpdated(actorSchema types.ProtocolActorSchema
 	if err != nil {
 		return nil, err
 	}
+
 	addrs := make([][]byte, 0)
 	for rows.Next() {
 		var addr string
diff --git a/persistence/state.go b/persistence/state.go
index 2e6ea75fc..f7e268c66 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -105,7 +105,7 @@ func (p *PostgresContext) updateStateHash() error {
 		case paramsMerkleTree:
 			fallthrough
 		case flagsMerkleTree:
-			log.Println("TODO: merkle tree not implemented", treeType)
+			// log.Println("TODO: merkle tree not implemented", treeType)
 		default:
 			log.Fatalln("Not handled yet in state commitment update", treeType)
 		}
@@ -117,17 +117,18 @@ func (p *PostgresContext) updateStateHash() error {
 		roots = append(roots, p.merkleTrees[treeType].Root())
 	}
 
-	// Currently using the order of the merkle tree definition (i.e. defined in code)
-	// Sort the merkle roots lexicographically
-	// sort.Slice(roots, func(r1, r2 int) bool {
-	// 	return bytes.Compare(roots[r1], roots[r2]) < 0
-	// })
+	// DISCUSS(drewsky): In #152, we discussed the ordering of the roots
+	// 	Strict Ordering: sha3(app_tree_root + fish_tree_root + service_node_tree_root + validator_tree_root)
+	// 	Value Ordering sha3(app_tree_root <= + fish_tree_root <= + service_node_tree_root <= + validator_tree_root)
+	// If we don't do the lexographic ordering below, then it follows the string ordering of
+	// the merkle trees declared above. I have a feeling you're not a fan of this solution, but curious
+	// to hear your thoughts.
 
 	// Get the state hash
 	rootsConcat := bytes.Join(roots, []byte{})
 	stateHash := sha256.Sum256(rootsConcat)
 
-	p.currentStateHash = stateHash[:] //[]byte(fmt.Sprintf("%x", ))
+	p.currentStateHash = stateHash[:]
 	return nil
 }
 

From 3002911a365446f930315f2f7cdc2b2db2e205a1 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky@pokt.network>
Date: Mon, 17 Oct 2022 11:43:59 -0700
Subject: [PATCH 085/227] Update shared/docs/flows/AppHash.md

Co-authored-by: Alessandro De Blasis <alex@deblasis.net>
---
 shared/docs/flows/AppHash.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/shared/docs/flows/AppHash.md b/shared/docs/flows/AppHash.md
index 1e8eceb9f..80f16d122 100644
--- a/shared/docs/flows/AppHash.md
+++ b/shared/docs/flows/AppHash.md
@@ -6,7 +6,9 @@
 
 ## Context Initialization
 
-This flow shows the process of context initialization between all the modules requirer to apply a block and compute a state hash during the consensus lifecycle.
+This flow shows the process of context initialization between all the modules required to apply a block and compute a state hash during the consensus lifecycle.
+
+The `Hotstuff lifecycle` part refers to the so-called `PreCommit` and `Commit` phases of the protocol.
 
 ```mermaid
 sequenceDiagram

From 7ea59696df96ed514d7269e278fd32a552ee10d1 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky@pokt.network>
Date: Mon, 17 Oct 2022 11:44:11 -0700
Subject: [PATCH 086/227] Update shared/docs/flows/AppHash.md

Co-authored-by: Alessandro De Blasis <alex@deblasis.net>
---
 shared/docs/flows/AppHash.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/shared/docs/flows/AppHash.md b/shared/docs/flows/AppHash.md
index 80f16d122..a7f2a411f 100644
--- a/shared/docs/flows/AppHash.md
+++ b/shared/docs/flows/AppHash.md
@@ -40,6 +40,7 @@ sequenceDiagram
 
 ## Block Application
 
+This flow shows how the `leader` and the `replica`s behave in order to apply a `block` and return a `stateHash`.
 ```mermaid
 sequenceDiagram
     participant C as Consensus

From ea2b2012ef858db5bc9ef5b36dd7f125215dd9c2 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky@pokt.network>
Date: Mon, 17 Oct 2022 14:19:12 -0700
Subject: [PATCH 087/227] Update shared/docs/flows/AppHash.md

Co-authored-by: Irving A.J. Rivas Z. <axel.rivas@gmail.com>
---
 shared/docs/flows/AppHash.md | 48 +++++++++++++++++++++++-------------
 1 file changed, 31 insertions(+), 17 deletions(-)

diff --git a/shared/docs/flows/AppHash.md b/shared/docs/flows/AppHash.md
index a7f2a411f..b7b7d3ccc 100644
--- a/shared/docs/flows/AppHash.md
+++ b/shared/docs/flows/AppHash.md
@@ -47,26 +47,40 @@ sequenceDiagram
     participant U as Utility
     participant P as Persistence
 
-    alt as leader
-        C->>+U: GetProposalTransactions(proposer, maxTxBz, [lastVal])
+    opt if leader
+        C->>U: GetProposalTransactions(proposer, maxTxBz, [lastVal])
+        activate U
+        alt no quorum for Prepare
         U->>U: reap mempool
-        U->>-C: txs
-        Note over C, U: fallthrough to replica behaviour
-    else as replica
-        C->>+U: ApplyBlock(height, proposer, txs, lastVals)
-        loop for each operation in tx
-            U->>P: Get*/Set*
-            P->>U: result, err_code
-            U->>U: validation<br>logic
-            U->>P: StoreTransaction(tx)
-            P->>P: store tx<br>locally
-            P->>U: result, err_code
+        activate U
+        deactivate U
+        else
+        U->>U: get QC
+        activate U
+        deactivate U
         end
-        U->>+P: UpdateAppHash()
-        Note over P: Update State Hash
-        P->>-U: stateHash
-        U->>-C: stateHash
+        U-->>C: txs
+        deactivate U
     end
+    C->>+U: ApplyBlock(height, proposer, txs, lastVals)
+    loop for each tx in txs
+        U->>+P: Get*/Set*
+        P-->>-U: result, err_code
+        U->>U: Validation logic
+        activate U
+        deactivate U
+        U->>+P: StoreTransaction(tx)
+        P->>P: Store tx locally
+        activate P
+        deactivate P
+        P-->>-U: result, err_code
+    end
+    U->>+P: UpdateAppHash()
+    P->>P: Update state hash
+    activate P
+    deactivate P
+    P-->>-U: stateHash
+    U-->>-C: stateHash
 ```
 
 The [V1 Persistence Specification](https://github.com/pokt-network/pocket-network-protocol/tree/main/persistence) outlines the use of a **PostgresDB** and **Merkle Trees** to implement the `Update State Hash` component. This is an internal detail which can be done differently depending on the implementation. For the core V1 implementation, see the flows outlined [here](../../../persistence/docs/AppHash.md).

From 02f2a6b6a0ecf331d65565277c72afc6027b8753 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 17 Oct 2022 11:43:48 -0700
Subject: [PATCH 088/227] Remove merge conflict file

---
 persistence/module.go | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/persistence/module.go b/persistence/module.go
index 0d548336d..5c980fb78 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -183,18 +183,6 @@ func (m *persistenceModule) ReleaseWriteContext() error {
 	panic("INTRODUCE(#284): Add this function in #284 per the interface changes in #252.")
 }
 
-func (m *persistenceModule) ResetContext() error {
-	if m.writeContext != nil {
-		if !m.writeContext.GetTx().Conn().IsClosed() {
-			if err := m.writeContext.Release(); err != nil {
-				log.Println("[TODO][ERROR] Error releasing write context...", err)
-			}
-		}
-		m.writeContext = nil
-	}
-	return nil
-}
-
 func (m *persistenceModule) GetBlockStore() kvstore.KVStore {
 	return m.blockStore
 }

From 68ef680b461a74659e643f1a524d437b48120e55 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 17 Oct 2022 14:15:59 -0700
Subject: [PATCH 089/227] Update changelog

---
 shared/CHANGELOG.md             | 20 +++-----------------
 shared/modules/doc/CHANGELOG.md | 31 ++++++++++++++++++++++++++++++-
 2 files changed, 33 insertions(+), 18 deletions(-)

diff --git a/shared/CHANGELOG.md b/shared/CHANGELOG.md
index 0bdc40498..d8e22a15e 100644
--- a/shared/CHANGELOG.md
+++ b/shared/CHANGELOG.md
@@ -7,21 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.0.3] - 2022-10-16
-
-- Updates to the `PersistenceModule` interface
-  - Added `ReleaseWriteContext`
-  - Removed `ResetContext`
-- Updates to the `PersistenceContext` interface
-  - Removed `Reset`
-  - Changed `AppHash` `UpdateAppHash`
-  - Changed `Commit()` to `Commit(proposerAddr, quorumCert)`
-- Updates to the `UtilityContext` interface
-  - Change `ReleaseContext` to `Release`
-  - Removed `GetPersistenceContext`
-  - Changed `CommitPersistenceContext()` to `Commit(quorumCert)`
-
-## [0.0.2] - 2022-10-12
+## [0.0.0.2] - 2022-10-12
 
 ### [#235](https://github.com/pokt-network/pocket/pull/235) Config and genesis handling
 
@@ -29,7 +15,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Segregate interfaces (eg: `GenesisDependentModule`, `P2PAddressableModule`, etc)
 - Updated tests and mocks
 
-## [0.0.1] - 2022-09-30
+## [0.0.0.1] - 2022-09-30
 
 - Used proper `TODO/INVESTIGATE/DISCUSS` convention across package
 - Moved TxIndexer Package to Utility to properly encapsulate
@@ -43,7 +29,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Time mocking abilities via https://github.com/benbjohnson/clock and simple utility wrappers
 - Race conditions and concurrency fixes via sync.Mutex
 
-## [0.0.0] - 2022-08-25
+## [0.0.0.0] - 2022-08-25
 
 ### [#163](https://github.com/pokt-network/pocket/issues/163) Minimization
 
diff --git a/shared/modules/doc/CHANGELOG.md b/shared/modules/doc/CHANGELOG.md
index fd53e8c55..8fd630985 100644
--- a/shared/modules/doc/CHANGELOG.md
+++ b/shared/modules/doc/CHANGELOG.md
@@ -7,7 +7,36 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.0.3] - 2022-10-16
+
+Interface changes (w/o implementation) to support a StateHash computation.
+
+### Persistence Module Changes
+
+- Updates to the `PersistenceModule` interface
+
+  - Introduce `ReleaseWriteContext`
+  - Deprecate `ResetContext`
+
+- Updates to the `PersistenceContext` interface
+
+  - Deprecate `StoreBlock`, `InsertBlock`, `AppHash`, `Reset`, `Commit`
+  - Change `Commit()` to `Commit(proposerAddr, quorumCert)`
+  - Change `AppHash()` to `UpdateAppHash()`
+
+- Updates to the `UtilityContext` interface
+  - Deprecate `GetPersistenceContext`
+  - Change `ReleaseContext()` to `Release()`
+  - Changed `CommitPersistenceContext()` to `Commit(quorumCert)`
+
+## [0.0.0.2] - 2022-09-17
+
+- Minimized shared module with [#163](https://github.com/pokt-network/pocket/issues/163)
+- Deprecated shared/types, moved remaining interfaces to shared/modules
+- Most GenesisTypes moved to persistence
+
 ## [0.0.0.1] - 2022-08-21
+
 - Minimized shared module with [#163](https://github.com/pokt-network/pocket/issues/163)
 - Deprecated shared/types, moved remaining interfaces to shared/modules
 - Most GenesisTypes moved to persistence
@@ -36,5 +65,5 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Opened followup issue #163
 - Added config and genesis generator to build package
 - Deprecated old build files
-- Use new config and genesis files for make compose_and_watch 
+- Use new config and genesis files for make compose_and_watch
 - Use new config and genesis files for make client_start && make client_connect

From 41c01a7014943614c6dd82c7c1d995a597d176e5 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 17 Oct 2022 14:20:38 -0700
Subject: [PATCH 090/227] Minor changelog update

---
 shared/modules/doc/CHANGELOG.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/shared/modules/doc/CHANGELOG.md b/shared/modules/doc/CHANGELOG.md
index 8fd630985..4246261dc 100644
--- a/shared/modules/doc/CHANGELOG.md
+++ b/shared/modules/doc/CHANGELOG.md
@@ -20,14 +20,14 @@ Interface changes (w/o implementation) to support a StateHash computation.
 
 - Updates to the `PersistenceContext` interface
 
-  - Deprecate `StoreBlock`, `InsertBlock`, `AppHash`, `Reset`, `Commit`
   - Change `Commit()` to `Commit(proposerAddr, quorumCert)`
   - Change `AppHash()` to `UpdateAppHash()`
+  - Deprecate `StoreBlock`, `InsertBlock`, `Reset`
 
 - Updates to the `UtilityContext` interface
-  - Deprecate `GetPersistenceContext`
   - Change `ReleaseContext()` to `Release()`
   - Changed `CommitPersistenceContext()` to `Commit(quorumCert)`
+  - Deprecate `GetPersistenceContext`
 
 ## [0.0.0.2] - 2022-09-17
 

From 558965c068a9898f0a95a5561793a367caec2c36 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 17 Oct 2022 15:33:18 -0700
Subject: [PATCH 091/227] Added activations and deactivations

---
 persistence/docs/AppHash.md  | 29 ++++++++++++---------
 shared/docs/flows/AppHash.md | 49 +++++++++++++++++++++++-------------
 2 files changed, 48 insertions(+), 30 deletions(-)

diff --git a/persistence/docs/AppHash.md b/persistence/docs/AppHash.md
index d8b68d5e3..f6ae4b57e 100644
--- a/persistence/docs/AppHash.md
+++ b/persistence/docs/AppHash.md
@@ -11,16 +11,19 @@ sequenceDiagram
     participant PM as Persistence (MerkleTree)
 
     loop for each protocol actor type
-        P->>PP: GetActorsUpdated(height)
-        PP->>P: actors
-        loop update tree for each actor
-            P->>PM: Update(addr, serialized(actor))
-            PM->>P: result, err_code
+        P->>+PP: GetActorsUpdated(height)
+        PP->>-P: actors
+        loop for each state tree
+            P->>+PM: Update(addr, serialized(actor))
+            PM->>-P: result, err_code
         end
-        P->>PM: GetRoot()
-        PM->>P: rootHash
+        P->>+PM: GetRoot()
+        PM->>-P: rootHash
     end
+
     P->>P: stateHash = hash(aggregated(rootHashes))
+    activate P
+    deactivate P
 ```
 
 ## Store Block
@@ -34,11 +37,13 @@ sequenceDiagram
     participant PP as Persistence (PostgresDB)
     participant PK as Persistence (Key-Value Store)
 
+    activate P
     P->>P: reap stored transactions
-    P->>P: create & serialize<br>`typesPer.Block`
-    P->>PP: insertBlock(height, serialized(block))
-    PP->>P: result, err_code
-    P->>PK: Put(height, serialized(block))
-    PK->>P: result, err_code
+    P->>P: prepare, serialize <br> & store block
+    deactivate P
 
+    P->>+PP: insertBlock(height, serialized(block))
+    PP->>-P: result, err_code
+    P->>+PK: Put(height, serialized(block))
+    PK->>-P: result, err_code
 ```
diff --git a/shared/docs/flows/AppHash.md b/shared/docs/flows/AppHash.md
index b7b7d3ccc..9fc0ff269 100644
--- a/shared/docs/flows/AppHash.md
+++ b/shared/docs/flows/AppHash.md
@@ -4,6 +4,8 @@
 - [Block Application](#block-application)
 - [Block Commit](#block-commit)
 
+<!-- See if there's an answer in this question to add links to notes: https://stackoverflow.com/questions/74103729/adding-hyperlinks-to-notes-in-mermaid-sequence-diagrams -->
+
 ## Context Initialization
 
 This flow shows the process of context initialization between all the modules required to apply a block and compute a state hash during the consensus lifecycle.
@@ -12,7 +14,6 @@ The `Hotstuff lifecycle` part refers to the so-called `PreCommit` and `Commit` p
 
 ```mermaid
 sequenceDiagram
-    %% autonumber
     participant N as Node
     participant C as Consensus
     participant U as Utility
@@ -22,11 +23,15 @@ sequenceDiagram
     N-->>C: HandleMessage(anypb.Any)
     critical NewRound Message
         C->>+U: NewContext(height)
-        U->>P: NewRWContext(height)
-        P->>U: PersistenceRWContext
+        U->>+P: NewRWContext(height)
+        P->>-U: PersistenceRWContext
         U->>U: store context<br>locally
+        activate U
+        deactivate U
         U->>-C: UtilityContext
         C->>C: store context<br>locally
+        activate C
+        deactivate C
         Note over C, P: See 'Block Application'
     end
 
@@ -41,29 +46,33 @@ sequenceDiagram
 ## Block Application
 
 This flow shows how the `leader` and the `replica`s behave in order to apply a `block` and return a `stateHash`.
+
 ```mermaid
 sequenceDiagram
     participant C as Consensus
     participant U as Utility
     participant P as Persistence
 
+    %% Prepare or get block as leader
     opt if leader
         C->>U: GetProposalTransactions(proposer, maxTxBz, [lastVal])
         activate U
-        alt no quorum for Prepare
-        U->>U: reap mempool
+        alt no QC in NewRound
+        U->>U: reap mempool <br> & prepare block
         activate U
         deactivate U
-        else
-        U->>U: get QC
+    else
+        U->>U: find QC <br> & get block
         activate U
         deactivate U
         end
         U-->>C: txs
         deactivate U
     end
+
+    %% Apply block as leader or replica
     C->>+U: ApplyBlock(height, proposer, txs, lastVals)
-    loop for each tx in txs
+    loop [for each op in tx] for each tx in txs
         U->>+P: Get*/Set*
         P-->>-U: result, err_code
         U->>U: Validation logic
@@ -89,21 +98,25 @@ The [V1 Persistence Specification](https://github.com/pokt-network/pocket-networ
 
 ```mermaid
 sequenceDiagram
-    %% autonumber
     participant C as Consensus
     participant U as Utility
     participant P as Persistence
 
-    C->>U: CommitContext(quorumCert)
-    U->>P: Commit(proposerAddr, quorumCert)
-    P->>P: reap stored transactions
-    Note over P: Create And Store Block
-    P->>U: result, err_code
-    U->>P: Release()
-    P->>U: result, err_code
-    C->>U: Release()
-    U->>C: result, err_code
+    %% Commit Context
+    C->>+U: CommitContext(quorumCert)
+    U->>+P: Commit(proposerAddr, quorumCert)
+    P->>P: See 'Store Block'
+    P->>-U: result, err_code
+    U->>+P: Release()
+    P->>-U: result, err_code
+    deactivate U
+
+    %% Release Context
+    C->>+U: Release()
+    U->>-C: result, err_code
     C->>C: release utilityContext
+    activate C
+    deactivate C
 ```
 
 The [V1 Persistence Specification](https://github.com/pokt-network/pocket-network-protocol/tree/main/persistence) outlines the use of a **key-value store** to implement the `Create And Store Block` component. This is an internal detail which can be done differently depending on the implementation. For the core V1 implementation, see the flows outlined [here](../../../persistence/docs/AppHash.md).

From 0d5df3ab588f1b4fdebff14c08371cc056428ee3 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 17 Oct 2022 16:39:11 -0700
Subject: [PATCH 092/227] Fix tests

---
 persistence/module.go          | 14 ++------------
 persistence/test/setup_test.go |  2 +-
 persistence/test/state_test.go |  6 +++---
 3 files changed, 6 insertions(+), 16 deletions(-)

diff --git a/persistence/module.go b/persistence/module.go
index 4eb9da7e2..ee8e34fc2 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -28,20 +28,13 @@ type persistenceModule struct {
 	config       modules.PersistenceConfig
 	genesisState modules.PersistenceGenesisState
 
-	// postgresURL string
-	// nodeSchema  string
-	// genesisPath string
-
 	// TECHDEBT: Need to implement context pooling (for writes), timeouts (for read & writes), etc...
 	writeContext *PostgresContext // only one write context is allowed at a time
 
 	// The connection to the PostgreSQL database
 	postgresConn *pgx.Conn
 	// A reference to the block key-value store
-	// INVESTIGATE: We may need to create a custom `BlockStore` package in the future.
-	blockStore kvstore.KVStore
-	// A mapping of context IDs to persistence contexts
-	// contexts map[contextId]modules.PersistenceRWContext
+	blockStore kvstore.KVStore // INVESTIGATE: We may need to create a custom `BlockStore` package in the future.
 	// Merkle trees
 	trees map[MerkleTree]*smt.SparseMerkleTree
 }
@@ -94,15 +87,12 @@ func (*persistenceModule) Create(runtimeMgr modules.RuntimeMgr) (modules.Module,
 		trees: make(map[MerkleTree]*smt.SparseMerkleTree),
 	}
 
-	// DISCUSS_IN_THIS_COMMIT: We've been using the module function pattern, but this making `initializeTrees`
-	// be able to create and/or load trees outside the scope of the persistence module makes it easier to test.
 	trees, err := newMerkleTrees()
 	if err != nil {
 		return nil, err
 	}
 
-	// TODO_IN_THIS_COMMIT: load trees from state
-	m.trees = trees
+	m.trees = trees // TODO_IN_THIS_COMMIT: load trees from state
 
 	// Determine if we should hydrate the genesis db or use the current state of the DB attached
 	if shouldHydrateGenesis, err := m.shouldHydrateGenesisDb(); err != nil {
diff --git a/persistence/test/setup_test.go b/persistence/test/setup_test.go
index e685c6e67..3934be4d4 100644
--- a/persistence/test/setup_test.go
+++ b/persistence/test/setup_test.go
@@ -65,7 +65,7 @@ func NewTestPostgresContext(t *testing.T, height int64) *persistence.PostgresCon
 	require.True(t, ok)
 
 	t.Cleanup(func() {
-		require.NoError(t, db.Release())
+		// require.NoError(t, db.Release())
 		require.NoError(t, db.ResetContext())
 	})
 
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index ab3365af7..1079e1827 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -15,9 +15,9 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 	// These hashes were determined manually by running the test, but hardcoded to guarantee
 	// that the business logic doesn't change and that they remain deterministic.
 	encodedAppHash := []string{
-		"a405c3db598c9898c61b76c77f3e1ed94277a2bc683fbc4f9bd502c47633d617",
-		"e431c357c0e0d9ef5999b52bc18d36aa0e1bedbd555a82dd5e8a8130b6b8fa6b",
-		"a46c8024472f50a4ab887b8b1e06fdc578f0344eada2d68784325c27e74d6529",
+		"62adad6925267abe075dc62ffb9b8d960709409b097b75dd6b3ea4cce31d1482",
+		"c1af3fda156bce4162df755f0095ae4f909477fc385f761c6e8d2ef6eb2d9fa6",
+		"e65d0c2cd78f180d774bfe43e52a49fad490bf208fcc6d167f2b6543ab280cb9",
 	}
 
 	for i := 0; i < 3; i++ {

From 4c05a2c10e52938da7fa6824fb38cdf680f37500 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 19 Oct 2022 20:45:33 -0700
Subject: [PATCH 093/227] Add call to tx exists

---
 shared/docs/flows/AppHash.md | 24 ++++++++++++++----------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/shared/docs/flows/AppHash.md b/shared/docs/flows/AppHash.md
index 9fc0ff269..b5598a339 100644
--- a/shared/docs/flows/AppHash.md
+++ b/shared/docs/flows/AppHash.md
@@ -73,16 +73,20 @@ sequenceDiagram
     %% Apply block as leader or replica
     C->>+U: ApplyBlock(height, proposer, txs, lastVals)
     loop [for each op in tx] for each tx in txs
-        U->>+P: Get*/Set*
-        P-->>-U: result, err_code
-        U->>U: Validation logic
-        activate U
-        deactivate U
-        U->>+P: StoreTransaction(tx)
-        P->>P: Store tx locally
-        activate P
-        deactivate P
-        P-->>-U: result, err_code
+        U->>+P: TransactionExists(txHash)
+        P->>-U: true | false
+        opt if tx is not indexed
+            U->>+P: Get*/Set*
+            P-->>-U: result, err_code
+            U->>U: Validation logic
+            activate U
+            deactivate U
+            U->>+P: StoreTransaction(tx)
+            P->>P: Store tx locally
+            activate P
+            deactivate P
+            P-->>-U: result, err_code
+        end
     end
     U->>+P: UpdateAppHash()
     P->>P: Update state hash

From 36aee3f7ca0b6550ef987f685f0bfe4b131d968c Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Fri, 21 Oct 2022 14:38:27 -0700
Subject: [PATCH 094/227] Fix up changelog

---
 shared/modules/doc/CHANGELOG.md | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/shared/modules/doc/CHANGELOG.md b/shared/modules/doc/CHANGELOG.md
index e30b5d264..5cc114ed7 100644
--- a/shared/modules/doc/CHANGELOG.md
+++ b/shared/modules/doc/CHANGELOG.md
@@ -7,7 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.0.0.5] - 2022-10-16
+## [0.0.0.3] - 2022-10-20
 
 Interface changes (w/o implementation) to support a StateHash computation.
 
@@ -29,17 +29,12 @@ Interface changes (w/o implementation) to support a StateHash computation.
   - Changed `CommitPersistenceContext()` to `Commit(quorumCert)`
   - Deprecate `GetPersistenceContext`
 
-## [0.0.0.3] - 2022-10-12
+## [0.0.0.2] - 2022-10-12
 
 - Modified interface for Utility Module `ApplyBlock` and `GetProposalTransactions` to return `TxResults`
 - Modified interface for Persistence Module `StoreTransaction` to store the `TxResult`
 - Added shared interface `TxResult` under types.go
 
-## [0.0.0.2] - 2022-09-17
-
-- Minimized shared module with [#163](https://github.com/pokt-network/pocket/issues/163)
-- Deprecated shared/types, moved remaining interfaces to shared/modules
-
 # Most GenesisTypes moved to persistence
 
 ## [0.0.0.1] - 2022-08-21

From 79bba7dcf5c168e559254755913e6356e6e9a4ac Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Fri, 21 Oct 2022 21:25:56 -0700
Subject: [PATCH 095/227] Interim commit

---
 persistence/test/state_test.go | 5 +++--
 utility/test/module_test.go    | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index 1079e1827..45c9f3294 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -42,8 +42,9 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 
 		// NOTE: The tx does not currently affect the state hash
 		txBz := []byte("a tx, i am, which set the app stake amount to " + newStakeAmount)
-		err = db.StoreTransaction(txBz)
-		require.NoError(t, err)
+		// txResult := types.DefaultTx
+		// err = db.StoreTransaction(txBz)
+		// require.NoError(t, err)
 
 		// Update & commit the state hash
 		appHash, err := db.UpdateAppHash()
diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index 11a314b69..17c67f7fb 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -60,7 +60,7 @@ func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext
 	require.NoError(t, err)
 
 	t.Cleanup(func() {
-		persistenceContext.ReleaseWriteContext()
+		persistenceContext.Release()
 	})
 
 	return utility.UtilityContext{

From 843d5090bd8c513ee4ac0b5c9284aa9d60f3d721 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 24 Oct 2022 20:50:46 -0700
Subject: [PATCH 096/227] Replied to most comments

---
 persistence/StateHash.md                  |  2 +-
 persistence/block.go                      | 15 ++++++----
 persistence/context.go                    |  4 +++
 persistence/debug.go                      |  2 +-
 persistence/indexer/indexer.go            | 12 ++++----
 persistence/kvstore/kvstore.go            | 36 ++++++++---------------
 persistence/module.go                     | 15 +++++-----
 persistence/proto/block_persistence.proto |  2 ++
 persistence/shared_sql.go                 |  2 +-
 persistence/test/setup_test.go            |  1 -
 persistence/test/state_test.go            | 17 +++++++++--
 persistence/types/base_actor.go           |  2 +-
 utility/block.go                          | 11 +++----
 utility/context.go                        |  4 +--
 14 files changed, 67 insertions(+), 58 deletions(-)

diff --git a/persistence/StateHash.md b/persistence/StateHash.md
index 24f1d2e65..1ec5d0ef2 100644
--- a/persistence/StateHash.md
+++ b/persistence/StateHash.md
@@ -1,4 +1,4 @@
-DO NOT READ YET
+ROUGH NOTES - DELETE LATER
 
 1.  Simplify interfaces in utility & persistence (make it simple and clear)
 2.  How do we revert changes to the merkle trees?
diff --git a/persistence/block.go b/persistence/block.go
index 32edae2ae..854a6f5f4 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -76,7 +76,7 @@ func (p PostgresContext) storeBlock(block *types.Block) error {
 	if err != nil {
 		return err
 	}
-	return p.blockStore.Put(HeightToBytes(p.Height), blockBz)
+	return p.blockStore.Set(heightToBytes(p.Height), blockBz)
 }
 
 func (p *PostgresContext) prepareBlock(proposerAddr []byte, quorumCert []byte) (*types.Block, error) {
@@ -91,26 +91,29 @@ func (p *PostgresContext) prepareBlock(proposerAddr []byte, quorumCert []byte) (
 		prevHash = []byte("HACK: get hash from genesis")
 	}
 
-	_, err := p.txIndexer.GetByHeight(p.Height, false)
+	txResults, err := p.txIndexer.GetByHeight(p.Height, false)
 	if err != nil {
 		return nil, err
 	}
 
+	txs := make([][]byte, len(txResults))
+	for i, txResult := range txResults {
+		txs[i] = txResult.GetTx()
+	}
+
 	block := &types.Block{
 		Height:            uint64(p.Height),
 		Hash:              hex.EncodeToString(p.currentStateHash),
 		PrevHash:          hex.EncodeToString(prevHash),
 		ProposerAddress:   proposerAddr,
 		QuorumCertificate: quorumCert,
-		// Transactions:      []byte(""),
+		Transactions:      txs,
 	}
 
 	return block, nil
 }
 
-// CLEANUP: Should this be moved to a shared directory?
-// Exposed for testing purposes
-func HeightToBytes(height int64) []byte {
+func heightToBytes(height int64) []byte {
 	heightBytes := make([]byte, 8)
 	binary.LittleEndian.PutUint64(heightBytes, uint64(height))
 	return heightBytes
diff --git a/persistence/context.go b/persistence/context.go
index 18fbf3200..4f675ddb7 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -22,18 +22,22 @@ func (p *PostgresContext) UpdateAppHash() ([]byte, error) {
 	return p.currentStateHash, nil
 }
 
+// TODO_IN_THIS_COMMIT: Make sure that `prepareBlock`, `insertBlock`, and `storeBlock` are all atomic.
 func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
+	// Create a persistence block proto
 	block, err := p.prepareBlock(proposerAddr, quorumCert)
 	if err != nil {
 		return err
 	}
 
+	// Insert the block into the postgres DB
 	if err := p.insertBlock(block); err != nil {
 		return err
 	}
 
+	// Store block in the KV store
 	if err := p.storeBlock(block); err != nil {
 		return err
 	}
diff --git a/persistence/debug.go b/persistence/debug.go
index 500eace23..f6a729d05 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -27,7 +27,7 @@ func (m *persistenceModule) HandleDebugMessage(debugMessage *debug.DebugMessage)
 func (m *persistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 	// TODO: Add an iterator to the `kvstore` and use that instead
 	height := m.GetBus().GetConsensusModule().CurrentHeight() - 1 // -1 because we want the latest committed height
-	blockBytes, err := m.GetBlockStore().Get(HeightToBytes(int64(height)))
+	blockBytes, err := m.GetBlockStore().Get(heightToBytes(int64(height)))
 	if err != nil {
 		log.Printf("Error getting block %d from block store: %s \n", height, err)
 		return
diff --git a/persistence/indexer/indexer.go b/persistence/indexer/indexer.go
index 02a3ec8b9..0b4bfbe46 100644
--- a/persistence/indexer/indexer.go
+++ b/persistence/indexer/indexer.go
@@ -85,8 +85,8 @@ func NewTxIndexer(databasePath string) (TxIndexer, error) {
 	if databasePath == "" {
 		return NewMemTxIndexer()
 	}
-	// db, err := kvstore.NewKVStore(databasePath)
-	db, err := kvstore.OpenKVStore(databasePath)
+
+	db, err := kvstore.NewKVStore(databasePath)
 	return &txIndexer{
 		db: db,
 	}, err
@@ -173,22 +173,22 @@ func (indexer *txIndexer) get(key []byte) (shared.TxResult, error) {
 
 func (indexer *txIndexer) indexByHash(hash, bz []byte) (hashKey []byte, err error) {
 	key := indexer.hashKey(hash)
-	return key, indexer.db.Put(key, bz)
+	return key, indexer.db.Set(key, bz)
 }
 
 func (indexer *txIndexer) indexByHeightAndIndex(height int64, index int32, bz []byte) error {
-	return indexer.db.Put(indexer.heightAndIndexKey(height, index), bz)
+	return indexer.db.Set(indexer.heightAndIndexKey(height, index), bz)
 }
 
 func (indexer *txIndexer) indexBySender(sender string, bz []byte) error {
-	return indexer.db.Put(indexer.senderKey(sender), bz)
+	return indexer.db.Set(indexer.senderKey(sender), bz)
 }
 
 func (indexer *txIndexer) indexByRecipient(recipient string, bz []byte) error {
 	if recipient == "" {
 		return nil
 	}
-	return indexer.db.Put(indexer.recipientKey(recipient), bz)
+	return indexer.db.Set(indexer.recipientKey(recipient), bz)
 }
 
 // key helper functions
diff --git a/persistence/kvstore/kvstore.go b/persistence/kvstore/kvstore.go
index 986448612..7b1a95440 100644
--- a/persistence/kvstore/kvstore.go
+++ b/persistence/kvstore/kvstore.go
@@ -9,6 +9,8 @@ import (
 )
 
 type KVStore interface {
+	smt.MapStore
+
 	// Lifecycle methods
 	Stop() error
 
@@ -19,11 +21,6 @@ type KVStore interface {
 
 	Exists(key []byte) (bool, error)
 	ClearAll() error
-
-	// Same interface as in `smt.MapStore``
-	Put(key, value []byte) error
-	Get(key []byte) ([]byte, error)
-	Delete(key []byte) error
 }
 
 const (
@@ -42,15 +39,12 @@ type badgerKVStore struct {
 	db *badger.DB
 }
 
-// REFACTOR: Loads or creates a badgerDb at `path`. This may potentially need to be refactored
-// into `NewKVStore` and `LoadKVStore` depending on how state sync evolves by leveraging `os.Stat`
-// on the file path.
-func OpenKVStore(path string) (KVStore, error) {
+func NewKVStore(path string) (KVStore, error) {
 	db, err := badger.Open(badger.DefaultOptions(path))
 	if err != nil {
 		return nil, err
 	}
-	return badgerKVStore{db: db}, nil
+	return &badgerKVStore{db: db}, nil
 }
 
 func NewMemKVStore() KVStore {
@@ -58,10 +52,10 @@ func NewMemKVStore() KVStore {
 	if err != nil {
 		log.Fatal(err)
 	}
-	return badgerKVStore{db: db}
+	return &badgerKVStore{db: db}
 }
 
-func (store badgerKVStore) Put(key, value []byte) error {
+func (store *badgerKVStore) Set(key, value []byte) error {
 	tx := store.db.NewTransaction(true)
 	defer tx.Discard()
 
@@ -73,13 +67,7 @@ func (store badgerKVStore) Put(key, value []byte) error {
 	return tx.Commit()
 }
 
-// CONSOLIDATE: We might be able to remove the `KVStore` interface altogether if we end up using `smt.MapStore`
-// A wrapper around `Put` to conform to the `smt.MapStore` interface
-func (store *badgerKVStore) Set(key, value []byte) error {
-	return store.Put(key, value)
-}
-
-func (store badgerKVStore) Get(key []byte) ([]byte, error) {
+func (store *badgerKVStore) Get(key []byte) ([]byte, error) {
 	tx := store.db.NewTransaction(false)
 	defer tx.Discard()
 
@@ -100,12 +88,12 @@ func (store badgerKVStore) Get(key []byte) ([]byte, error) {
 	return value, nil
 }
 
-func (store badgerKVStore) Delete(key []byte) error {
+func (store *badgerKVStore) Delete(key []byte) error {
 	log.Fatalf("badgerKVStore.Delete not implemented yet")
 	return nil
 }
 
-func (store badgerKVStore) GetAll(prefix []byte, descending bool) (values [][]byte, err error) {
+func (store *badgerKVStore) GetAll(prefix []byte, descending bool) (values [][]byte, err error) {
 	// INVESTIGATE: research `badger.views` for further improvements and optimizations
 	txn := store.db.NewTransaction(false)
 	defer txn.Discard()
@@ -134,7 +122,7 @@ func (store badgerKVStore) GetAll(prefix []byte, descending bool) (values [][]by
 	return
 }
 
-func (store badgerKVStore) Exists(key []byte) (bool, error) {
+func (store *badgerKVStore) Exists(key []byte) (bool, error) {
 	val, err := store.Get(key)
 	if err != nil {
 		return false, err
@@ -142,11 +130,11 @@ func (store badgerKVStore) Exists(key []byte) (bool, error) {
 	return val != nil, nil
 }
 
-func (store badgerKVStore) ClearAll() error {
+func (store *badgerKVStore) ClearAll() error {
 	return store.db.DropAll()
 }
 
-func (store badgerKVStore) Stop() error {
+func (store *badgerKVStore) Stop() error {
 	return store.db.Close()
 }
 
diff --git a/persistence/module.go b/persistence/module.go
index 3e818bed0..0b0e94bfc 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -37,8 +37,6 @@ type persistenceModule struct {
 	// TECHDEBT: Need to implement context pooling (for writes), timeouts (for read & writes), etc...
 	writeContext *PostgresContext // only one write context is allowed at a time
 
-	// The connection to the PostgreSQL database
-	postgresConn *pgx.Conn
 	// Merkle trees
 	trees map[MerkleTree]*smt.SparseMerkleTree
 }
@@ -93,16 +91,15 @@ func (*persistenceModule) Create(runtimeMgr modules.RuntimeMgr) (modules.Module,
 		blockStore:   blockStore,
 		txIndexer:    txIndexer,
 		writeContext: nil,
-		// contexts:     make(map[contextId]modules.PersistenceContext),
-		trees: make(map[MerkleTree]*smt.SparseMerkleTree),
+		trees:        make(map[MerkleTree]*smt.SparseMerkleTree),
 	}
 
+	// TODO_IN_THIS_COMMIT: load trees from state
 	trees, err := newMerkleTrees()
 	if err != nil {
 		return nil, err
 	}
-
-	m.trees = trees // TODO_IN_THIS_COMMIT: load trees from state
+	m.trees = trees
 
 	// Determine if we should hydrate the genesis db or use the current state of the DB attached
 	if shouldHydrateGenesis, err := m.shouldHydrateGenesisDb(); err != nil {
@@ -175,8 +172,10 @@ func (m *persistenceModule) NewRWContext(height int64) (modules.PersistenceRWCon
 		conn:   conn,
 		tx:     tx,
 
+		// TODO_IN_THIS_COMMIT: Does this tate need to be maintained?
 		currentStateHash: make([]byte, 0),
 
+		// TODO_IN_THIS_COMMIT: Can we access these via the bus?
 		blockStore:  m.blockStore,
 		merkleTrees: m.trees,
 		txIndexer:   m.txIndexer,
@@ -233,7 +232,7 @@ func initializeBlockStore(blockStorePath string) (kvstore.KVStore, error) {
 	if blockStorePath == "" {
 		return kvstore.NewMemKVStore(), nil
 	}
-	return kvstore.OpenKVStore(blockStorePath)
+	return kvstore.NewKVStore(blockStorePath)
 }
 
 // TODO(drewsky): Simplify and externalize the logic for whether genesis should be populated and
@@ -250,5 +249,5 @@ func (m *persistenceModule) shouldHydrateGenesisDb() (bool, error) {
 		return true, nil
 	}
 
-	return m.blockStore.Exists(HeightToBytes(int64(maxHeight)))
+	return m.blockStore.Exists(heightToBytes(int64(maxHeight)))
 }
diff --git a/persistence/proto/block_persistence.proto b/persistence/proto/block_persistence.proto
index 0c314690d..7a69403ea 100644
--- a/persistence/proto/block_persistence.proto
+++ b/persistence/proto/block_persistence.proto
@@ -9,5 +9,7 @@ message Block {
     string prevHash = 3;
     bytes proposerAddress = 4;
     bytes quorumCertificate = 5;
+    // REARCHITECT_IN_THIS_COMMIT: Since transactions are stored in the TX Indexer, do we only
+    // need a collective hash here or all the bytes?
     repeated bytes transactions = 6;
 }
\ No newline at end of file
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
index b7e1f047b..9ce0c535f 100644
--- a/persistence/shared_sql.go
+++ b/persistence/shared_sql.go
@@ -54,6 +54,7 @@ func (p *PostgresContext) GetActorsUpdated(actorSchema types.ProtocolActorSchema
 	if err != nil {
 		return nil, err
 	}
+	defer rows.Close()
 
 	addrs := make([][]byte, 0)
 	for rows.Next() {
@@ -95,7 +96,6 @@ func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, addres
 	return p.GetChainsForActor(ctx, tx, actorSchema, actor, height)
 }
 
-// IMPORTANT: Need to consolidate `persistence/types.BaseActor` with `persistence/genesisTypes.Actor`
 func (p *PostgresContext) GetActorFromRow(row pgx.Row) (actor *types.Actor, height int64, err error) {
 	err = row.Scan(
 		&actor.Address,
diff --git a/persistence/test/setup_test.go b/persistence/test/setup_test.go
index c061b3ace..fe92880b5 100644
--- a/persistence/test/setup_test.go
+++ b/persistence/test/setup_test.go
@@ -65,7 +65,6 @@ func NewTestPostgresContext(t *testing.T, height int64) *persistence.PostgresCon
 	require.True(t, ok)
 
 	t.Cleanup(func() {
-		// require.NoError(t, db.Release())
 		require.NoError(t, db.ResetContext())
 	})
 
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index 45c9f3294..113be2cc1 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -1,11 +1,11 @@
 package test
 
 import (
+	"encoding/binary"
 	"encoding/hex"
 	"math/big"
 	"testing"
 
-	"github.com/pokt-network/pocket/persistence"
 	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/stretchr/testify/require"
@@ -23,7 +23,7 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 	for i := 0; i < 3; i++ {
 		// Get the context at the new height and retrieve one of the apps
 		height := int64(i + 1)
-		heightBz := persistence.HeightToBytes(height)
+		heightBz := heightToBytes(height)
 		expectedAppHash := encodedAppHash[i]
 
 		db := NewTestPostgresContext(t, height)
@@ -70,3 +70,16 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 
 	}
 }
+
+// Tests/debug to implement:
+// - Visibility into what's in the tree
+// - Benchmarking many inserts
+// - Release / revert mid block and making sure everything is reverted
+// - Thinking about how it can be synched
+// - Playing back several blocks
+
+func heightToBytes(height int64) []byte {
+	heightBytes := make([]byte, 8)
+	binary.LittleEndian.PutUint64(heightBytes, uint64(height))
+	return heightBytes
+}
diff --git a/persistence/types/base_actor.go b/persistence/types/base_actor.go
index 67c255c39..a0c65ca6c 100644
--- a/persistence/types/base_actor.go
+++ b/persistence/types/base_actor.go
@@ -1,6 +1,6 @@
 package types
 
-// IMPROVE: Move schema related functions to a separate sub-package
+// CLEANUP: Move schema related functions to a separate sub-package
 import "github.com/pokt-network/pocket/shared/modules"
 
 var _ ProtocolActorSchema = &BaseProtocolActorSchema{}
diff --git a/utility/block.go b/utility/block.go
index 567c935b6..54646aa1d 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -98,11 +98,12 @@ func (u *UtilityContext) EndBlock(proposer []byte) typesUtil.Error {
 
 func (u *UtilityContext) GetAppHash() ([]byte, typesUtil.Error) {
 	// Get the root hash of the merkle state tree for state consensus integrity
-	appHash, er := u.Context.UpdateAppHash()
-	if er != nil {
-		return nil, typesUtil.ErrAppHash(er)
-	}
-	return appHash, nil
+	// appHash, er := u.Context.UpdateAppHash()
+	// if er != nil {
+	// 	return nil, typesUtil.ErrAppHash(er)
+	// }
+	// return appHash, nil
+	panic("TODO_IN_THIS_COMMIT: Do we need this function in the utility context?")
 }
 
 // HandleByzantineValidators handles the validators who either didn't sign at all or disagreed with the 2/3+ majority
diff --git a/utility/context.go b/utility/context.go
index 7f0aad166..10f834550 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -9,8 +9,8 @@ import (
 )
 
 type UtilityContext struct {
-	LatestHeight    int64 // IMPROVE: Rename to `currentHeight?`
-	currentProposer []byte
+	LatestHeight    int64  // IMPROVE: Rename to `currentHeight?`
+	currentProposer []byte // REARCHITECT_IN_THIS_COMMIT: Ephemeral block state should only exist in the persistence context
 
 	Mempool typesUtil.Mempool
 	Context *Context // IMPROVE: Rename to `persistenceContext` or `storeContext` or `reversibleContext`?

From 27890a502a13473ad127e659e36afb18ddda2b1b Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 24 Oct 2022 21:08:10 -0700
Subject: [PATCH 097/227] Tests passing

---
 persistence/module.go                | 3 ++-
 persistence/test/module_test.go      | 4 ++--
 shared/modules/persistence_module.go | 2 +-
 utility/test/module_test.go          | 2 +-
 4 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/persistence/module.go b/persistence/module.go
index 010c1e3fe..aa16dd590 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -3,9 +3,10 @@ package persistence
 import (
 	"context"
 	"fmt"
-	"github.com/pokt-network/pocket/persistence/indexer"
 	"log"
 
+	"github.com/pokt-network/pocket/persistence/indexer"
+
 	"github.com/pokt-network/pocket/persistence/types"
 
 	"github.com/jackc/pgx/v4"
diff --git a/persistence/test/module_test.go b/persistence/test/module_test.go
index 0dbf2d580..040612eff 100644
--- a/persistence/test/module_test.go
+++ b/persistence/test/module_test.go
@@ -8,7 +8,7 @@ import (
 
 func TestPersistenceContextParallelReadWrite(t *testing.T) {
 	t.Cleanup(func() {
-		require.NoError(t, testPersistenceMod.NewWriteContext().ResetContext())
+		require.NoError(t, testPersistenceMod.NewWriteContext().Release())
 	})
 	// variables for testing
 	poolName := "fake"
@@ -50,7 +50,7 @@ func TestPersistenceContextParallelReadWrite(t *testing.T) {
 
 func TestPersistenceContextTwoWritesErrors(t *testing.T) {
 	t.Cleanup(func() {
-		require.NoError(t, testPersistenceMod.NewWriteContext().ResetContext())
+		require.NoError(t, testPersistenceMod.NewWriteContext().Release())
 	})
 	// Opening up first write context succeeds
 	_, err := testPersistenceMod.NewRWContext(0)
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index d42ca9103..05a8954a9 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -18,7 +18,7 @@ type PersistenceModule interface {
 	ReleaseWriteContext() error // Only one write context can exist at a time
 
 	// BlockStore interface
-	ResetContext() error // DEPRECATE(#252): Remove in #284 per the interface changes in #252
+	// ResetContext() error // DEPRECATE(#252): Remove in #284 per the interface changes in #252
 	GetBlockStore() kvstore.KVStore
 	NewWriteContext() PersistenceRWContext
 
diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index bff893f0d..d17dcab04 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -60,7 +60,7 @@ func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext
 	require.NoError(t, err)
 
 	t.Cleanup(func() {
-		persistenceContext.ResetContext()
+		persistenceContext.Release()
 	})
 
 	return utility.UtilityContext{

From f27bc50bf9fe00b59569dbd775439d63d8437d09 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 25 Oct 2022 14:36:47 -0700
Subject: [PATCH 098/227] Interim commit while utility tests are failing

---
 Makefile                            | 4 ++--
 consensus/block.go                  | 8 ++++----
 persistence/genesis.go              | 7 +++++--
 persistence/test/setup_test.go      | 2 ++
 runtime/test_artifacts/generator.go | 6 ++++--
 utility/block.go                    | 8 +-------
 utility/test/module_test.go         | 3 +++
 7 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/Makefile b/Makefile
index 2101964f1..ecf6e8890 100644
--- a/Makefile
+++ b/Makefile
@@ -274,9 +274,9 @@ test_shared: # generate_mocks
 	go test ${VERBOSE_TEST} -p 1 ./shared/...
 
 .PHONY: test_consensus
-## Run all go unit tests in the Consensus module
+## Run all go unit tests in the consensus module
 test_consensus: # mockgen
-	go test ${VERBOSE_TEST} ./consensus/...
+	go test ${VERBOSE_TEST} -count=1 ./consensus/...
 
 .PHONY: test_consensus_concurrent_tests
 ## Run unit tests in the consensus module that could be prone to race conditions (#192)
diff --git a/consensus/block.go b/consensus/block.go
index cd3bdb4e4..27b4ee00c 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -10,10 +10,10 @@ import (
 func (m *consensusModule) commitBlock(block *typesCons.Block) error {
 	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
 
-	// Commit and release the context
-	if err := m.utilityContext.Commit(block.BlockHeader.QuorumCertificate); err != nil {
-		return err
-	}
+	// // Commit and release the context
+	// if err := m.utilityContext.Commit(block.BlockHeader.QuorumCertificate); err != nil {
+	// 	return err
+	// }
 
 	if err := m.utilityContext.Release(); err != nil {
 		return err
diff --git a/persistence/genesis.go b/persistence/genesis.go
index 29d636fd2..f559c4979 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -149,8 +149,11 @@ func (m *persistenceModule) populateGenesisState(state modules.PersistenceGenesi
 		log.Fatalf("an error occurred initializing flags: %s", err.Error())
 	}
 
-	if err = rwContext.Commit([]byte("HACK: genesisProposerPlaceholder"), []byte("HACK: genesisQuorumCertPlaceholder")); err != nil {
-		log.Fatalf("an error occurred during commit() on genesis state %s ", err.Error())
+	if err = rwContext.Commit(
+		[]byte("HACK_IN_THIS_COMMIT: genesisProposerPlaceholder"),
+		[]byte("HACK_IN_THIS_COMMIT: genesisQuorumCertPlaceholder"),
+	); err != nil {
+		log.Fatalf("error committing populateGenesisState %s ", err.Error())
 	}
 }
 
diff --git a/persistence/test/setup_test.go b/persistence/test/setup_test.go
index fe92880b5..a1316b09c 100644
--- a/persistence/test/setup_test.go
+++ b/persistence/test/setup_test.go
@@ -65,6 +65,8 @@ func NewTestPostgresContext(t *testing.T, height int64) *persistence.PostgresCon
 	require.True(t, ok)
 
 	t.Cleanup(func() {
+		// require.NoError(db.DebugClearAll())
+		// require.NoError(t, db.Release())
 		require.NoError(t, db.ResetContext())
 	})
 
diff --git a/runtime/test_artifacts/generator.go b/runtime/test_artifacts/generator.go
index 142a04474..815a4458b 100644
--- a/runtime/test_artifacts/generator.go
+++ b/runtime/test_artifacts/generator.go
@@ -134,7 +134,8 @@ func NewPools() (pools []modules.Account) { // TODO (Team) in the real testing s
 
 func NewAccounts(n int, privateKeys ...string) (accounts []modules.Account) {
 	for i := 0; i < n; i++ {
-		_, _, addr := GenerateNewKeysDeterministic(69)
+		// _, _, addr := GenerateNewKeysDeterministic(69)
+		_, _, addr := GenerateNewKeysStrings()
 		if privateKeys != nil {
 			pk, _ := crypto.NewPrivateKey(privateKeys[i])
 			addr = pk.Address().String()
@@ -168,7 +169,8 @@ func getServiceUrl(n int) string {
 }
 
 func NewDefaultActor(actorType int32, genericParam string) (actor modules.Actor, privateKey string) {
-	privKey, pubKey, addr := GenerateNewKeysDeterministic(69)
+	// privKey, pubKey, addr := GenerateNewKeysDeterministic(69)
+	privKey, pubKey, addr := GenerateNewKeysStrings()
 	chains := DefaultChains
 	if actorType == int32(typesPers.ActorType_Val) {
 		chains = nil
diff --git a/utility/block.go b/utility/block.go
index 54646aa1d..f1b872fda 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -97,13 +97,7 @@ func (u *UtilityContext) EndBlock(proposer []byte) typesUtil.Error {
 }
 
 func (u *UtilityContext) GetAppHash() ([]byte, typesUtil.Error) {
-	// Get the root hash of the merkle state tree for state consensus integrity
-	// appHash, er := u.Context.UpdateAppHash()
-	// if er != nil {
-	// 	return nil, typesUtil.ErrAppHash(er)
-	// }
-	// return appHash, nil
-	panic("TODO_IN_THIS_COMMIT: Do we need this function in the utility context?")
+	panic("DISCUSS_IN_THIS_COMMIT: Can we remove this function from the utility context?")
 }
 
 // HandleByzantineValidators handles the validators who either didn't sign at all or disagreed with the 2/3+ majority
diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index d17dcab04..21a3220a8 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -2,6 +2,7 @@ package test
 
 import (
 	"encoding/hex"
+	"fmt"
 	"math/big"
 	"os"
 	"testing"
@@ -54,12 +55,14 @@ func TestMain(m *testing.M) {
 }
 
 func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext {
+	fmt.Println("OLSH HERE")
 	testPersistenceMod := newTestPersistenceModule(t, persistenceDbUrl)
 
 	persistenceContext, err := testPersistenceMod.NewRWContext(height)
 	require.NoError(t, err)
 
 	t.Cleanup(func() {
+		// persistenceContext.DebugClearAll()
 		persistenceContext.Release()
 	})
 

From 244318ba1e4e3b3ca40ac25863f979edcb5612eb Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 25 Oct 2022 21:36:19 -0700
Subject: [PATCH 099/227] Make test_utility works

---
 Makefile                             |   5 +
 build/sql/show_all_schemas.sql       |   1 +
 consensus/block.go                   |   8 +-
 persistence/context.go               |  30 +++++-
 persistence/db.go                    |  56 ++++-------
 persistence/debug.go                 |  17 ++--
 persistence/genesis.go               |   3 -
 persistence/module.go                |  29 +++---
 persistence/shared_sql.go            |   1 +
 persistence/test/setup_test.go       |   8 +-
 persistence/types/account.go         |   8 ++
 runtime/test_artifacts/util.go       |   4 +-
 shared/modules/persistence_module.go |   3 +
 utility/test/actor_test.go           | 144 ++++++++++++++-------------
 utility/test/block_test.go           | 134 +++++++++++++------------
 utility/test/module_test.go          |   6 +-
 utility/types/message_test.go        |   3 +-
 17 files changed, 238 insertions(+), 222 deletions(-)
 create mode 100644 build/sql/show_all_schemas.sql

diff --git a/Makefile b/Makefile
index ecf6e8890..d8de390a1 100644
--- a/Makefile
+++ b/Makefile
@@ -162,6 +162,11 @@ db_bench_init: docker_check
 db_bench: docker_check
 	docker exec -it pocket-db bash -c "pgbench -U postgres -d postgres"
 
+.PHONY: db_show_schemas
+## Show all the node schemas in the local DB
+db_show_schemas: docker_check
+	docker exec -it pocket-db bash -c "psql -U postgres -d postgres -a -f /tmp/scripts/show_all_schemas.sql"
+
 .PHONY: db_admin
 ## Helper to access to postgres admin GUI interface
 db_admin:
diff --git a/build/sql/show_all_schemas.sql b/build/sql/show_all_schemas.sql
new file mode 100644
index 000000000..b50e4fb4b
--- /dev/null
+++ b/build/sql/show_all_schemas.sql
@@ -0,0 +1 @@
+SELECT schema_name FROM information_schema.schemata;
\ No newline at end of file
diff --git a/consensus/block.go b/consensus/block.go
index 27b4ee00c..cd3bdb4e4 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -10,10 +10,10 @@ import (
 func (m *consensusModule) commitBlock(block *typesCons.Block) error {
 	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
 
-	// // Commit and release the context
-	// if err := m.utilityContext.Commit(block.BlockHeader.QuorumCertificate); err != nil {
-	// 	return err
-	// }
+	// Commit and release the context
+	if err := m.utilityContext.Commit(block.BlockHeader.QuorumCertificate); err != nil {
+		return err
+	}
 
 	if err := m.utilityContext.Release(); err != nil {
 		return err
diff --git a/persistence/context.go b/persistence/context.go
index 4f675ddb7..ffce0bf2a 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -5,6 +5,8 @@ import (
 	"log"
 )
 
+// DISCUSS: Why aren't these receivers pointers?
+
 func (p PostgresContext) NewSavePoint(bytes []byte) error {
 	log.Println("TODO: NewSavePoint not implemented")
 	return nil
@@ -56,19 +58,39 @@ func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
 
 func (p PostgresContext) Release() error {
 	log.Printf("About to release context at height %d.\n", p.Height)
-
 	ctx := context.TODO()
 	if err := p.GetTx().Rollback(ctx); err != nil {
 		return err
 	}
-	if err := p.conn.Close(ctx); err != nil {
-		log.Println("[TODO][ERROR] Implement connection pooling. Error when closing DB connecting...", err)
+	if err := p.resetContext(); err != nil {
+		return err
 	}
 	return nil
 }
 
 func (p PostgresContext) Close() error {
 	log.Printf("About to close context at height %d.\n", p.Height)
-
 	return p.conn.Close(context.TODO())
 }
+
+func (pg *PostgresContext) resetContext() (err error) {
+	if pg == nil {
+		return nil
+	}
+	tx := pg.GetTx()
+	if tx == nil {
+		return nil
+	}
+	conn := tx.Conn()
+	if conn == nil {
+		return nil
+	}
+	if !conn.IsClosed() {
+		if err := conn.Close(context.TODO()); err != nil {
+			return err
+		}
+	}
+	pg.conn = nil
+	pg.tx = nil
+	return err
+}
diff --git a/persistence/db.go b/persistence/db.go
index a4e49c213..0565b429a 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -4,7 +4,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"log"
 
 	"github.com/pokt-network/pocket/persistence/indexer"
 
@@ -37,6 +36,15 @@ var protocolActorSchemas = []types.ProtocolActorSchema{
 	types.ValidatorActor,
 }
 
+// A list of functions to clear data from the DB not associated with protocol actors
+var nonActorClearFunctions = []func() string{
+	types.ClearAllAccounts,
+	types.ClearAllPools,
+	types.ClearAllGovParamsQuery,
+	types.ClearAllGovFlagsQuery,
+	types.ClearAllBlocksQuery,
+}
+
 var _ modules.PersistenceRWContext = &PostgresContext{}
 
 type PostgresContext struct {
@@ -53,6 +61,8 @@ type PostgresContext struct {
 	merkleTrees map[MerkleTree]*smt.SparseMerkleTree
 }
 
+// TODO: Reduce the scope of these functions
+
 func (pg *PostgresContext) GetCtxAndTx() (context.Context, pgx.Tx, error) {
 	return context.TODO(), pg.GetTx(), nil
 }
@@ -65,27 +75,6 @@ func (pg *PostgresContext) GetCtx() (context.Context, error) {
 	return context.TODO(), nil
 }
 
-func (pg *PostgresContext) ResetContext() error {
-	if pg == nil {
-		return nil
-	}
-	tx := pg.GetTx()
-	if tx == nil {
-		return nil
-	}
-	conn := tx.Conn()
-	if conn == nil {
-		return nil
-	}
-	if !conn.IsClosed() {
-		if err := pg.Release(); err != nil {
-			log.Println("[TODO][ERROR] Error releasing write context...", err)
-		}
-	}
-	pg.tx = nil
-	return nil
-}
-
 // TECHDEBT: Implement proper connection pooling
 func connectToDatabase(postgresUrl string, schema string) (*pgx.Conn, error) {
 	ctx := context.TODO()
@@ -194,13 +183,8 @@ func initializeBlockTables(ctx context.Context, db *pgx.Conn) error {
 }
 
 // Exposed for testing purposes only
-func (p PostgresContext) DebugClearAll() error {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return err
-	}
-
-	clearTx, err := tx.Begin(ctx) // creates a pseudo-nested transaction
+func (p *PostgresContext) DebugClearAll() error {
+	ctx, clearTx, err := p.GetCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -216,16 +200,10 @@ func (p PostgresContext) DebugClearAll() error {
 		}
 	}
 
-	if _, err = tx.Exec(ctx, types.ClearAllGovParamsQuery()); err != nil {
-		return err
-	}
-
-	if _, err = tx.Exec(ctx, types.ClearAllGovFlagsQuery()); err != nil {
-		return err
-	}
-
-	if _, err = tx.Exec(ctx, types.ClearAllBlocksQuery()); err != nil {
-		return err
+	for _, clearFn := range nonActorClearFunctions {
+		if _, err := clearTx.Exec(ctx, clearFn()); err != nil {
+			return err
+		}
 	}
 
 	if err = clearTx.Commit(ctx); err != nil {
diff --git a/persistence/debug.go b/persistence/debug.go
index f6a729d05..e509c4e7e 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -14,9 +14,9 @@ func (m *persistenceModule) HandleDebugMessage(debugMessage *debug.DebugMessage)
 	case debug.DebugMessageAction_DEBUG_SHOW_LATEST_BLOCK_IN_STORE:
 		m.showLatestBlockInStore(debugMessage)
 	case debug.DebugMessageAction_DEBUG_CLEAR_STATE:
-		m.clearState(debugMessage)
+		m.ClearState(debugMessage) // TODO: Handle error
 		g := m.genesisState.(*types.PersistenceGenesisState)
-		m.populateGenesisState(g)
+		m.populateGenesisState(g) // fatal if there's an error
 	default:
 		log.Printf("Debug message not handled by persistence module: %s \n", debugMessage.Message)
 	}
@@ -39,19 +39,22 @@ func (m *persistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 	log.Printf("Block at height %d with %d transactions: %+v \n", height, len(block.Transactions), block)
 }
 
-func (m *persistenceModule) clearState(_ *debug.DebugMessage) {
+func (m *persistenceModule) ClearState(_ *debug.DebugMessage) error {
 	context, err := m.NewRWContext(-1)
-	defer context.Commit([]byte("HACK: debugClearStateProposerPlaceholder"), []byte("HACK: debugClearStateQuorumCertPlaceholder"))
 	if err != nil {
 		log.Printf("Error creating new context: %s \n", err)
-		return
+		return err
 	}
+
 	if err := context.(*PostgresContext).DebugClearAll(); err != nil {
 		log.Printf("Error clearing state: %s \n", err)
-		return
+		return err
 	}
+
 	if err := m.blockStore.ClearAll(); err != nil {
 		log.Printf("Error clearing block store: %s \n", err)
-		return
+		return err
 	}
+
+	return nil
 }
diff --git a/persistence/genesis.go b/persistence/genesis.go
index f559c4979..8d675076d 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -9,8 +9,6 @@ import (
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
-// TODO(andrew): generalize with the `actors interface`
-
 // WARNING: This function crashes the process if there is an error populating the genesis state.
 func (m *persistenceModule) populateGenesisState(state modules.PersistenceGenesisState) {
 	log.Println("Populating genesis state...")
@@ -30,7 +28,6 @@ func (m *persistenceModule) populateGenesisState(state modules.PersistenceGenesi
 		return nil
 	}
 
-	log.Println("Populating genesis state...")
 	rwContext, err := m.NewRWContext(0)
 	if err != nil {
 		log.Fatalf("an error occurred creating the rwContext for the genesis state: %s", err.Error())
diff --git a/persistence/module.go b/persistence/module.go
index 45053ea90..01de09393 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -105,10 +105,9 @@ func (*persistenceModule) Create(runtimeMgr modules.RuntimeMgr) (modules.Module,
 		return nil, err
 	} else if shouldHydrateGenesis {
 		// TECHDEBT: reconsider if this is the best place to call `populateGenesisState`. Note that
-		// 		     this forces the genesis state to be reloaded on every node startup until state sync is
-		//           implemented.
-		// NOTE: `populateGenesisState` does not return an error but logs a fatal error if there's a problem
-		m.populateGenesisState(persistenceGenesis)
+		// 		     this forces the genesis state to be reloaded on every node startup until state
+		//           sync is implemented.
+		m.populateGenesisState(persistenceGenesis) // fatal if there's an error
 	} else {
 		log.Println("Loading state from previous state...")
 	}
@@ -209,10 +208,8 @@ func (m *persistenceModule) NewReadContext(height int64) (modules.PersistenceRea
 
 func (m *persistenceModule) ReleaseWriteContext() error {
 	if m.writeContext != nil {
-		if !m.writeContext.GetTx().Conn().IsClosed() {
-			if err := m.writeContext.Release(); err != nil {
-				log.Println("[TODO][ERROR] Error releasing write context...", err)
-			}
+		if err := m.writeContext.resetContext(); err != nil {
+			log.Println("[TODO][ERROR] Error releasing write context...", err)
 		}
 		m.writeContext = nil
 	}
@@ -227,14 +224,7 @@ func (m *persistenceModule) NewWriteContext() modules.PersistenceRWContext {
 	return m.writeContext
 }
 
-func initializeBlockStore(blockStorePath string) (kvstore.KVStore, error) {
-	if blockStorePath == "" {
-		return kvstore.NewMemKVStore(), nil
-	}
-	return kvstore.NewKVStore(blockStorePath)
-}
-
-// TODO(drewsky): Simplify and externalize the logic for whether genesis should be populated and
+// TODO(olshansky): Simplify and externalize the logic for whether genesis should be populated and
 // move the if logic out of this file.
 func (m *persistenceModule) shouldHydrateGenesisDb() (bool, error) {
 	checkContext, err := m.NewReadContext(-1)
@@ -250,3 +240,10 @@ func (m *persistenceModule) shouldHydrateGenesisDb() (bool, error) {
 
 	return m.blockStore.Exists(heightToBytes(int64(maxHeight)))
 }
+
+func initializeBlockStore(blockStorePath string) (kvstore.KVStore, error) {
+	if blockStorePath == "" {
+		return kvstore.NewMemKVStore(), nil
+	}
+	return kvstore.NewKVStore(blockStorePath)
+}
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
index 9ce0c535f..62d454e31 100644
--- a/persistence/shared_sql.go
+++ b/persistence/shared_sql.go
@@ -97,6 +97,7 @@ func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, addres
 }
 
 func (p *PostgresContext) GetActorFromRow(row pgx.Row) (actor *types.Actor, height int64, err error) {
+	actor = new(types.Actor)
 	err = row.Scan(
 		&actor.Address,
 		&actor.PublicKey,
diff --git a/persistence/test/setup_test.go b/persistence/test/setup_test.go
index a1316b09c..af54f563e 100644
--- a/persistence/test/setup_test.go
+++ b/persistence/test/setup_test.go
@@ -65,9 +65,8 @@ func NewTestPostgresContext(t *testing.T, height int64) *persistence.PostgresCon
 	require.True(t, ok)
 
 	t.Cleanup(func() {
-		// require.NoError(db.DebugClearAll())
-		// require.NoError(t, db.Release())
-		require.NoError(t, db.ResetContext())
+		require.NoError(t, db.DebugClearAll())
+		require.NoError(t, db.Release())
 	})
 
 	return db
@@ -88,9 +87,6 @@ func NewFuzzTestPostgresContext(f *testing.F, height int64) *persistence.Postgre
 		if err := db.Release(); err != nil {
 			f.FailNow()
 		}
-		if err := db.ResetContext(); err != nil {
-			f.FailNow()
-		}
 	})
 
 	return db
diff --git a/persistence/types/account.go b/persistence/types/account.go
index a726b3dce..5c517a7e8 100644
--- a/persistence/types/account.go
+++ b/persistence/types/account.go
@@ -79,3 +79,11 @@ func SelectPools(height int64, tableName string) string {
 			ORDER BY name, height DESC
        `, tableName, height)
 }
+
+func ClearAllAccounts() string {
+	return fmt.Sprintf(`DELETE FROM %s`, AccountTableName)
+}
+
+func ClearAllPools() string {
+	return fmt.Sprintf(`DELETE FROM %s`, PoolTableName)
+}
diff --git a/runtime/test_artifacts/util.go b/runtime/test_artifacts/util.go
index b23252a45..f064a7880 100644
--- a/runtime/test_artifacts/util.go
+++ b/runtime/test_artifacts/util.go
@@ -95,7 +95,7 @@ func CleanupPostgresDocker(_ *testing.M, pool *dockertest.Pool, resource *docker
 	}
 }
 
-// TODO(drewsky): Remove this in favor of a golang specific solution
 func CleanupTest(u utility.UtilityContext) {
-	u.Context.Release()
+	// require.NoError(t, testPersistenceMod.ReleaseWriteContext()) // Release the write context used in the test
+	// require.NoError(t, testPersistenceMod.ClearState(nil))
 }
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index d3454bd9d..f72fc6933 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -23,6 +23,9 @@ type PersistenceModule interface {
 
 	// Debugging / development only
 	HandleDebugMessage(*debug.DebugMessage) error
+
+	// HACK: Until utility has no dependency on the real persistence module
+	ClearState(*debug.DebugMessage) error
 }
 
 // Interface defining the context within which the node can operate with the persistence layer.
diff --git a/utility/test/actor_test.go b/utility/test/actor_test.go
index fdb922f37..6bfe073ee 100644
--- a/utility/test/actor_test.go
+++ b/utility/test/actor_test.go
@@ -453,86 +453,88 @@ func TestUtilityContext_UnstakePausedBefore(t *testing.T) {
 
 func TestUtilityContext_UnstakeActorsThatAreReady(t *testing.T) {
 	for _, actorType := range actorTypes {
-		ctx := NewTestingUtilityContext(t, 1)
-
-		poolName := ""
-		var err1, err2 error
-		switch actorType {
-		case typesUtil.ActorType_App:
-			err1 = ctx.Context.SetParam(typesUtil.AppUnstakingBlocksParamName, 0)
-			err2 = ctx.Context.SetParam(typesUtil.AppMaxPauseBlocksParamName, 0)
-			poolName = typesUtil.PoolNames_AppStakePool.String()
-		case typesUtil.ActorType_Validator:
-			err1 = ctx.Context.SetParam(typesUtil.ValidatorUnstakingBlocksParamName, 0)
-			err2 = ctx.Context.SetParam(typesUtil.ValidatorMaxPausedBlocksParamName, 0)
-			poolName = typesUtil.PoolNames_ValidatorStakePool.String()
-		case typesUtil.ActorType_Fisherman:
-			err1 = ctx.Context.SetParam(typesUtil.FishermanUnstakingBlocksParamName, 0)
-			err2 = ctx.Context.SetParam(typesUtil.FishermanMaxPauseBlocksParamName, 0)
-			poolName = typesUtil.PoolNames_FishermanStakePool.String()
-		case typesUtil.ActorType_ServiceNode:
-			err1 = ctx.Context.SetParam(typesUtil.ServiceNodeUnstakingBlocksParamName, 0)
-			err2 = ctx.Context.SetParam(typesUtil.ServiceNodeMaxPauseBlocksParamName, 0)
-			poolName = typesUtil.PoolNames_ServiceNodeStakePool.String()
-		default:
-			t.Fatalf("unexpected actor type %s", actorType.String())
-		}
+		t.Run(string(actorType), func(t *testing.T) {
+			ctx := NewTestingUtilityContext(t, 1)
 
-		err := ctx.SetPoolAmount(poolName, big.NewInt(math.MaxInt64))
-		require.NoError(t, err)
-		require.NoError(t, err1, "error setting unstaking blocks")
-		require.NoError(t, err2, "error setting max pause blocks")
+			poolName := ""
+			var err1, err2 error
+			switch actorType {
+			case typesUtil.ActorType_App:
+				err1 = ctx.Context.SetParam(typesUtil.AppUnstakingBlocksParamName, 0)
+				err2 = ctx.Context.SetParam(typesUtil.AppMaxPauseBlocksParamName, 0)
+				poolName = typesUtil.PoolNames_AppStakePool.String()
+			case typesUtil.ActorType_Validator:
+				err1 = ctx.Context.SetParam(typesUtil.ValidatorUnstakingBlocksParamName, 0)
+				err2 = ctx.Context.SetParam(typesUtil.ValidatorMaxPausedBlocksParamName, 0)
+				poolName = typesUtil.PoolNames_ValidatorStakePool.String()
+			case typesUtil.ActorType_Fisherman:
+				err1 = ctx.Context.SetParam(typesUtil.FishermanUnstakingBlocksParamName, 0)
+				err2 = ctx.Context.SetParam(typesUtil.FishermanMaxPauseBlocksParamName, 0)
+				poolName = typesUtil.PoolNames_FishermanStakePool.String()
+			case typesUtil.ActorType_ServiceNode:
+				err1 = ctx.Context.SetParam(typesUtil.ServiceNodeUnstakingBlocksParamName, 0)
+				err2 = ctx.Context.SetParam(typesUtil.ServiceNodeMaxPauseBlocksParamName, 0)
+				poolName = typesUtil.PoolNames_ServiceNodeStakePool.String()
+			default:
+				t.Fatalf("unexpected actor type %s", actorType.String())
+			}
 
-		actors := getAllTestingActors(t, ctx, actorType)
-		for _, actor := range actors {
-			addrBz, err := hex.DecodeString(actor.GetAddress())
+			err := ctx.SetPoolAmount(poolName, big.NewInt(math.MaxInt64))
 			require.NoError(t, err)
-			require.Equal(t, int64(-1), actor.GetUnstakingHeight(), "wrong starting staked status")
-			err = ctx.SetActorPauseHeight(actorType, addrBz, 1)
-			require.NoError(t, err, "error setting actor pause height")
-		}
+			require.NoError(t, err1, "error setting unstaking blocks")
+			require.NoError(t, err2, "error setting max pause blocks")
+
+			actors := getAllTestingActors(t, ctx, actorType)
+			for _, actor := range actors {
+				addrBz, err := hex.DecodeString(actor.GetAddress())
+				require.NoError(t, err)
+				require.Equal(t, int64(-1), actor.GetUnstakingHeight(), "wrong starting staked status")
+				err = ctx.SetActorPauseHeight(actorType, addrBz, 1)
+				require.NoError(t, err, "error setting actor pause height")
+			}
 
-		err = ctx.UnstakeActorPausedBefore(2, actorType)
-		require.NoError(t, err, "error setting actor pause before")
+			err = ctx.UnstakeActorPausedBefore(2, actorType)
+			require.NoError(t, err, "error setting actor pause before")
 
-		accountAmountsBefore := make([]*big.Int, 0)
+			accountAmountsBefore := make([]*big.Int, 0)
 
-		for _, actor := range actors {
-			// get the output address account amount before the 'unstake'
-			outputAddressString := actor.GetOutput()
-			outputAddress, err := hex.DecodeString(outputAddressString)
-			require.NoError(t, err)
-			outputAccountAmount, err := ctx.GetAccountAmount(outputAddress)
+			for _, actor := range actors {
+				// get the output address account amount before the 'unstake'
+				outputAddressString := actor.GetOutput()
+				outputAddress, err := hex.DecodeString(outputAddressString)
+				require.NoError(t, err)
+				outputAccountAmount, err := ctx.GetAccountAmount(outputAddress)
+				require.NoError(t, err)
+				// capture the amount before
+				accountAmountsBefore = append(accountAmountsBefore, outputAccountAmount)
+			}
+			// capture the pool amount before
+			poolAmountBefore, err := ctx.GetPoolAmount(poolName)
 			require.NoError(t, err)
-			// capture the amount before
-			accountAmountsBefore = append(accountAmountsBefore, outputAccountAmount)
-		}
-		// capture the pool amount before
-		poolAmountBefore, err := ctx.GetPoolAmount(poolName)
-		require.NoError(t, err)
-
-		err = ctx.UnstakeActorsThatAreReady()
-		require.NoError(t, err, "error unstaking actors that are ready")
 
-		for i, actor := range actors {
-			// get the output address account amount after the 'unstake'
-			outputAddressString := actor.GetOutput()
-			outputAddress, err := hex.DecodeString(outputAddressString)
-			require.NoError(t, err)
-			outputAccountAmount, err := ctx.GetAccountAmount(outputAddress)
+			err = ctx.UnstakeActorsThatAreReady()
+			require.NoError(t, err, "error unstaking actors that are ready")
+
+			for i, actor := range actors {
+				// get the output address account amount after the 'unstake'
+				outputAddressString := actor.GetOutput()
+				outputAddress, err := hex.DecodeString(outputAddressString)
+				require.NoError(t, err)
+				outputAccountAmount, err := ctx.GetAccountAmount(outputAddress)
+				require.NoError(t, err)
+				// ensure the stake amount went to the output address
+				outputAccountAmountDelta := new(big.Int).Sub(outputAccountAmount, accountAmountsBefore[i])
+				require.Equal(t, outputAccountAmountDelta, test_artifacts.DefaultStakeAmount)
+			}
+			// ensure the staking pool is `# of readyToUnstake actors * default stake` less than before the unstake
+			poolAmountAfter, err := ctx.GetPoolAmount(poolName)
 			require.NoError(t, err)
-			// ensure the stake amount went to the output address
-			outputAccountAmountDelta := new(big.Int).Sub(outputAccountAmount, accountAmountsBefore[i])
-			require.Equal(t, outputAccountAmountDelta, test_artifacts.DefaultStakeAmount)
-		}
-		// ensure the staking pool is `# of readyToUnstake actors * default stake` less than before the unstake
-		poolAmountAfter, err := ctx.GetPoolAmount(poolName)
-		require.NoError(t, err)
-		actualPoolDelta := new(big.Int).Sub(poolAmountBefore, poolAmountAfter)
-		expectedPoolDelta := new(big.Int).Mul(big.NewInt(int64(len(actors))), test_artifacts.DefaultStakeAmount)
-		require.Equal(t, expectedPoolDelta, actualPoolDelta)
-
-		test_artifacts.CleanupTest(ctx)
+			actualPoolDelta := new(big.Int).Sub(poolAmountBefore, poolAmountAfter)
+			expectedPoolDelta := new(big.Int).Mul(big.NewInt(int64(len(actors))), test_artifacts.DefaultStakeAmount)
+			require.Equal(t, expectedPoolDelta, actualPoolDelta)
+
+			test_artifacts.CleanupTest(ctx)
+		})
 	}
 }
 
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index 5990ba447..1c628f930 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -101,35 +101,37 @@ func TestUtilityContext_BeginBlock(t *testing.T) {
 
 func TestUtilityContext_BeginUnstakingMaxPausedActors(t *testing.T) {
 	for _, actorType := range actorTypes {
-		ctx := NewTestingUtilityContext(t, 1)
-		actor := getFirstActor(t, ctx, actorType)
-
-		var err error
-		switch actorType {
-		case typesUtil.ActorType_App:
-			err = ctx.Context.SetParam(typesUtil.AppMaxPauseBlocksParamName, 0)
-		case typesUtil.ActorType_Validator:
-			err = ctx.Context.SetParam(typesUtil.ValidatorMaxPausedBlocksParamName, 0)
-		case typesUtil.ActorType_Fisherman:
-			err = ctx.Context.SetParam(typesUtil.FishermanMaxPauseBlocksParamName, 0)
-		case typesUtil.ActorType_ServiceNode:
-			err = ctx.Context.SetParam(typesUtil.ServiceNodeMaxPauseBlocksParamName, 0)
-		default:
-			t.Fatalf("unexpected actor type %s", actorType.String())
-		}
-		require.NoError(t, err)
-		addrBz, er := hex.DecodeString(actor.GetAddress())
-		require.NoError(t, er)
-		err = ctx.SetActorPauseHeight(actorType, addrBz, 0)
-		require.NoError(t, err)
+		t.Run(string(actorType), func(t *testing.T) {
+			ctx := NewTestingUtilityContext(t, 1)
+			actor := getFirstActor(t, ctx, actorType)
+
+			var err error
+			switch actorType {
+			case typesUtil.ActorType_App:
+				err = ctx.Context.SetParam(typesUtil.AppMaxPauseBlocksParamName, 0)
+			case typesUtil.ActorType_Validator:
+				err = ctx.Context.SetParam(typesUtil.ValidatorMaxPausedBlocksParamName, 0)
+			case typesUtil.ActorType_Fisherman:
+				err = ctx.Context.SetParam(typesUtil.FishermanMaxPauseBlocksParamName, 0)
+			case typesUtil.ActorType_ServiceNode:
+				err = ctx.Context.SetParam(typesUtil.ServiceNodeMaxPauseBlocksParamName, 0)
+			default:
+				t.Fatalf("unexpected actor type %s", actorType.String())
+			}
+			require.NoError(t, err)
+			addrBz, er := hex.DecodeString(actor.GetAddress())
+			require.NoError(t, er)
+			err = ctx.SetActorPauseHeight(actorType, addrBz, 0)
+			require.NoError(t, err)
 
-		err = ctx.BeginUnstakingMaxPaused()
-		require.NoError(t, err)
+			err = ctx.BeginUnstakingMaxPaused()
+			require.NoError(t, err)
 
-		status, err := ctx.GetActorStatus(actorType, addrBz)
-		require.Equal(t, int32(typesUtil.StakeStatus_Unstaking), status, "incorrect status")
+			status, err := ctx.GetActorStatus(actorType, addrBz)
+			require.Equal(t, int32(typesUtil.StakeStatus_Unstaking), status, "incorrect status")
 
-		test_artifacts.CleanupTest(ctx)
+			test_artifacts.CleanupTest(ctx)
+		})
 	}
 }
 
@@ -178,49 +180,51 @@ func TestUtilityContext_EndBlock(t *testing.T) {
 
 func TestUtilityContext_UnstakeValidatorsActorsThatAreReady(t *testing.T) {
 	for _, actorType := range actorTypes {
-		ctx := NewTestingUtilityContext(t, 1)
-		var poolName string
-		switch actorType {
-		case typesUtil.ActorType_App:
-			poolName = typesUtil.PoolNames_AppStakePool.String()
-		case typesUtil.ActorType_Validator:
-			poolName = typesUtil.PoolNames_ValidatorStakePool.String()
-		case typesUtil.ActorType_Fisherman:
-			poolName = typesUtil.PoolNames_FishermanStakePool.String()
-		case typesUtil.ActorType_ServiceNode:
-			poolName = typesUtil.PoolNames_ServiceNodeStakePool.String()
-		default:
-			t.Fatalf("unexpected actor type %s", actorType.String())
-		}
-
-		ctx.SetPoolAmount(poolName, big.NewInt(math.MaxInt64))
-		err := ctx.Context.SetParam(typesUtil.AppUnstakingBlocksParamName, 0)
-		require.NoError(t, err)
-
-		err = ctx.Context.SetParam(typesUtil.AppMaxPauseBlocksParamName, 0)
-		require.NoError(t, err)
-
-		actors := getAllTestingActors(t, ctx, actorType)
-		for _, actor := range actors {
-			// require.Equal(t, int32(typesUtil.StakedStatus), actor.GetStatus(), "wrong starting status")
-			addrBz, er := hex.DecodeString(actor.GetAddress())
-			require.NoError(t, er)
-			er = ctx.SetActorPauseHeight(actorType, addrBz, 1)
-			require.NoError(t, er)
-		}
+		t.Run(string(actorType), func(t *testing.T) {
+			ctx := NewTestingUtilityContext(t, 1)
+			var poolName string
+			switch actorType {
+			case typesUtil.ActorType_App:
+				poolName = typesUtil.PoolNames_AppStakePool.String()
+			case typesUtil.ActorType_Validator:
+				poolName = typesUtil.PoolNames_ValidatorStakePool.String()
+			case typesUtil.ActorType_Fisherman:
+				poolName = typesUtil.PoolNames_FishermanStakePool.String()
+			case typesUtil.ActorType_ServiceNode:
+				poolName = typesUtil.PoolNames_ServiceNodeStakePool.String()
+			default:
+				t.Fatalf("unexpected actor type %s", actorType.String())
+			}
+
+			ctx.SetPoolAmount(poolName, big.NewInt(math.MaxInt64))
+			err := ctx.Context.SetParam(typesUtil.AppUnstakingBlocksParamName, 0)
+			require.NoError(t, err)
+
+			err = ctx.Context.SetParam(typesUtil.AppMaxPauseBlocksParamName, 0)
+			require.NoError(t, err)
+
+			actors := getAllTestingActors(t, ctx, actorType)
+			for _, actor := range actors {
+				// require.Equal(t, int32(typesUtil.StakedStatus), actor.GetStatus(), "wrong starting status")
+				addrBz, er := hex.DecodeString(actor.GetAddress())
+				require.NoError(t, er)
+				er = ctx.SetActorPauseHeight(actorType, addrBz, 1)
+				require.NoError(t, er)
+			}
 
-		err = ctx.UnstakeActorPausedBefore(2, actorType)
-		require.NoError(t, err)
+			err = ctx.UnstakeActorPausedBefore(2, actorType)
+			require.NoError(t, err)
 
-		err = ctx.UnstakeActorsThatAreReady()
-		require.NoError(t, err)
+			err = ctx.UnstakeActorsThatAreReady()
+			require.NoError(t, err)
 
-		actors = getAllTestingActors(t, ctx, actorType)
-		require.NotEqual(t, actors[0].GetUnstakingHeight(), -1, "validators still exists after unstake that are ready() call")
+			actors = getAllTestingActors(t, ctx, actorType)
+			require.NotEqual(t, actors[0].GetUnstakingHeight(), -1, "validators still exists after unstake that are ready() call")
 
-		// TODO: We need to better define what 'deleted' really is in the postgres world.
-		// We might not need to 'unstakeActorsThatAreReady' if we are already filtering by unstakingHeight
+			// TODO: We need to better define what 'deleted' really is in the postgres world.
+			// We might not need to 'unstakeActorsThatAreReady' if we are already filtering by unstakingHeight
 
-		test_artifacts.CleanupTest(ctx)
+			test_artifacts.CleanupTest(ctx)
+		})
 	}
 }
diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index 21a3220a8..d5b0247be 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -2,7 +2,6 @@ package test
 
 import (
 	"encoding/hex"
-	"fmt"
 	"math/big"
 	"os"
 	"testing"
@@ -55,15 +54,14 @@ func TestMain(m *testing.M) {
 }
 
 func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext {
-	fmt.Println("OLSH HERE")
 	testPersistenceMod := newTestPersistenceModule(t, persistenceDbUrl)
 
 	persistenceContext, err := testPersistenceMod.NewRWContext(height)
 	require.NoError(t, err)
 
 	t.Cleanup(func() {
-		// persistenceContext.DebugClearAll()
-		persistenceContext.Release()
+		require.NoError(t, testPersistenceMod.ReleaseWriteContext()) // Release the write context used in the test
+		require.NoError(t, testPersistenceMod.ClearState(nil))
 	})
 
 	return utility.UtilityContext{
diff --git a/utility/types/message_test.go b/utility/types/message_test.go
index 0702a9bf6..f282adc88 100644
--- a/utility/types/message_test.go
+++ b/utility/types/message_test.go
@@ -1,10 +1,11 @@
 package types
 
 import (
-	"github.com/pokt-network/pocket/shared/codec"
 	"math/big"
 	"testing"
 
+	"github.com/pokt-network/pocket/shared/codec"
+
 	"github.com/pokt-network/pocket/shared/crypto"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/protobuf/proto"

From dabfb0bb0f3cbbd28b7bc83d90159bcf930ee91b Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 25 Oct 2022 22:01:15 -0700
Subject: [PATCH 100/227] Most tests except for persistence pass

---
 persistence/test/account_test.go |  1 -
 persistence/test/setup_test.go   | 20 +++++++++++++++-----
 2 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/persistence/test/account_test.go b/persistence/test/account_test.go
index 6846878da..a0ee0bd34 100644
--- a/persistence/test/account_test.go
+++ b/persistence/test/account_test.go
@@ -300,7 +300,6 @@ func TestGetAllAccounts(t *testing.T) {
 		} else {
 			return db.AddAccountAmount(addr, "10")
 		}
-
 	}
 
 	getAllActorsTest(t, db, db.GetAllAccounts, createAndInsertNewAccount, updateAccount, 8)
diff --git a/persistence/test/setup_test.go b/persistence/test/setup_test.go
index af54f563e..6589dd526 100644
--- a/persistence/test/setup_test.go
+++ b/persistence/test/setup_test.go
@@ -15,6 +15,7 @@ import (
 	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/runtime"
 	"github.com/pokt-network/pocket/runtime/test_artifacts"
+	"github.com/pokt-network/pocket/shared/debug"
 	"github.com/pokt-network/pocket/shared/modules"
 	"github.com/stretchr/testify/require"
 	"golang.org/x/exp/slices"
@@ -58,6 +59,8 @@ func TestMain(m *testing.M) {
 }
 
 func NewTestPostgresContext(t *testing.T, height int64) *persistence.PostgresContext {
+	// require.NoError(t, testPersistenceMod.ReleaseWriteContext())
+
 	ctx, err := testPersistenceMod.NewRWContext(height)
 	require.NoError(t, err)
 
@@ -65,8 +68,12 @@ func NewTestPostgresContext(t *testing.T, height int64) *persistence.PostgresCon
 	require.True(t, ok)
 
 	t.Cleanup(func() {
-		require.NoError(t, db.DebugClearAll())
-		require.NoError(t, db.Release())
+		ctx.Release()
+		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
+		require.NoError(t, testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
+			Action:  debug.DebugMessageAction_DEBUG_CLEAR_STATE,
+			Message: nil,
+		}))
 	})
 
 	return db
@@ -84,9 +91,12 @@ func NewFuzzTestPostgresContext(f *testing.F, height int64) *persistence.Postgre
 	}
 
 	f.Cleanup(func() {
-		if err := db.Release(); err != nil {
-			f.FailNow()
-		}
+		testPersistenceMod.ReleaseWriteContext()
+		testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
+			Action:  debug.DebugMessageAction_DEBUG_CLEAR_STATE,
+			Message: nil,
+		})
+
 	})
 
 	return db

From 65cd81a58f977556ab71f5a2ec6b63a882d441d9 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Fri, 28 Oct 2022 14:23:34 -0700
Subject: [PATCH 101/227] All tests finally passing except for deterministic
 hash

---
 persistence/debug.go            |  15 ++--
 persistence/genesis.go          |   3 -
 persistence/test/module_test.go |  30 +++++--
 persistence/test/setup_test.go  |  23 +++--
 persistence/test/state_test.go  | 155 +++++++++++++++-----------------
 5 files changed, 115 insertions(+), 111 deletions(-)

diff --git a/persistence/debug.go b/persistence/debug.go
index e509c4e7e..df9368592 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -3,7 +3,6 @@ package persistence
 import (
 	"log"
 
-	typesCons "github.com/pokt-network/pocket/consensus/types"
 	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/debug"
@@ -14,7 +13,9 @@ func (m *persistenceModule) HandleDebugMessage(debugMessage *debug.DebugMessage)
 	case debug.DebugMessageAction_DEBUG_SHOW_LATEST_BLOCK_IN_STORE:
 		m.showLatestBlockInStore(debugMessage)
 	case debug.DebugMessageAction_DEBUG_CLEAR_STATE:
-		m.ClearState(debugMessage) // TODO: Handle error
+		if err := m.ClearState(debugMessage); err != nil {
+			log.Fatalf("Error clearing state: %s \n", err)
+		}
 		g := m.genesisState.(*types.PersistenceGenesisState)
 		m.populateGenesisState(g) // fatal if there's an error
 	default:
@@ -23,7 +24,6 @@ func (m *persistenceModule) HandleDebugMessage(debugMessage *debug.DebugMessage)
 	return nil
 }
 
-// TODO(olshansky): Create a shared interface `Block` to avoid the use of typesCons here.
 func (m *persistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 	// TODO: Add an iterator to the `kvstore` and use that instead
 	height := m.GetBus().GetConsensusModule().CurrentHeight() - 1 // -1 because we want the latest committed height
@@ -33,7 +33,7 @@ func (m *persistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 		return
 	}
 	codec := codec.GetCodec()
-	block := &typesCons.Block{}
+	block := &types.Block{}
 	codec.Unmarshal(blockBytes, block)
 
 	log.Printf("Block at height %d with %d transactions: %+v \n", height, len(block.Transactions), block)
@@ -42,17 +42,18 @@ func (m *persistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 func (m *persistenceModule) ClearState(_ *debug.DebugMessage) error {
 	context, err := m.NewRWContext(-1)
 	if err != nil {
-		log.Printf("Error creating new context: %s \n", err)
 		return err
 	}
 
 	if err := context.(*PostgresContext).DebugClearAll(); err != nil {
-		log.Printf("Error clearing state: %s \n", err)
 		return err
 	}
 
 	if err := m.blockStore.ClearAll(); err != nil {
-		log.Printf("Error clearing block store: %s \n", err)
+		return err
+	}
+
+	if err := m.ReleaseWriteContext(); err != nil {
 		return err
 	}
 
diff --git a/persistence/genesis.go b/persistence/genesis.go
index 8d675076d..4a800744d 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -33,9 +33,6 @@ func (m *persistenceModule) populateGenesisState(state modules.PersistenceGenesi
 		log.Fatalf("an error occurred creating the rwContext for the genesis state: %s", err.Error())
 	}
 
-	if err != nil {
-		log.Fatalf("an error occurred creating the rwContext for the genesis state: %s", err.Error())
-	}
 	for _, acc := range state.GetAccs() {
 		addrBz, err := hex.DecodeString(acc.GetAddress())
 		if err != nil {
diff --git a/persistence/test/module_test.go b/persistence/test/module_test.go
index 844095bb1..2668f0a1b 100644
--- a/persistence/test/module_test.go
+++ b/persistence/test/module_test.go
@@ -7,10 +7,8 @@ import (
 )
 
 func TestPersistenceContextParallelReadWrite(t *testing.T) {
-	// Cleanup previous contexts
-	t.Cleanup(func() {
-		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
-	})
+	prepareAndCleanContext(t)
+
 	// variables for testing
 	poolName := "fake"
 	poolAddress := []byte("address")
@@ -52,11 +50,8 @@ func TestPersistenceContextParallelReadWrite(t *testing.T) {
 }
 
 func TestPersistenceContextTwoWritesErrors(t *testing.T) {
-	// Cleanup previous contexts
-	testPersistenceMod.ReleaseWriteContext()
-	t.Cleanup(func() {
-		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
-	})
+	prepareAndCleanContext(t)
+
 	// Opening up first write context succeeds
 	_, err := testPersistenceMod.NewRWContext(0)
 	require.NoError(t, err)
@@ -71,6 +66,8 @@ func TestPersistenceContextTwoWritesErrors(t *testing.T) {
 }
 
 func TestPersistenceContextSequentialWrites(t *testing.T) {
+	prepareAndCleanContext(t)
+
 	// Opening up first write context succeeds
 	writeContext1, err := testPersistenceMod.NewRWContext(0)
 	require.NoError(t, err)
@@ -94,6 +91,8 @@ func TestPersistenceContextSequentialWrites(t *testing.T) {
 }
 
 func TestPersistenceContextMultipleParallelReads(t *testing.T) {
+	prepareAndCleanContext(t)
+
 	// Opening up first read context succeeds
 	readContext1, err := testPersistenceMod.NewReadContext(0)
 	require.NoError(t, err)
@@ -110,3 +109,16 @@ func TestPersistenceContextMultipleParallelReads(t *testing.T) {
 	require.NoError(t, readContext2.Close())
 	require.NoError(t, readContext3.Close())
 }
+
+func prepareAndCleanContext(t *testing.T) {
+	// Cleanup context after the test
+	t.Cleanup(func() {
+		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
+		require.NoError(t, testPersistenceMod.ClearState(nil))
+	})
+
+	// Make sure the db is empty at the start of these tests
+	require.NoError(t, testPersistenceMod.ReleaseWriteContext())
+	require.NoError(t, testPersistenceMod.ClearState(nil))
+
+}
diff --git a/persistence/test/setup_test.go b/persistence/test/setup_test.go
index 6589dd526..140315e87 100644
--- a/persistence/test/setup_test.go
+++ b/persistence/test/setup_test.go
@@ -58,9 +58,8 @@ func TestMain(m *testing.M) {
 	os.Exit(exitCode)
 }
 
+// TODO_IN_THIS_COMMIT(olshansky): Consider just using `testPersistenceMod` everywhere instead of the underlying context
 func NewTestPostgresContext(t *testing.T, height int64) *persistence.PostgresContext {
-	// require.NoError(t, testPersistenceMod.ReleaseWriteContext())
-
 	ctx, err := testPersistenceMod.NewRWContext(height)
 	require.NoError(t, err)
 
@@ -68,7 +67,6 @@ func NewTestPostgresContext(t *testing.T, height int64) *persistence.PostgresCon
 	require.True(t, ok)
 
 	t.Cleanup(func() {
-		ctx.Release()
 		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
 		require.NoError(t, testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
 			Action:  debug.DebugMessageAction_DEBUG_CLEAR_STATE,
@@ -79,6 +77,7 @@ func NewTestPostgresContext(t *testing.T, height int64) *persistence.PostgresCon
 	return db
 }
 
+// TODO_IN_THIS_COMMIT(olshansky): Consider just using `testPersistenceMod` everywhere instead of the underlying context
 func NewFuzzTestPostgresContext(f *testing.F, height int64) *persistence.PostgresContext {
 	ctx, err := testPersistenceMod.NewRWContext(height)
 	if err != nil {
@@ -91,11 +90,15 @@ func NewFuzzTestPostgresContext(f *testing.F, height int64) *persistence.Postgre
 	}
 
 	f.Cleanup(func() {
-		testPersistenceMod.ReleaseWriteContext()
-		testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
+		if err := testPersistenceMod.ReleaseWriteContext(); err != nil {
+			log.Fatalf("Error releasing write context: %v\n", err)
+		}
+		if err := testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
 			Action:  debug.DebugMessageAction_DEBUG_CLEAR_STATE,
 			Message: nil,
-		})
+		}); err != nil {
+			log.Fatalf("Error clearing state: %v\n", err)
+		}
 
 	})
 
@@ -126,10 +129,12 @@ func fuzzSingleProtocolActor(
 	getTestActor func(db *persistence.PostgresContext, address string) (*types.Actor, error),
 	protocolActorSchema types.ProtocolActorSchema) {
 
-	db := NewFuzzTestPostgresContext(f, 0)
+	// SELF_REVIEW: Consider if this is the right approach
+	if err := testPersistenceMod.ClearState(nil); err != nil {
+		log.Fatal("Cannot clear state err")
+	}
 
-	err := db.DebugClearAll()
-	require.NoError(f, err)
+	db := NewFuzzTestPostgresContext(f, 0)
 
 	actor, err := newTestActor()
 	require.NoError(f, err)
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index 113be2cc1..7aecdf226 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -1,85 +1,74 @@
 package test
 
-import (
-	"encoding/binary"
-	"encoding/hex"
-	"math/big"
-	"testing"
-
-	"github.com/pokt-network/pocket/persistence/types"
-	"github.com/pokt-network/pocket/shared/codec"
-	"github.com/stretchr/testify/require"
-)
-
-func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
-	// These hashes were determined manually by running the test, but hardcoded to guarantee
-	// that the business logic doesn't change and that they remain deterministic.
-	encodedAppHash := []string{
-		"62adad6925267abe075dc62ffb9b8d960709409b097b75dd6b3ea4cce31d1482",
-		"c1af3fda156bce4162df755f0095ae4f909477fc385f761c6e8d2ef6eb2d9fa6",
-		"e65d0c2cd78f180d774bfe43e52a49fad490bf208fcc6d167f2b6543ab280cb9",
-	}
-
-	for i := 0; i < 3; i++ {
-		// Get the context at the new height and retrieve one of the apps
-		height := int64(i + 1)
-		heightBz := heightToBytes(height)
-		expectedAppHash := encodedAppHash[i]
-
-		db := NewTestPostgresContext(t, height)
-
-		apps, err := db.GetAllApps(height)
-		require.NoError(t, err)
-		app := apps[0]
-
-		addrBz, err := hex.DecodeString(app.GetAddress())
-		require.NoError(t, err)
-
-		// Update the app's stake
-		newStakeAmount := types.BigIntToString(big.NewInt(height + int64(420000000000)))
-		err = db.SetAppStakeAmount(addrBz, newStakeAmount)
-		require.NoError(t, err)
-
-		// NOTE: The tx does not currently affect the state hash
-		txBz := []byte("a tx, i am, which set the app stake amount to " + newStakeAmount)
-		// txResult := types.DefaultTx
-		// err = db.StoreTransaction(txBz)
-		// require.NoError(t, err)
-
-		// Update & commit the state hash
-		appHash, err := db.UpdateAppHash()
-		require.NoError(t, err)
-		require.Equal(t, expectedAppHash, hex.EncodeToString(appHash))
-
-		err = db.Commit([]byte("proposer"), []byte("quorumCert"))
-		require.NoError(t, err)
-
-		// Verify the block contents
-		blockBz, err := testPersistenceMod.GetBlockStore().Get(heightBz)
-		require.NoError(t, err)
-
-		var block types.Block
-		err = codec.GetCodec().Unmarshal(blockBz, &block)
-		require.NoError(t, err)
-		require.Len(t, block.Transactions, 1)
-		require.Equal(t, txBz, block.Transactions[0])
-		require.Equal(t, expectedAppHash, block.Hash) // block
-		if i > 0 {
-			require.Equal(t, encodedAppHash[i-1], block.PrevHash) // chain
-		}
-
-	}
-}
-
-// Tests/debug to implement:
-// - Visibility into what's in the tree
-// - Benchmarking many inserts
-// - Release / revert mid block and making sure everything is reverted
-// - Thinking about how it can be synched
-// - Playing back several blocks
-
-func heightToBytes(height int64) []byte {
-	heightBytes := make([]byte, 8)
-	binary.LittleEndian.PutUint64(heightBytes, uint64(height))
-	return heightBytes
-}
+// func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
+// 	// These hashes were determined manually by running the test, but hardcoded to guarantee
+// 	// that the business logic doesn't change and that they remain deterministic.
+// 	encodedAppHash := []string{
+// 		"62adad6925267abe075dc62ffb9b8d960709409b097b75dd6b3ea4cce31d1482",
+// 		"c1af3fda156bce4162df755f0095ae4f909477fc385f761c6e8d2ef6eb2d9fa6",
+// 		"e65d0c2cd78f180d774bfe43e52a49fad490bf208fcc6d167f2b6543ab280cb9",
+// 	}
+
+// 	for i := 0; i < 3; i++ {
+// 		// Get the context at the new height and retrieve one of the apps
+// 		height := int64(i + 1)
+// 		heightBz := heightToBytes(height)
+// 		expectedAppHash := encodedAppHash[i]
+
+// 		db := NewTestPostgresContext(t, height)
+
+// 		apps, err := db.GetAllApps(height)
+// 		require.NoError(t, err)
+// 		app := apps[0]
+
+// 		addrBz, err := hex.DecodeString(app.GetAddress())
+// 		require.NoError(t, err)
+
+// 		// Update the app's stake
+// 		newStakeAmount := types.BigIntToString(big.NewInt(height + int64(420000000000)))
+// 		err = db.SetAppStakeAmount(addrBz, newStakeAmount)
+// 		require.NoError(t, err)
+
+// 		// NOTE: The tx does not currently affect the state hash
+// 		txBz := []byte("a tx, i am, which set the app stake amount to " + newStakeAmount)
+// 		// txResult := types.DefaultTx
+// 		// err = db.StoreTransaction(txBz)
+// 		// require.NoError(t, err)
+
+// 		// Update & commit the state hash
+// 		appHash, err := db.UpdateAppHash()
+// 		require.NoError(t, err)
+// 		require.Equal(t, expectedAppHash, hex.EncodeToString(appHash))
+
+// 		err = db.Commit([]byte("proposer"), []byte("quorumCert"))
+// 		require.NoError(t, err)
+
+// 		// Verify the block contents
+// 		blockBz, err := testPersistenceMod.GetBlockStore().Get(heightBz)
+// 		require.NoError(t, err)
+
+// 		var block types.Block
+// 		err = codec.GetCodec().Unmarshal(blockBz, &block)
+// 		require.NoError(t, err)
+// 		require.Len(t, block.Transactions, 1)
+// 		require.Equal(t, txBz, block.Transactions[0])
+// 		require.Equal(t, expectedAppHash, block.Hash) // block
+// 		if i > 0 {
+// 			require.Equal(t, encodedAppHash[i-1], block.PrevHash) // chain
+// 		}
+
+// 	}
+// }
+
+// // Tests/debug to implement:
+// // - Visibility into what's in the tree
+// // - Benchmarking many inserts
+// // - Release / revert mid block and making sure everything is reverted
+// // - Thinking about how it can be synched
+// // - Playing back several blocks
+
+// func heightToBytes(height int64) []byte {
+// 	heightBytes := make([]byte, 8)
+// 	binary.LittleEndian.PutUint64(heightBytes, uint64(height))
+// 	return heightBytes
+// }

From 6e953a120d3709dc98554daada7b330a5b34c6d6 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Fri, 28 Oct 2022 21:46:44 -0700
Subject: [PATCH 102/227] Deterministic hash working with TxResult

---
 persistence/context.go              |   1 -
 persistence/test/setup_test.go      |   4 +
 persistence/test/state_test.go      | 167 ++++++++++++++++------------
 runtime/test_artifacts/generator.go |  55 ++++++---
 4 files changed, 137 insertions(+), 90 deletions(-)

diff --git a/persistence/context.go b/persistence/context.go
index ffce0bf2a..2df1b75f2 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -48,7 +48,6 @@ func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
 	if err := p.GetTx().Commit(ctx); err != nil {
 		return err
 	}
-
 	if err := p.conn.Close(ctx); err != nil {
 		log.Println("[TODO][ERROR] Implement connection pooling. Error when closing DB connecting...", err)
 	}
diff --git a/persistence/test/setup_test.go b/persistence/test/setup_test.go
index 140315e87..0f576471f 100644
--- a/persistence/test/setup_test.go
+++ b/persistence/test/setup_test.go
@@ -107,6 +107,10 @@ func NewFuzzTestPostgresContext(f *testing.F, height int64) *persistence.Postgre
 
 // TODO(andrew): Take in `t testing.T` as a parameter and error if there's an issue
 func newTestPersistenceModule(databaseUrl string) modules.PersistenceModule {
+	// HACK: See `runtime/test_artifacts/generator.go` for why this is needed
+	os.Setenv(test_artifacts.PrivateKeySeedEnv, "42")
+	defer os.Unsetenv(test_artifacts.PrivateKeySeedEnv)
+
 	cfg := runtime.NewConfig(&runtime.BaseConfig{}, runtime.WithPersistenceConfig(&types.PersistenceConfig{
 		PostgresUrl:    databaseUrl,
 		NodeSchema:     testSchema,
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index 7aecdf226..74e33e4ee 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -1,74 +1,97 @@
 package test
 
-// func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
-// 	// These hashes were determined manually by running the test, but hardcoded to guarantee
-// 	// that the business logic doesn't change and that they remain deterministic.
-// 	encodedAppHash := []string{
-// 		"62adad6925267abe075dc62ffb9b8d960709409b097b75dd6b3ea4cce31d1482",
-// 		"c1af3fda156bce4162df755f0095ae4f909477fc385f761c6e8d2ef6eb2d9fa6",
-// 		"e65d0c2cd78f180d774bfe43e52a49fad490bf208fcc6d167f2b6543ab280cb9",
-// 	}
-
-// 	for i := 0; i < 3; i++ {
-// 		// Get the context at the new height and retrieve one of the apps
-// 		height := int64(i + 1)
-// 		heightBz := heightToBytes(height)
-// 		expectedAppHash := encodedAppHash[i]
-
-// 		db := NewTestPostgresContext(t, height)
-
-// 		apps, err := db.GetAllApps(height)
-// 		require.NoError(t, err)
-// 		app := apps[0]
-
-// 		addrBz, err := hex.DecodeString(app.GetAddress())
-// 		require.NoError(t, err)
-
-// 		// Update the app's stake
-// 		newStakeAmount := types.BigIntToString(big.NewInt(height + int64(420000000000)))
-// 		err = db.SetAppStakeAmount(addrBz, newStakeAmount)
-// 		require.NoError(t, err)
-
-// 		// NOTE: The tx does not currently affect the state hash
-// 		txBz := []byte("a tx, i am, which set the app stake amount to " + newStakeAmount)
-// 		// txResult := types.DefaultTx
-// 		// err = db.StoreTransaction(txBz)
-// 		// require.NoError(t, err)
-
-// 		// Update & commit the state hash
-// 		appHash, err := db.UpdateAppHash()
-// 		require.NoError(t, err)
-// 		require.Equal(t, expectedAppHash, hex.EncodeToString(appHash))
-
-// 		err = db.Commit([]byte("proposer"), []byte("quorumCert"))
-// 		require.NoError(t, err)
-
-// 		// Verify the block contents
-// 		blockBz, err := testPersistenceMod.GetBlockStore().Get(heightBz)
-// 		require.NoError(t, err)
-
-// 		var block types.Block
-// 		err = codec.GetCodec().Unmarshal(blockBz, &block)
-// 		require.NoError(t, err)
-// 		require.Len(t, block.Transactions, 1)
-// 		require.Equal(t, txBz, block.Transactions[0])
-// 		require.Equal(t, expectedAppHash, block.Hash) // block
-// 		if i > 0 {
-// 			require.Equal(t, encodedAppHash[i-1], block.PrevHash) // chain
-// 		}
-
-// 	}
-// }
-
-// // Tests/debug to implement:
-// // - Visibility into what's in the tree
-// // - Benchmarking many inserts
-// // - Release / revert mid block and making sure everything is reverted
-// // - Thinking about how it can be synched
-// // - Playing back several blocks
-
-// func heightToBytes(height int64) []byte {
-// 	heightBytes := make([]byte, 8)
-// 	binary.LittleEndian.PutUint64(heightBytes, uint64(height))
-// 	return heightBytes
-// }
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"math/big"
+	"testing"
+
+	"github.com/pokt-network/pocket/persistence/indexer"
+	"github.com/pokt-network/pocket/persistence/types"
+	"github.com/pokt-network/pocket/shared/codec"
+	"github.com/pokt-network/pocket/shared/modules"
+	"github.com/stretchr/testify/require"
+)
+
+func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
+	// These hashes were determined manually by running the test, but hardcoded to guarantee
+	// that the business logic doesn't change and that they remain deterministic.
+	encodedAppHash := []string{
+		"f13ddc447bdebd38b1db7d534915992fa2b6dd4aabdc81868e3420df37b3647f",
+		"40ba19443d9c18d12c17ed25e86ae1aa34ecc1080cc0208854dc72e51f9b8b94",
+		"b7578e3d5a675effe31475ce0df034a2aec21c983b4a3c34c23ad9b583cb60eb",
+	}
+
+	for i := 0; i < 3; i++ {
+		// Get the context at the new height and retrieve one of the apps
+		height := int64(i + 1)
+		heightBz := heightToBytes(height)
+		expectedAppHash := encodedAppHash[i]
+
+		db := NewTestPostgresContext(t, height)
+
+		apps, err := db.GetAllApps(height)
+		require.NoError(t, err)
+		app := apps[0]
+
+		addrBz, err := hex.DecodeString(app.GetAddress())
+		require.NoError(t, err)
+
+		// Update the app's stake
+		newStakeAmount := types.BigIntToString(big.NewInt(height + int64(420000000000)))
+		err = db.SetAppStakeAmount(addrBz, newStakeAmount)
+		require.NoError(t, err)
+
+		txBz := []byte("a tx, i am, which set the app stake amount to " + newStakeAmount)
+		txResult := indexer.TxRes{
+			Tx:            txBz,
+			Height:        height,
+			Index:         0,
+			ResultCode:    0,
+			Error:         "",
+			SignerAddr:    "",
+			RecipientAddr: "",
+			MessageType:   "",
+		}
+
+		// txResult := mockTxResult(t, height, txBz)
+		err = db.StoreTransaction(modules.TxResult(&txResult))
+		require.NoError(t, err)
+
+		// Update & commit the state hash
+		appHash, err := db.UpdateAppHash()
+		require.NoError(t, err)
+		require.Equal(t, expectedAppHash, hex.EncodeToString(appHash))
+
+		err = db.Commit([]byte("proposer"), []byte("quorumCert"))
+		require.NoError(t, err)
+
+		// Verify the block contents
+		blockBz, err := testPersistenceMod.GetBlockStore().Get(heightBz)
+		require.NoError(t, err)
+
+		var block types.Block
+		err = codec.GetCodec().Unmarshal(blockBz, &block)
+		require.NoError(t, err)
+		require.Len(t, block.Transactions, 1)
+		// require.Equal(t, txResult.GetTx(), block.Transactions[0])
+		require.Equal(t, expectedAppHash, block.Hash) // block
+		if i > 0 {
+			require.Equal(t, encodedAppHash[i-1], block.PrevHash) // chain
+		}
+
+	}
+}
+
+// Tests/debug to implement:
+// - Visibility into what's in the tree
+// - Benchmarking many inserts
+// - Release / revert mid block and making sure everything is reverted
+// - Thinking about how it can be synched
+// - Playing back several blocks
+
+func heightToBytes(height int64) []byte {
+	heightBytes := make([]byte, 8)
+	binary.LittleEndian.PutUint64(heightBytes, uint64(height))
+	return heightBytes
+}
diff --git a/runtime/test_artifacts/generator.go b/runtime/test_artifacts/generator.go
index 815a4458b..975ade5d2 100644
--- a/runtime/test_artifacts/generator.go
+++ b/runtime/test_artifacts/generator.go
@@ -6,6 +6,8 @@ import (
 	"encoding/binary"
 	"fmt"
 	"math/big"
+	"math/rand"
+	"os"
 	"strconv"
 
 	typesCons "github.com/pokt-network/pocket/consensus/types"
@@ -40,9 +42,28 @@ var (
 	ServiceUrlFormat           = "node%d.consensus:8080"
 )
 
-// TODO (Team) this is meant to be a **temporary** replacement for the recently deprecated
-// 'genesis config' option. We need to implement a real suite soon!
+// HACK: This is a hack used to enable deterministic key generation via an environment variable.
+// In order to avoid this, `NewGenesisState` and all downstream functions would need to be
+// refactored, or the seed would need to be passed via the runtime manager. To avoid these large
+// scale changes, this is a temporary approach
+const PrivateKeySeedEnv = "PRIVATE_KEY_SEED"
+
+var privateKeySeed int
+
+func loadPrivateKeySeed() {
+	privateKeySeedEnvValue := os.Getenv(PrivateKeySeedEnv)
+	if seedInt, err := strconv.Atoi(privateKeySeedEnvValue); err == nil {
+		privateKeySeed = seedInt
+	} else {
+		rand.Seed(timestamppb.Now().Seconds)
+		privateKeySeed = rand.Int()
+	}
+}
+
+// IMPROVE: This was initially a temp replacement, so create real genesis suite soon!
 func NewGenesisState(numValidators, numServiceNodes, numApplications, numFisherman int) (modules.GenesisState, []string) {
+	loadPrivateKeySeed()
+
 	apps, appsPrivateKeys := NewActors(types.ActorType_App, numApplications)
 	vals, validatorPrivateKeys := NewActors(types.ActorType_Validator, numValidators)
 	serviceNodes, snPrivateKeys := NewActors(types.ActorType_ServiceNode, numServiceNodes)
@@ -66,6 +87,7 @@ func NewGenesisState(numValidators, numServiceNodes, numApplications, numFisherm
 		},
 	)
 
+	// TODO: Generalize this to all actors and not just validators
 	return genesisState, validatorPrivateKeys
 }
 
@@ -134,8 +156,7 @@ func NewPools() (pools []modules.Account) { // TODO (Team) in the real testing s
 
 func NewAccounts(n int, privateKeys ...string) (accounts []modules.Account) {
 	for i := 0; i < n; i++ {
-		// _, _, addr := GenerateNewKeysDeterministic(69)
-		_, _, addr := GenerateNewKeysStrings()
+		_, _, addr := generateNewKeysStrings()
 		if privateKeys != nil {
 			pk, _ := crypto.NewPrivateKey(privateKeys[i])
 			addr = pk.Address().String()
@@ -169,8 +190,7 @@ func getServiceUrl(n int) string {
 }
 
 func NewDefaultActor(actorType int32, genericParam string) (actor modules.Actor, privateKey string) {
-	// privKey, pubKey, addr := GenerateNewKeysDeterministic(69)
-	privKey, pubKey, addr := GenerateNewKeysStrings()
+	privKey, pubKey, addr := generateNewKeysStrings()
 	chains := DefaultChains
 	if actorType == int32(typesPers.ActorType_Val) {
 		chains = nil
@@ -190,24 +210,18 @@ func NewDefaultActor(actorType int32, genericParam string) (actor modules.Actor,
 	}, privKey
 }
 
-func GenerateNewKeysStrings() (privateKey, publicKey, address string) {
-	privKey, pubKey, addr := GenerateNewKeys()
+func generateNewKeysStrings2() (privateKey, publicKey, address string) {
+	privKey, pubKey, addr := generateNewKeys()
 	privateKey = privKey.String()
 	publicKey = pubKey.String()
 	address = addr.String()
 	return
 }
 
-func GenerateNewKeys() (privateKey crypto.PrivateKey, publicKey crypto.PublicKey, address crypto.Address) {
-	privateKey, _ = crypto.GeneratePrivateKey()
-	publicKey = privateKey.PublicKey()
-	address = publicKey.Address()
-	return
-}
-
-func GenerateNewKeysDeterministic(seed uint32) (privateKey, publicKey, address string) {
+func generateNewKeysStrings() (privateKey, publicKey, address string) {
+	privateKeySeed += 1 // Different on every call but deterministic
 	cryptoSeed := make([]byte, crypto.SeedSize)
-	binary.LittleEndian.PutUint32(cryptoSeed, seed)
+	binary.LittleEndian.PutUint32(cryptoSeed, uint32(privateKeySeed))
 
 	reader := bytes.NewReader(cryptoSeed)
 	privateKeyBz, err := crypto.GeneratePrivateKeyWithReader(reader)
@@ -221,3 +235,10 @@ func GenerateNewKeysDeterministic(seed uint32) (privateKey, publicKey, address s
 
 	return
 }
+
+func generateNewKeys() (privateKey crypto.PrivateKey, publicKey crypto.PublicKey, address crypto.Address) {
+	privateKey, _ = crypto.GeneratePrivateKey()
+	publicKey = privateKey.PublicKey()
+	address = publicKey.Address()
+	return
+}

From d21d5dcb2acbe0c1d86a243f54e6823e957ca961 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sat, 29 Oct 2022 15:43:09 -0700
Subject: [PATCH 103/227] Finished self review of all the simple code

---
 consensus/debugging.go                    |  2 +-
 persistence/StateHash.md                  | 92 -----------------------
 persistence/block.go                      | 47 ++++++------
 persistence/context.go                    |  7 +-
 persistence/db.go                         | 11 +--
 persistence/debug.go                      | 12 ++-
 persistence/genesis.go                    | 13 ++--
 persistence/module.go                     |  3 +-
 persistence/proto/block_persistence.proto |  4 +-
 persistence/shared_sql.go                 |  1 -
 persistence/state.go                      | 19 +++--
 persistence/test/module_test.go           | 12 ++-
 persistence/test/setup_test.go            | 15 ++--
 persistence/test/state_test.go            |  1 +
 runtime/test_artifacts/generator.go       | 27 ++-----
 runtime/test_artifacts/util.go            |  3 +-
 shared/debug/proto/debug_message.proto    |  6 +-
 shared/modules/persistence_module.go      |  3 -
 utility/block.go                          |  9 ++-
 utility/context.go                        |  7 +-
 utility/test/actor_test.go                |  2 +-
 utility/test/block_test.go                |  5 +-
 utility/test/module_test.go               |  9 ++-
 utility/types/message_test.go             |  1 -
 24 files changed, 107 insertions(+), 204 deletions(-)
 delete mode 100644 persistence/StateHash.md

diff --git a/consensus/debugging.go b/consensus/debugging.go
index 1a3fe0f5c..aad6a0353 100644
--- a/consensus/debugging.go
+++ b/consensus/debugging.go
@@ -48,7 +48,7 @@ func (m *consensusModule) resetToGenesis(_ *debug.DebugMessage) {
 	m.clearLeader()
 	m.clearMessagesPool()
 	m.GetBus().GetPersistenceModule().HandleDebugMessage(&debug.DebugMessage{
-		Action:  debug.DebugMessageAction_DEBUG_CLEAR_STATE,
+		Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_RESET_TO_GENESIS,
 		Message: nil,
 	})
 	m.GetBus().GetPersistenceModule().Start() // reload genesis state
diff --git a/persistence/StateHash.md b/persistence/StateHash.md
deleted file mode 100644
index 1ec5d0ef2..000000000
--- a/persistence/StateHash.md
+++ /dev/null
@@ -1,92 +0,0 @@
-ROUGH NOTES - DELETE LATER
-
-1.  Simplify interfaces in utility & persistence (make it simple and clear)
-2.  How do we revert changes to the merkle trees?
-3.  Draw an end-to-end diagram of everything and the data flow
-
-## References:
-
-- https://github.com/cosmos/cosmos-sdk/discussions/9158
-- https://github.com/cosmos/cosmos-sdk/pull/8012
-- https://github.com/cosmos/cosmos-sdk/discussions/8297
-- https://github.com/cosmos/cosmos-sdk/discussions/8297
-- https://paper.dropbox.com/doc/State-commitments-and-storage-review--BpuF08OSksSkLeErjf66jrOAAg-wKl2RINZWD9I0DUmZIFwQ
-- https://arxiv.org/pdf/1803.05069.pdf
-
-## Open questions:
-
-1. Review flows
-2. How do we revert changes to the merkle trees?
-
-# This discussion is aimed at:
-
-1. Defining how we should compute the state hash
-2. Identify potential changes needed in the current codebase
-3. Propose next steps and actionable on implementation
-
-## Goals:
-
-- Define how the state hash will be computed
-- Propose the necessary changes in separate tasks
-- Implement each of the necessary pieces
-
-## Non-goals:
-
-- Choice/decision of Merkle Tree Design & Implementation
-- Selection of a key-value store engine
-
-## Primitives / non-negotiables:
-
-- We will be using Merkle Trees (and Merkle Proofs) for this design (i.e. not vector commitments)
-- We will be using a SQL engine for this (i.e. specifically PostgresSQL)
-- We will be using Protobufs (not Flatbuffers, json, yaml or other) for the schema
-
-## Necessary technical context:
-
-### DB Engines
-
-Insert table from here: [Merkle Tree Design & Implementation](https://tikv.org/deep-dive/key-value-engine/b-tree-vs-lsm/#summary)
-
-- Most **Key-Value Store DB** Engines use **LSM-trees** -> good for writes
-- Most **SQL DB** Engines use **B-Trees** -> good for reads
-
-_Basically all but there can be exceptions_
-
-### Addressable Merkle Trees
-
-State is stored use an Account Based (non UTXO) based Modle
-
-Insert image from: https://www.horizen.io/blockchain-academy/technology/expert/utxo-vs-account-model/#:~:text=The%20UTXO%20model%20is%20a,constructions%2C%20as%20well%20a%20sharding.
-
----
-
-### Data Flow
-
-## Basics:
-
-1. Get each actor (flag, param, etc...) updated at a certain height (the context's height)
-2. Compute the protobuf (the deterministic schema we use as source of truth)
-3. Serialize the data struct
-4. Update the corresponding merkle tree
-5. Compute a state hash from the aggregated roots of all trees as per pokt-network/pocket-network-protocol@main/persistence#562-state-transition-sequence-diagram
-
-## Q&A
-
-Q: Can the SQL Engine be changed?
-A: Yes
-
-Q: Can the SQL Engine be removed altogether?
-A: Yes, but hard
-
-Q: Can the protobuf schema change?
-A: Yes, but out-of-scope
-
-Q: Can protobufs be replaced?
-A: Maybe, but out-of-scope
-
----
-
-Learnings / Ideas:
-
-- Consolidate `UtilActorType` and `persistence.ActorType`
-- `modules.Actors` interface vs `types.Actor` in persistenceGenesis
diff --git a/persistence/block.go b/persistence/block.go
index 854a6f5f4..aa1b42eec 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -21,7 +21,7 @@ func (p PostgresContext) GetLatestBlockHeight() (latestHeight uint64, err error)
 	return
 }
 
-// OPTIMIZE(team): get from blockstore or keep in cache/memory
+// OPTIMIZE: get from blockstore or keep in cache/memory
 func (p PostgresContext) GetBlockHash(height int64) ([]byte, error) {
 	ctx, tx, err := p.GetCtxAndTx()
 	if err != nil {
@@ -61,34 +61,17 @@ func (p PostgresContext) StoreTransaction(txResult modules.TxResult) error {
 	return p.txIndexer.Index(txResult)
 }
 
-func (p *PostgresContext) insertBlock(block *types.Block) error {
-	ctx, tx, err := p.GetCtxAndTx()
-	if err != nil {
-		return err
-	}
-
-	_, err = tx.Exec(ctx, types.InsertBlockQuery(block.Height, block.Hash, block.ProposerAddress, block.QuorumCertificate))
-	return err
-}
-
-func (p PostgresContext) storeBlock(block *types.Block) error {
-	blockBz, err := codec.GetCodec().Marshal(block)
-	if err != nil {
-		return err
-	}
-	return p.blockStore.Set(heightToBytes(p.Height), blockBz)
-}
-
+// Creates a block protobuf object using the schema defined in the persistence module
 func (p *PostgresContext) prepareBlock(proposerAddr []byte, quorumCert []byte) (*types.Block, error) {
 	var prevHash []byte
-	if p.Height > 0 {
+	if p.Height == 0 {
+		prevHash = []byte("")
+	} else {
 		var err error
 		prevHash, err = p.GetBlockHash(p.Height - 1)
 		if err != nil {
 			return nil, err
 		}
-	} else {
-		prevHash = []byte("HACK: get hash from genesis")
 	}
 
 	txResults, err := p.txIndexer.GetByHeight(p.Height, false)
@@ -113,6 +96,26 @@ func (p *PostgresContext) prepareBlock(proposerAddr []byte, quorumCert []byte) (
 	return block, nil
 }
 
+// Inserts the block into the postgres database
+func (p *PostgresContext) insertBlock(block *types.Block) error {
+	ctx, tx, err := p.GetCtxAndTx()
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, types.InsertBlockQuery(block.Height, block.Hash, block.ProposerAddress, block.QuorumCertificate))
+	return err
+}
+
+// Stores the block in the key-value store
+func (p PostgresContext) storeBlock(block *types.Block) error {
+	blockBz, err := codec.GetCodec().Marshal(block)
+	if err != nil {
+		return err
+	}
+	return p.blockStore.Set(heightToBytes(p.Height), blockBz)
+}
+
 func heightToBytes(height int64) []byte {
 	heightBytes := make([]byte, 8)
 	binary.LittleEndian.PutUint64(heightBytes, uint64(height))
diff --git a/persistence/context.go b/persistence/context.go
index 2df1b75f2..e582f7c55 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -5,7 +5,7 @@ import (
 	"log"
 )
 
-// DISCUSS: Why aren't these receivers pointers?
+// CLEANUP: Figure out why the receivers here aren't pointers?
 
 func (p PostgresContext) NewSavePoint(bytes []byte) error {
 	log.Println("TODO: NewSavePoint not implemented")
@@ -76,20 +76,25 @@ func (pg *PostgresContext) resetContext() (err error) {
 	if pg == nil {
 		return nil
 	}
+
 	tx := pg.GetTx()
 	if tx == nil {
 		return nil
 	}
+
 	conn := tx.Conn()
 	if conn == nil {
 		return nil
 	}
+
 	if !conn.IsClosed() {
 		if err := conn.Close(context.TODO()); err != nil {
 			return err
 		}
 	}
+
 	pg.conn = nil
 	pg.tx = nil
+
 	return err
 }
diff --git a/persistence/db.go b/persistence/db.go
index 0565b429a..b6f9a379d 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -5,14 +5,12 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/pokt-network/pocket/persistence/indexer"
-
-	"github.com/pokt-network/pocket/persistence/types"
-
 	"github.com/celestiaorg/smt"
 	"github.com/jackc/pgconn"
 	"github.com/jackc/pgx/v4"
+	"github.com/pokt-network/pocket/persistence/indexer"
 	"github.com/pokt-network/pocket/persistence/kvstore"
+	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
@@ -55,14 +53,11 @@ type PostgresContext struct {
 	txIndexer        indexer.TxIndexer
 	currentStateHash []byte
 
-	// REARCHITECT_IN_THIS_COMMIT: This is a passthrough from the persistence module (i.e. not context).
-	// Consider making this accessible via the persistence module interface and accessing it via the bus.
+	// REFACTOR: Access `blockStore` and `merkleTree` from the persistence module via bus.
 	blockStore  kvstore.KVStore
 	merkleTrees map[MerkleTree]*smt.SparseMerkleTree
 }
 
-// TODO: Reduce the scope of these functions
-
 func (pg *PostgresContext) GetCtxAndTx() (context.Context, pgx.Tx, error) {
 	return context.TODO(), pg.GetTx(), nil
 }
diff --git a/persistence/debug.go b/persistence/debug.go
index df9368592..586d3b1f1 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -12,9 +12,13 @@ func (m *persistenceModule) HandleDebugMessage(debugMessage *debug.DebugMessage)
 	switch debugMessage.Action {
 	case debug.DebugMessageAction_DEBUG_SHOW_LATEST_BLOCK_IN_STORE:
 		m.showLatestBlockInStore(debugMessage)
-	case debug.DebugMessageAction_DEBUG_CLEAR_STATE:
-		if err := m.ClearState(debugMessage); err != nil {
-			log.Fatalf("Error clearing state: %s \n", err)
+	case debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE:
+		if err := m.clearState(debugMessage); err != nil {
+			return err
+		}
+	case debug.DebugMessageAction_DEBUG_PERSISTENCE_RESET_TO_GENESIS:
+		if err := m.clearState(debugMessage); err != nil {
+			return err
 		}
 		g := m.genesisState.(*types.PersistenceGenesisState)
 		m.populateGenesisState(g) // fatal if there's an error
@@ -39,7 +43,7 @@ func (m *persistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 	log.Printf("Block at height %d with %d transactions: %+v \n", height, len(block.Transactions), block)
 }
 
-func (m *persistenceModule) ClearState(_ *debug.DebugMessage) error {
+func (m *persistenceModule) clearState(_ *debug.DebugMessage) error {
 	context, err := m.NewRWContext(-1)
 	if err != nil {
 		return err
diff --git a/persistence/genesis.go b/persistence/genesis.go
index 4a800744d..9649e1b15 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -9,7 +9,7 @@ import (
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
-// WARNING: This function crashes the process if there is an error populating the genesis state.
+// DISCUSS: Should we make this return an error and let the caller decide if it should log a fatal error?
 func (m *persistenceModule) populateGenesisState(state modules.PersistenceGenesisState) {
 	log.Println("Populating genesis state...")
 
@@ -143,11 +143,8 @@ func (m *persistenceModule) populateGenesisState(state modules.PersistenceGenesi
 		log.Fatalf("an error occurred initializing flags: %s", err.Error())
 	}
 
-	if err = rwContext.Commit(
-		[]byte("HACK_IN_THIS_COMMIT: genesisProposerPlaceholder"),
-		[]byte("HACK_IN_THIS_COMMIT: genesisQuorumCertPlaceholder"),
-	); err != nil {
-		log.Fatalf("error committing populateGenesisState %s ", err.Error())
+	if err = rwContext.Commit([]byte("placeholderGenesisProposer"), []byte("placeholderQuorumCert")); err != nil {
+		log.Fatalf("error committing genesis state to DB %s ", err.Error())
 	}
 }
 
@@ -219,8 +216,8 @@ func (p PostgresContext) GetAllApps(height int64) (apps []modules.Actor, err err
 	}
 	rows.Close()
 	for _, actor := range actors {
-		actorWithChains, er := p.GetChainsForActor(ctx, tx, types.ApplicationActor, actor, height)
-		if er != nil {
+		actorWithChains, err := p.GetChainsForActor(ctx, tx, types.ApplicationActor, actor, height)
+		if err != nil {
 			return nil, err
 		}
 		apps = append(apps, actorWithChains)
diff --git a/persistence/module.go b/persistence/module.go
index 01de09393..a590c27e8 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -29,8 +29,7 @@ type persistenceModule struct {
 	config       modules.PersistenceConfig
 	genesisState modules.PersistenceGenesisState
 
-	// A reference to the block key-value store
-	blockStore kvstore.KVStore // INVESTIGATE: We may need to create a custom `BlockStore` package in the future
+	blockStore kvstore.KVStore
 	txIndexer  indexer.TxIndexer
 
 	// TECHDEBT: Need to implement context pooling (for writes), timeouts (for read & writes), etc...
diff --git a/persistence/proto/block_persistence.proto b/persistence/proto/block_persistence.proto
index 7a69403ea..887a9212c 100644
--- a/persistence/proto/block_persistence.proto
+++ b/persistence/proto/block_persistence.proto
@@ -9,7 +9,5 @@ message Block {
     string prevHash = 3;
     bytes proposerAddress = 4;
     bytes quorumCertificate = 5;
-    // REARCHITECT_IN_THIS_COMMIT: Since transactions are stored in the TX Indexer, do we only
-    // need a collective hash here or all the bytes?
-    repeated bytes transactions = 6;
+    repeated bytes transactions = 6; // DISCUSS_IN_THIS_COMMIT(drewskey): Just one hash here?
 }
\ No newline at end of file
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
index 62d454e31..09494afe9 100644
--- a/persistence/shared_sql.go
+++ b/persistence/shared_sql.go
@@ -70,7 +70,6 @@ func (p *PostgresContext) GetActorsUpdated(actorSchema types.ProtocolActorSchema
 	}
 	rows.Close()
 
-	// OPTIMIZE: Consolidate logic with `GetActor` to reduce code footprint
 	actors = make([]*types.Actor, len(addrs))
 	for i, addr := range addrs {
 		actor, err := p.GetActor(actorSchema, []byte(addr), height)
diff --git a/persistence/state.go b/persistence/state.go
index 82ba0a611..e41667dda 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -14,9 +14,9 @@ import (
 
 type MerkleTree float64
 
-// A work-in-progress list of all the trees we need to update to maintain the overall state
+// A list of Merkle Trees used to maintain the state hash
 const (
-	// Actor  Merkle Trees
+	// Actor Merkle Trees
 	appMerkleTree MerkleTree = iota
 	valMerkleTree
 	fishMerkleTree
@@ -26,13 +26,13 @@ const (
 	accountMerkleTree
 	poolMerkleTree
 
-	// Data / State Merkle Trees
+	// Data Merkle Trees
 	blocksMerkleTree
 	paramsMerkleTree
 	flagsMerkleTree
 
 	// Used for iteration purposes only - see https://stackoverflow.com/a/64178235/768439
-	lastMerkleTree
+	numMerkleTrees
 )
 
 var actorTypeToMerkleTreeName map[types.ActorType]MerkleTree = map[types.ActorType]MerkleTree{
@@ -57,10 +57,9 @@ var actorTypeToSchemaName map[types.ActorType]types.ProtocolActorSchema = map[ty
 }
 
 func newMerkleTrees() (map[MerkleTree]*smt.SparseMerkleTree, error) {
-	// We need a separate Merkle tree for each type of actor or storage
-	trees := make(map[MerkleTree]*smt.SparseMerkleTree, int(lastMerkleTree))
+	trees := make(map[MerkleTree]*smt.SparseMerkleTree, int(numMerkleTrees))
 
-	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
+	for treeType := MerkleTree(0); treeType < numMerkleTrees; treeType++ {
 		// TODO_IN_THIS_COMMIT: Rather than using `NewSimpleMap`, use a disk based key-value store
 		nodeStore := smt.NewSimpleMap()
 		valueStore := smt.NewSimpleMap()
@@ -71,12 +70,12 @@ func newMerkleTrees() (map[MerkleTree]*smt.SparseMerkleTree, error) {
 }
 
 func loadMerkleTrees(map[MerkleTree]*smt.SparseMerkleTree, error) {
-	log.Fatalf("loadMerkleTrees not implemented yet")
+	log.Fatalf("TODO: loadMerkleTrees not implemented yet")
 }
 
 func (p *PostgresContext) updateStateHash() error {
 	// Update all the merkle trees
-	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
+	for treeType := MerkleTree(0); treeType < numMerkleTrees; treeType++ {
 		switch treeType {
 		case appMerkleTree:
 			fallthrough
@@ -113,7 +112,7 @@ func (p *PostgresContext) updateStateHash() error {
 
 	// Get the root of each Merkle Tree
 	roots := make([][]byte, 0)
-	for treeType := MerkleTree(0); treeType < lastMerkleTree; treeType++ {
+	for treeType := MerkleTree(0); treeType < numMerkleTrees; treeType++ {
 		roots = append(roots, p.merkleTrees[treeType].Root())
 	}
 
diff --git a/persistence/test/module_test.go b/persistence/test/module_test.go
index 2668f0a1b..02354cf78 100644
--- a/persistence/test/module_test.go
+++ b/persistence/test/module_test.go
@@ -3,6 +3,7 @@ package test
 import (
 	"testing"
 
+	"github.com/pokt-network/pocket/shared/debug"
 	"github.com/stretchr/testify/require"
 )
 
@@ -114,11 +115,16 @@ func prepareAndCleanContext(t *testing.T) {
 	// Cleanup context after the test
 	t.Cleanup(func() {
 		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
-		require.NoError(t, testPersistenceMod.ClearState(nil))
+		require.NoError(t, testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
+			Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
+			Message: nil,
+		}))
 	})
 
 	// Make sure the db is empty at the start of these tests
 	require.NoError(t, testPersistenceMod.ReleaseWriteContext())
-	require.NoError(t, testPersistenceMod.ClearState(nil))
-
+	require.NoError(t, testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
+		Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
+		Message: nil,
+	}))
 }
diff --git a/persistence/test/setup_test.go b/persistence/test/setup_test.go
index 0f576471f..15e5627aa 100644
--- a/persistence/test/setup_test.go
+++ b/persistence/test/setup_test.go
@@ -58,7 +58,7 @@ func TestMain(m *testing.M) {
 	os.Exit(exitCode)
 }
 
-// TODO_IN_THIS_COMMIT(olshansky): Consider just using `testPersistenceMod` everywhere instead of the underlying context
+// IMPROVE(olshansky): Look into returning `testPersistenceMod` to avoid exposing underlying abstraction.
 func NewTestPostgresContext(t *testing.T, height int64) *persistence.PostgresContext {
 	ctx, err := testPersistenceMod.NewRWContext(height)
 	require.NoError(t, err)
@@ -69,7 +69,7 @@ func NewTestPostgresContext(t *testing.T, height int64) *persistence.PostgresCon
 	t.Cleanup(func() {
 		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
 		require.NoError(t, testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
-			Action:  debug.DebugMessageAction_DEBUG_CLEAR_STATE,
+			Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_RESET_TO_GENESIS,
 			Message: nil,
 		}))
 	})
@@ -77,7 +77,7 @@ func NewTestPostgresContext(t *testing.T, height int64) *persistence.PostgresCon
 	return db
 }
 
-// TODO_IN_THIS_COMMIT(olshansky): Consider just using `testPersistenceMod` everywhere instead of the underlying context
+// IMPROVE(olshansky): Look into returning `testPersistenceMod` to avoid exposing underlying abstraction.
 func NewFuzzTestPostgresContext(f *testing.F, height int64) *persistence.PostgresContext {
 	ctx, err := testPersistenceMod.NewRWContext(height)
 	if err != nil {
@@ -94,7 +94,7 @@ func NewFuzzTestPostgresContext(f *testing.F, height int64) *persistence.Postgre
 			log.Fatalf("Error releasing write context: %v\n", err)
 		}
 		if err := testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
-			Action:  debug.DebugMessageAction_DEBUG_CLEAR_STATE,
+			Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
 			Message: nil,
 		}); err != nil {
 			log.Fatalf("Error clearing state: %v\n", err)
@@ -107,7 +107,7 @@ func NewFuzzTestPostgresContext(f *testing.F, height int64) *persistence.Postgre
 
 // TODO(andrew): Take in `t testing.T` as a parameter and error if there's an issue
 func newTestPersistenceModule(databaseUrl string) modules.PersistenceModule {
-	// HACK: See `runtime/test_artifacts/generator.go` for why this is needed
+	// HACK: See `runtime/test_artifacts/generator.go` for why we're doing this to get deterministic key generation.
 	os.Setenv(test_artifacts.PrivateKeySeedEnv, "42")
 	defer os.Unsetenv(test_artifacts.PrivateKeySeedEnv)
 
@@ -133,11 +133,6 @@ func fuzzSingleProtocolActor(
 	getTestActor func(db *persistence.PostgresContext, address string) (*types.Actor, error),
 	protocolActorSchema types.ProtocolActorSchema) {
 
-	// SELF_REVIEW: Consider if this is the right approach
-	if err := testPersistenceMod.ClearState(nil); err != nil {
-		log.Fatal("Cannot clear state err")
-	}
-
 	db := NewFuzzTestPostgresContext(f, 0)
 
 	actor, err := newTestActor()
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index 74e33e4ee..f97cacd37 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -89,6 +89,7 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 // - Release / revert mid block and making sure everything is reverted
 // - Thinking about how it can be synched
 // - Playing back several blocks
+// - Atomicity - Look into Commit
 
 func heightToBytes(height int64) []byte {
 	heightBytes := make([]byte, 8)
diff --git a/runtime/test_artifacts/generator.go b/runtime/test_artifacts/generator.go
index 975ade5d2..1625aa5b8 100644
--- a/runtime/test_artifacts/generator.go
+++ b/runtime/test_artifacts/generator.go
@@ -43,13 +43,15 @@ var (
 )
 
 // HACK: This is a hack used to enable deterministic key generation via an environment variable.
-// In order to avoid this, `NewGenesisState` and all downstream functions would need to be
-// refactored, or the seed would need to be passed via the runtime manager. To avoid these large
-// scale changes, this is a temporary approach
-const PrivateKeySeedEnv = "PRIVATE_KEY_SEED"
+//       In order to avoid this, `NewGenesisState` and all downstream functions would need to be
+//       refactored. Alternatively, the seed would need to be passed via the runtime manager.
+//       To avoid these large scale changes, this is a temporary approach to enable deterministic
+//       key generation.
+const PrivateKeySeedEnv = "DEFAULT_PRIVATE_KEY_SEED"
 
 var privateKeySeed int
 
+// Intentionally not using `init` in case the caller sets this before `NewGenesisState` is called.s
 func loadPrivateKeySeed() {
 	privateKeySeedEnvValue := os.Getenv(PrivateKeySeedEnv)
 	if seedInt, err := strconv.Atoi(privateKeySeedEnvValue); err == nil {
@@ -60,7 +62,7 @@ func loadPrivateKeySeed() {
 	}
 }
 
-// IMPROVE: This was initially a temp replacement, so create real genesis suite soon!
+// IMPROVE: Generate a proper genesis suite in the future.
 func NewGenesisState(numValidators, numServiceNodes, numApplications, numFisherman int) (modules.GenesisState, []string) {
 	loadPrivateKeySeed()
 
@@ -210,14 +212,6 @@ func NewDefaultActor(actorType int32, genericParam string) (actor modules.Actor,
 	}, privKey
 }
 
-func generateNewKeysStrings2() (privateKey, publicKey, address string) {
-	privKey, pubKey, addr := generateNewKeys()
-	privateKey = privKey.String()
-	publicKey = pubKey.String()
-	address = addr.String()
-	return
-}
-
 func generateNewKeysStrings() (privateKey, publicKey, address string) {
 	privateKeySeed += 1 // Different on every call but deterministic
 	cryptoSeed := make([]byte, crypto.SeedSize)
@@ -235,10 +229,3 @@ func generateNewKeysStrings() (privateKey, publicKey, address string) {
 
 	return
 }
-
-func generateNewKeys() (privateKey crypto.PrivateKey, publicKey crypto.PublicKey, address crypto.Address) {
-	privateKey, _ = crypto.GeneratePrivateKey()
-	publicKey = privateKey.PublicKey()
-	address = publicKey.Address()
-	return
-}
diff --git a/runtime/test_artifacts/util.go b/runtime/test_artifacts/util.go
index f064a7880..fff674db6 100644
--- a/runtime/test_artifacts/util.go
+++ b/runtime/test_artifacts/util.go
@@ -95,7 +95,6 @@ func CleanupPostgresDocker(_ *testing.M, pool *dockertest.Pool, resource *docker
 	}
 }
 
+// TODO(olshansky): Remove this since it's no longer used or necessary.
 func CleanupTest(u utility.UtilityContext) {
-	// require.NoError(t, testPersistenceMod.ReleaseWriteContext()) // Release the write context used in the test
-	// require.NoError(t, testPersistenceMod.ClearState(nil))
 }
diff --git a/shared/debug/proto/debug_message.proto b/shared/debug/proto/debug_message.proto
index e38d42f93..85941eeb2 100644
--- a/shared/debug/proto/debug_message.proto
+++ b/shared/debug/proto/debug_message.proto
@@ -7,12 +7,16 @@ import "google/protobuf/any.proto";
 
 enum DebugMessageAction {
 	DEBUG_ACTION_UNKNOWN = 0;
+
 	DEBUG_CONSENSUS_RESET_TO_GENESIS = 1;
 	DEBUG_CONSENSUS_PRINT_NODE_STATE = 2;
 	DEBUG_CONSENSUS_TRIGGER_NEXT_VIEW = 3;
 	DEBUG_CONSENSUS_TOGGLE_PACE_MAKER_MODE = 4; // toggle between manual and automatic
+
 	DEBUG_SHOW_LATEST_BLOCK_IN_STORE = 5; // toggle between manual and automatic
-	DEBUG_CLEAR_STATE = 6;
+
+	DEBUG_PERSISTENCE_CLEAR_STATE = 6;
+	DEBUG_PERSISTENCE_RESET_TO_GENESIS = 7;
 }
 
 message DebugMessage {
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index f72fc6933..d3454bd9d 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -23,9 +23,6 @@ type PersistenceModule interface {
 
 	// Debugging / development only
 	HandleDebugMessage(*debug.DebugMessage) error
-
-	// HACK: Until utility has no dependency on the real persistence module
-	ClearState(*debug.DebugMessage) error
 }
 
 // Interface defining the context within which the node can operate with the persistence layer.
diff --git a/utility/block.go b/utility/block.go
index f1b872fda..217bc2025 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -37,9 +37,9 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 			return nil, nil, err
 		}
 		// Validate and apply the transaction to the Postgres database
-		// DISCUSS: currently, the pattern is allowing nil err with an error transaction...
-		// Should we terminate applyBlock immediately if there's an invalid transaction?
-		// Or wait until the entire lifecycle is over to evaluate an 'invalid' block
+		// DISCUSS_IN_THIS_COMMIT(#315): currently, the pattern is allowing nil err with an error transaction...
+		//                               Should we terminate applyBlock immediately if there's an invalid transaction?
+		//                               Or wait until the entire lifecycle is over to evaluate an 'invalid' block
 		txResult, err := u.ApplyTransaction(index, tx)
 		if err != nil {
 			return nil, nil, err
@@ -63,9 +63,10 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 		return nil, nil, err
 	}
 
-	// TODO: What if everything above succeeded but updating the app hash failed?
+	// DISCUSS_IN_THIS_COMMIT: What if everything above succeeded but updating the app hash failed?
 	appHash, err = u.Context.UpdateAppHash()
 	if err != nil {
+		// TODO: Rollback the entire block
 		return nil, nil, typesUtil.ErrAppHash(err)
 	}
 
diff --git a/utility/context.go b/utility/context.go
index 10f834550..2e48405dd 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -9,8 +9,9 @@ import (
 )
 
 type UtilityContext struct {
-	LatestHeight    int64  // IMPROVE: Rename to `currentHeight?`
-	currentProposer []byte // REARCHITECT_IN_THIS_COMMIT: Ephemeral block state should only exist in the persistence context
+	// TODO_IN_THIS_COMMIT(#315): Should be removed before this is commited.
+	LatestHeight    int64
+	currentProposer []byte
 
 	Mempool typesUtil.Mempool
 	Context *Context // IMPROVE: Rename to `persistenceContext` or `storeContext` or `reversibleContext`?
@@ -20,7 +21,7 @@ type UtilityContext struct {
 type Context struct {
 	// CLEANUP: Since `Context` embeds `PersistenceRWContext`, we don't need to do `u.Context.PersistenceRWContext`, but can call `u.Context` directly
 	modules.PersistenceRWContext
-	// TODO/DISCUSS: `SavePoints`` have not been implemented yet
+	// TODO: `SavePoints`` have not been implemented yet
 	SavePointsM map[string]struct{}
 	SavePoints  [][]byte
 }
diff --git a/utility/test/actor_test.go b/utility/test/actor_test.go
index 6bfe073ee..084fbef09 100644
--- a/utility/test/actor_test.go
+++ b/utility/test/actor_test.go
@@ -453,7 +453,7 @@ func TestUtilityContext_UnstakePausedBefore(t *testing.T) {
 
 func TestUtilityContext_UnstakeActorsThatAreReady(t *testing.T) {
 	for _, actorType := range actorTypes {
-		t.Run(string(actorType), func(t *testing.T) {
+		t.Run(fmt.Sprintf("%s.UnstakeActorsThatAreReady", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)
 
 			poolName := ""
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index 1c628f930..349a7eeab 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -2,6 +2,7 @@ package test
 
 import (
 	"encoding/hex"
+	"fmt"
 	"math"
 	"math/big"
 	"testing"
@@ -101,7 +102,7 @@ func TestUtilityContext_BeginBlock(t *testing.T) {
 
 func TestUtilityContext_BeginUnstakingMaxPausedActors(t *testing.T) {
 	for _, actorType := range actorTypes {
-		t.Run(string(actorType), func(t *testing.T) {
+		t.Run(fmt.Sprintf("%s.BeginUnstakingMaxPausedActors", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)
 			actor := getFirstActor(t, ctx, actorType)
 
@@ -180,7 +181,7 @@ func TestUtilityContext_EndBlock(t *testing.T) {
 
 func TestUtilityContext_UnstakeValidatorsActorsThatAreReady(t *testing.T) {
 	for _, actorType := range actorTypes {
-		t.Run(string(actorType), func(t *testing.T) {
+		t.Run(fmt.Sprintf("%s.UnstakeValidatorsActorsThatAreReady", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)
 			var poolName string
 			switch actorType {
diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index d5b0247be..d75f32b49 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -9,6 +9,7 @@ import (
 	"github.com/golang/mock/gomock"
 	"github.com/pokt-network/pocket/persistence"
 	"github.com/pokt-network/pocket/runtime/test_artifacts"
+	"github.com/pokt-network/pocket/shared/debug"
 	"github.com/pokt-network/pocket/shared/modules"
 	mock_modules "github.com/pokt-network/pocket/shared/modules/mocks"
 	"github.com/pokt-network/pocket/utility"
@@ -54,14 +55,18 @@ func TestMain(m *testing.M) {
 }
 
 func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext {
+	// IMPROVE: Avoid creating a new persistence module with every test
 	testPersistenceMod := newTestPersistenceModule(t, persistenceDbUrl)
 
 	persistenceContext, err := testPersistenceMod.NewRWContext(height)
 	require.NoError(t, err)
 
 	t.Cleanup(func() {
-		require.NoError(t, testPersistenceMod.ReleaseWriteContext()) // Release the write context used in the test
-		require.NoError(t, testPersistenceMod.ClearState(nil))
+		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
+		require.NoError(t, testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
+			Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
+			Message: nil,
+		}))
 	})
 
 	return utility.UtilityContext{
diff --git a/utility/types/message_test.go b/utility/types/message_test.go
index f282adc88..bf487e64b 100644
--- a/utility/types/message_test.go
+++ b/utility/types/message_test.go
@@ -5,7 +5,6 @@ import (
 	"testing"
 
 	"github.com/pokt-network/pocket/shared/codec"
-
 	"github.com/pokt-network/pocket/shared/crypto"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/protobuf/proto"

From ade27afd6d39e91b28c4c9a74765e42a92bfc147 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sun, 30 Oct 2022 12:30:26 -0700
Subject: [PATCH 104/227] Implemented Account trees

---
 persistence/account.go         |  42 +++++++++++-
 persistence/state.go           | 117 ++++++++++++++++++++++++---------
 persistence/test/state_test.go |  62 +++++++++++------
 persistence/types/account.go   |   8 +++
 utility/block.go               |   4 +-
 5 files changed, 179 insertions(+), 54 deletions(-)

diff --git a/persistence/account.go b/persistence/account.go
index cacb86ef4..eb6b8de0b 100644
--- a/persistence/account.go
+++ b/persistence/account.go
@@ -68,6 +68,10 @@ func (p PostgresContext) SetAccountAmount(address []byte, amount string) error {
 	return nil
 }
 
+func (p PostgresContext) getAccountsUpdated(height int64) (accounts []*types.Account, err error) {
+	return p.getPoolOrAccUpdatedInternal(types.GetAccountsUpdatedAtHeightQuery(height))
+}
+
 func (p *PostgresContext) operationAccountAmount(address []byte, deltaAmount string, op func(*big.Int, *big.Int) error) error {
 	return p.operationPoolOrAccAmount(hex.EncodeToString(address), deltaAmount, op, p.getAccountAmountStr, types.InsertAccountAmountQuery)
 }
@@ -140,10 +144,44 @@ func (p *PostgresContext) operationPoolAmount(name string, amount string, op fun
 	return p.operationPoolOrAccAmount(name, amount, op, p.GetPoolAmount, types.InsertPoolAmountQuery)
 }
 
-func (p *PostgresContext) operationPoolOrAccAmount(name, amount string,
+func (p PostgresContext) getPoolsUpdated(height int64) ([]*types.Account, error) {
+	return p.getPoolOrAccUpdatedInternal(types.GetPoolsUpdatedAtHeightQuery(height))
+}
+
+// Joint Pool & Account Helpers
+
+// Helper for shared logic between `getPoolsUpdated` and `getAccountsUpdated` while keeping an explicit
+// external interface.
+func (p *PostgresContext) getPoolOrAccUpdatedInternal(query string) (accounts []*types.Account, err error) {
+	ctx, tx, err := p.GetCtxAndTx()
+	if err != nil {
+		return
+	}
+
+	rows, err := tx.Query(ctx, query)
+	if err != nil {
+		return nil, err
+	}
+
+	accounts = make([]*types.Account, 0)
+	for rows.Next() {
+		account := new(types.Account)
+		var height int64
+		if err = rows.Scan(&account.Address, &account.Amount, height); err != nil {
+			return nil, err
+		}
+		accounts = append(accounts, account)
+	}
+
+	return
+}
+
+func (p *PostgresContext) operationPoolOrAccAmount(
+	name, amount string,
 	op func(*big.Int, *big.Int) error,
 	getAmount func(string, int64) (string, error),
-	insert func(name, amount string, height int64) string) error {
+	insert func(name, amount string, height int64) string,
+) error {
 	ctx, tx, err := p.GetCtxAndTx()
 	if err != nil {
 		return err
diff --git a/persistence/state.go b/persistence/state.go
index e41667dda..51846feab 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -14,8 +14,12 @@ import (
 
 type MerkleTree float64
 
-// A list of Merkle Trees used to maintain the state hash
+// A list of Merkle Trees used to maintain the state hash.
 const (
+	// VERY IMPORTANT: The order in which these trees are defined is important and strict. It implicitly
+	// defines the index of the the root hash each independent as they are concatenated together
+	// to generate the state hash.
+
 	// Actor Merkle Trees
 	appMerkleTree MerkleTree = iota
 	valMerkleTree
@@ -30,8 +34,9 @@ const (
 	blocksMerkleTree
 	paramsMerkleTree
 	flagsMerkleTree
+	// txMerkleTree ??
 
-	// Used for iteration purposes only - see https://stackoverflow.com/a/64178235/768439
+	// Used for iteration purposes only; see https://stackoverflow.com/a/64178235/768439 as a reference
 	numMerkleTrees
 )
 
@@ -42,13 +47,6 @@ var actorTypeToMerkleTreeName map[types.ActorType]MerkleTree = map[types.ActorTy
 	types.ActorType_Node: serviceNodeMerkleTree,
 }
 
-var merkleTreeToActorTypeName map[MerkleTree]types.ActorType = map[MerkleTree]types.ActorType{
-	appMerkleTree:         types.ActorType_App,
-	valMerkleTree:         types.ActorType_Val,
-	fishMerkleTree:        types.ActorType_Fish,
-	serviceNodeMerkleTree: types.ActorType_Node,
-}
-
 var actorTypeToSchemaName map[types.ActorType]types.ProtocolActorSchema = map[types.ActorType]types.ProtocolActorSchema{
 	types.ActorType_App:  types.ApplicationActor,
 	types.ActorType_Val:  types.ValidatorActor,
@@ -56,6 +54,13 @@ var actorTypeToSchemaName map[types.ActorType]types.ProtocolActorSchema = map[ty
 	types.ActorType_Node: types.ServiceNodeActor,
 }
 
+var merkleTreeToActorTypeName map[MerkleTree]types.ActorType = map[MerkleTree]types.ActorType{
+	appMerkleTree:         types.ActorType_App,
+	valMerkleTree:         types.ActorType_Val,
+	fishMerkleTree:        types.ActorType_Fish,
+	serviceNodeMerkleTree: types.ActorType_Node,
+}
+
 func newMerkleTrees() (map[MerkleTree]*smt.SparseMerkleTree, error) {
 	trees := make(map[MerkleTree]*smt.SparseMerkleTree, int(numMerkleTrees))
 
@@ -77,6 +82,7 @@ func (p *PostgresContext) updateStateHash() error {
 	// Update all the merkle trees
 	for treeType := MerkleTree(0); treeType < numMerkleTrees; treeType++ {
 		switch treeType {
+		// Actor Merkle Trees
 		case appMerkleTree:
 			fallthrough
 		case valMerkleTree:
@@ -88,25 +94,31 @@ func (p *PostgresContext) updateStateHash() error {
 			if !ok {
 				return fmt.Errorf("no actor type found for merkle tree: %v\n", treeType)
 			}
-			actors, err := p.getActorsUpdatedAtHeight(actorType, p.Height)
-			if err != nil {
+			if err := p.updateActorsTree(actorType, p.Height); err != nil {
 				return err
 			}
-			if err != p.updateActorsTree(actorType, actors) {
+
+		// Account Merkle Trees
+		case accountMerkleTree:
+			if err := p.updateAccountTrees(false, p.Height); err != nil {
 				return err
 			}
-		case accountMerkleTree:
-			fallthrough
 		case poolMerkleTree:
-			fallthrough
+			if err := p.updateAccountTrees(true, p.Height); err != nil {
+				return err
+			}
+
+		// Data Merkle Trees
 		case blocksMerkleTree:
-			fallthrough
+			p.updateBlockTree(p.Height)
 		case paramsMerkleTree:
-			fallthrough
+			log.Printf("TODO: merkle tree not implemented yet. Merkle tree #{%v}\n", treeType)
 		case flagsMerkleTree:
-			// log.Println("TODO: merkle tree not implemented", treeType)
+			log.Printf("TODO: merkle tree not implemented yet. Merkle tree #{%v}\n", treeType)
+
+		// Default
 		default:
-			log.Fatalln("Not handled yet in state commitment update", treeType)
+			log.Fatalf("Not handled yet in state commitment update. Merkle tree #{%v}\n", treeType)
 		}
 	}
 
@@ -116,13 +128,6 @@ func (p *PostgresContext) updateStateHash() error {
 		roots = append(roots, p.merkleTrees[treeType].Root())
 	}
 
-	// DISCUSS(drewsky): In #152, we discussed the ordering of the roots
-	// 	Strict Ordering: sha3(app_tree_root + fish_tree_root + service_node_tree_root + validator_tree_root)
-	// 	Value Ordering sha3(app_tree_root <= + fish_tree_root <= + service_node_tree_root <= + validator_tree_root)
-	// If we don't do the lexographic ordering below, then it follows the string ordering of
-	// the merkle trees declared above. I have a feeling you're not a fan of this solution, but curious
-	// to hear your thoughts.
-
 	// Get the state hash
 	rootsConcat := bytes.Join(roots, []byte{})
 	stateHash := sha256.Sum256(rootsConcat)
@@ -131,14 +136,21 @@ func (p *PostgresContext) updateStateHash() error {
 	return nil
 }
 
-func (p PostgresContext) updateActorsTree(actorType types.ActorType, actors []*types.Actor) error {
+// Actor Tree Helpers
+
+func (p *PostgresContext) updateActorsTree(actorType types.ActorType, height int64) error {
+	actors, err := p.getActorsUpdatedAtHeight(actorType, height)
+	if err != nil {
+		return err
+	}
+
 	for _, actor := range actors {
 		bzAddr, err := hex.DecodeString(actor.GetAddress())
 		if err != nil {
 			return err
 		}
 
-		appBz, err := proto.Marshal(actor)
+		actorBz, err := proto.Marshal(actor)
 		if err != nil {
 			return err
 		}
@@ -148,7 +160,7 @@ func (p PostgresContext) updateActorsTree(actorType types.ActorType, actors []*t
 			return fmt.Errorf("no merkle tree found for actor type: %s", actorType)
 		}
 
-		if _, err := p.merkleTrees[merkleTreeName].Update(bzAddr, appBz); err != nil {
+		if _, err := p.merkleTrees[merkleTreeName].Update(bzAddr, actorBz); err != nil {
 			return err
 		}
 	}
@@ -156,7 +168,7 @@ func (p PostgresContext) updateActorsTree(actorType types.ActorType, actors []*t
 	return nil
 }
 
-func (p PostgresContext) getActorsUpdatedAtHeight(actorType types.ActorType, height int64) (actors []*types.Actor, err error) {
+func (p *PostgresContext) getActorsUpdatedAtHeight(actorType types.ActorType, height int64) (actors []*types.Actor, err error) {
 	actorSchema, ok := actorTypeToSchemaName[actorType]
 	if !ok {
 		return nil, fmt.Errorf("no schema found for actor type: %s", actorType)
@@ -184,3 +196,48 @@ func (p PostgresContext) getActorsUpdatedAtHeight(actorType types.ActorType, hei
 	}
 	return
 }
+
+// Account Tree Helpers
+
+// Helper to update both `Pool` and `Account` Merkle Trees. The use of `isPool` is a bit hacky, but
+// but simplifies the code since Pools are just specialized versions of accounts.
+func (p *PostgresContext) updateAccountTrees(isPool bool, height int64) error {
+	var merkleTreeName MerkleTree
+	var accounts []*types.Account
+	var err error
+
+	if isPool {
+		merkleTreeName = poolMerkleTree
+		accounts, err = p.getPoolsUpdated(height)
+	} else {
+		merkleTreeName = accountMerkleTree
+		accounts, err = p.getAccountsUpdated(height)
+	}
+	if err != nil {
+		return err
+	}
+
+	for _, account := range accounts {
+		bzAddr, err := hex.DecodeString(account.GetAddress())
+		if err != nil {
+			return err
+		}
+
+		accBz, err := proto.Marshal(account)
+		if err != nil {
+			return err
+		}
+
+		if _, err := p.merkleTrees[merkleTreeName].Update(bzAddr, accBz); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// Data Tree Helpers
+
+func (p *PostgresContext) updateBlockTree(height int64) {
+
+}
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index f97cacd37..fafa8ad1c 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -3,7 +3,8 @@ package test
 import (
 	"encoding/binary"
 	"encoding/hex"
-	"math/big"
+	"math/rand"
+	"strconv"
 	"testing"
 
 	"github.com/pokt-network/pocket/persistence/indexer"
@@ -13,15 +14,36 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+const (
+	txBytesRandSeed = "42"
+	txBytesSize     = 42
+
+	// This value is arbitrarily selected, but needs to be a constant to guarantee deterministic tests.
+	initialStakeAmount = 42
+)
+
+// Tests/debug to implement:
+// - Add a tool to easily see what's in the tree (visualize, size, etc...)
+// - Benchmark what happens when we add a shit ton of thins into the trie
+// - Fuzz a test that results in the same final state but uses different ways to get there
+// - Think about:
+//       - Thinking about how it can be synched
+//       - Playing back several blocks
+// - Add TODOs for:
+// 		- Atomicity
+//      - Bad tests
+
 func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 	// These hashes were determined manually by running the test, but hardcoded to guarantee
-	// that the business logic doesn't change and that they remain deterministic.
+	// that the business logic doesn't change and that they remain deterministic. Anytime the business
+	// logic changes, these hashes will need to be updated based on the test output.
 	encodedAppHash := []string{
-		"f13ddc447bdebd38b1db7d534915992fa2b6dd4aabdc81868e3420df37b3647f",
-		"40ba19443d9c18d12c17ed25e86ae1aa34ecc1080cc0208854dc72e51f9b8b94",
-		"b7578e3d5a675effe31475ce0df034a2aec21c983b4a3c34c23ad9b583cb60eb",
+		"3078d5c1dc45f3f76f5daef585097c4029e6d5837e2d6bc2bfb8c2c3d3766e4c",
+		"021b96cd367323c1d97832580d47ad3e54bfe79141aa507b7d60e3b0ddd107d6",
+		"70db812fb2b397252fb49b189d405d6e001bc7e2452914ca5c231af1166f2675",
 	}
 
+	stakeAmount := initialStakeAmount
 	for i := 0; i < 3; i++ {
 		// Get the context at the new height and retrieve one of the apps
 		height := int64(i + 1)
@@ -38,20 +60,21 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 		require.NoError(t, err)
 
 		// Update the app's stake
-		newStakeAmount := types.BigIntToString(big.NewInt(height + int64(420000000000)))
-		err = db.SetAppStakeAmount(addrBz, newStakeAmount)
+		stakeAmount += 1 // change the stake amount
+		stakeAmountStr := strconv.Itoa(stakeAmount)
+		err = db.SetAppStakeAmount(addrBz, stakeAmountStr)
 		require.NoError(t, err)
 
-		txBz := []byte("a tx, i am, which set the app stake amount to " + newStakeAmount)
+		txBz := []byte("a tx, i am, which set the app stake amount to " + stakeAmountStr)
 		txResult := indexer.TxRes{
 			Tx:            txBz,
 			Height:        height,
 			Index:         0,
 			ResultCode:    0,
-			Error:         "",
-			SignerAddr:    "",
-			RecipientAddr: "",
-			MessageType:   "",
+			Error:         "TODO",
+			SignerAddr:    "TODO",
+			RecipientAddr: "TODO",
+			MessageType:   "TODO",
 		}
 
 		// txResult := mockTxResult(t, height, txBz)
@@ -63,7 +86,7 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, expectedAppHash, hex.EncodeToString(appHash))
 
-		err = db.Commit([]byte("proposer"), []byte("quorumCert"))
+		err = db.Commit([]byte("TODOproposer"), []byte("TODOquorumCert"))
 		require.NoError(t, err)
 
 		// Verify the block contents
@@ -83,13 +106,12 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 	}
 }
 
-// Tests/debug to implement:
-// - Visibility into what's in the tree
-// - Benchmarking many inserts
-// - Release / revert mid block and making sure everything is reverted
-// - Thinking about how it can be synched
-// - Playing back several blocks
-// - Atomicity - Look into Commit
+func getTxBytes(seed, size int64) []byte {
+	rand.Seed(seed)
+	bz := make([]byte, size)
+	rand.Read(bz)
+	return bz
+}
 
 func heightToBytes(height int64) []byte {
 	heightBytes := make([]byte, 8)
diff --git a/persistence/types/account.go b/persistence/types/account.go
index 5c517a7e8..5174345d2 100644
--- a/persistence/types/account.go
+++ b/persistence/types/account.go
@@ -80,6 +80,14 @@ func SelectPools(height int64, tableName string) string {
        `, tableName, height)
 }
 
+func GetAccountsUpdatedAtHeightQuery(height int64) string {
+	return SelectAtHeight(AllColsSelector, height, AccountTableName)
+}
+
+func GetPoolsUpdatedAtHeightQuery(height int64) string {
+	return SelectAtHeight(AllColsSelector, height, PoolTableName)
+}
+
 func ClearAllAccounts() string {
 	return fmt.Sprintf(`DELETE FROM %s`, AccountTableName)
 }
diff --git a/utility/block.go b/utility/block.go
index 217bc2025..388c1200e 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -1,6 +1,7 @@
 package utility
 
 import (
+	"log"
 	"math/big"
 
 	"github.com/pokt-network/pocket/shared/modules"
@@ -63,10 +64,9 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 		return nil, nil, err
 	}
 
-	// DISCUSS_IN_THIS_COMMIT: What if everything above succeeded but updating the app hash failed?
 	appHash, err = u.Context.UpdateAppHash()
 	if err != nil {
-		// TODO: Rollback the entire block
+		log.Fatalf("Updating the app hash failed. TODO: Look into roll-backing the entire commit...")
 		return nil, nil, typesUtil.ErrAppHash(err)
 	}
 

From 17462687d043e97e58046880275901e314c3d4b3 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sun, 30 Oct 2022 15:46:59 -0700
Subject: [PATCH 105/227] WIP benchmarking

---
 Makefile                                 |  20 +++-
 persistence/kvstore/kvstore.go           |   6 +-
 persistence/state.go                     |   7 +-
 persistence/test/account_test.go         |   4 +-
 persistence/test/benchmark_state_test.go | 111 +++++++++++++++++++++++
 persistence/test/setup_test.go           |  38 +++-----
 persistence/test/state_test.go           |  22 ++---
 utility/block.go                         |   2 +-
 8 files changed, 161 insertions(+), 49 deletions(-)
 create mode 100644 persistence/test/benchmark_state_test.go

diff --git a/Makefile b/Makefile
index d8de390a1..4d5b2580c 100644
--- a/Makefile
+++ b/Makefile
@@ -316,6 +316,11 @@ test_sortition:
 test_persistence:
 	go test ${VERBOSE_TEST} -p 1 -count=1 ./persistence/...
 
+.PHONY: test_persistence_state_hash
+## Run all go unit tests in the Persistence module related to the state hash
+test_persistence_state_hash:
+	go test ${VERBOSE_TEST} -run TestStateHash -count=1 ./persistence/...
+
 .PHONY: test_p2p
 ## Run all p2p
 test_p2p:
@@ -324,22 +329,29 @@ test_p2p:
 .PHONY: test_p2p_raintree
 ## Run all p2p raintree related tests
 test_p2p_raintree:
-	go test -run RainTreeNetwork -v -count=1 ./p2p/...
+	go test ${VERBOSE_TEST} -run RainTreeNetwork -count=1 ./p2p/...
 
 .PHONY: test_p2p_raintree_addrbook
 ## Run all p2p raintree addr book related tests
 test_p2p_raintree_addrbook:
-	go test -run RainTreeAddrBook -v -count=1 ./p2p/...
+	go test ${VERBOSE_TEST} -run RainTreeAddrBook -count=1 ./p2p/...
+
+# For benchmarks, consider appending `-run=^#` to avoid running unit tests in the same package
+
+.PHONY: benchmark_persistence_state_hash
+## Benchmark the State Hash
+benchmark_persistence_state_hash:
+	go test ${VERBOSE_TEST} -bench=. -run BenchmarkStateHash -count=1 ./persistence/...
 
 .PHONY: benchmark_sortition
 ## Benchmark the Sortition library
 benchmark_sortition:
-	go test ${VERBOSE_TEST} ./consensus/leader_election/sortition -bench=.
+	go test ${VERBOSE_TEST} -bench=. -run ^# ./consensus/leader_election/sortition
 
 .PHONY: benchmark_p2p_addrbook
 ## Benchmark all P2P addr book related tests
 benchmark_p2p_addrbook:
-	go test -bench=. -run BenchmarkAddrBook -v -count=1 ./p2p/...
+	go test ${VERBOSE_TEST} -bench=. -run BenchmarkAddrBook -count=1 ./p2p/...
 
 ### Inspired by @goldinguy_ in this post: https://goldin.io/blog/stop-using-todo ###
 # TODO          - General Purpose catch-all.
diff --git a/persistence/kvstore/kvstore.go b/persistence/kvstore/kvstore.go
index 7b1a95440..cdba16f38 100644
--- a/persistence/kvstore/kvstore.go
+++ b/persistence/kvstore/kvstore.go
@@ -89,8 +89,10 @@ func (store *badgerKVStore) Get(key []byte) ([]byte, error) {
 }
 
 func (store *badgerKVStore) Delete(key []byte) error {
-	log.Fatalf("badgerKVStore.Delete not implemented yet")
-	return nil
+	tx := store.db.NewTransaction(true)
+	defer tx.Discard()
+
+	return tx.Delete(key)
 }
 
 func (store *badgerKVStore) GetAll(prefix []byte, descending bool) (values [][]byte, err error) {
diff --git a/persistence/state.go b/persistence/state.go
index 51846feab..69095eba7 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -8,6 +8,7 @@ import (
 	"log"
 
 	"github.com/celestiaorg/smt"
+	"github.com/pokt-network/pocket/persistence/kvstore"
 	"github.com/pokt-network/pocket/persistence/types"
 	"google.golang.org/protobuf/proto"
 )
@@ -66,8 +67,10 @@ func newMerkleTrees() (map[MerkleTree]*smt.SparseMerkleTree, error) {
 
 	for treeType := MerkleTree(0); treeType < numMerkleTrees; treeType++ {
 		// TODO_IN_THIS_COMMIT: Rather than using `NewSimpleMap`, use a disk based key-value store
-		nodeStore := smt.NewSimpleMap()
-		valueStore := smt.NewSimpleMap()
+		// nodeStore := smt.NewSimpleMap()
+		// valueStore := smt.NewSimpleMap()
+		nodeStore := kvstore.NewMemKVStore()
+		valueStore := kvstore.NewMemKVStore()
 
 		trees[treeType] = smt.NewSparseMerkleTree(nodeStore, valueStore, sha256.New())
 	}
diff --git a/persistence/test/account_test.go b/persistence/test/account_test.go
index a0ee0bd34..6ac11cdad 100644
--- a/persistence/test/account_test.go
+++ b/persistence/test/account_test.go
@@ -19,7 +19,7 @@ import (
 // TODO(andrew): Find all places where we import twice and update the imports appropriately.
 
 func FuzzAccountAmount(f *testing.F) {
-	db := NewFuzzTestPostgresContext(f, 0)
+	db := NewTestPostgresContext(f, 0)
 	operations := []string{
 		"AddAmount",
 		"SubAmount",
@@ -164,7 +164,7 @@ func TestSubAccountAmount(t *testing.T) {
 }
 
 func FuzzPoolAmount(f *testing.F) {
-	db := NewFuzzTestPostgresContext(f, 0)
+	db := NewTestPostgresContext(f, 0)
 	operations := []string{
 		"AddAmount",
 		"SubAmount",
diff --git a/persistence/test/benchmark_state_test.go b/persistence/test/benchmark_state_test.go
new file mode 100644
index 000000000..da95f758e
--- /dev/null
+++ b/persistence/test/benchmark_state_test.go
@@ -0,0 +1,111 @@
+package test
+
+import (
+	"fmt"
+	"log"
+	"math/rand"
+	"testing"
+
+	"github.com/pokt-network/pocket/persistence/indexer"
+	"github.com/pokt-network/pocket/shared/debug"
+)
+
+func BenchmarkStateHash(b *testing.B) {
+	b.StopTimer()
+
+	b.Cleanup(func() {
+		if err := testPersistenceMod.ReleaseWriteContext(); err != nil {
+			log.Fatalf("Error releasing write context: %v\n", err)
+		}
+		if err := testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
+			Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
+			Message: nil,
+		}); err != nil {
+			log.Fatalf("Error clearing state: %v\n", err)
+		}
+	})
+
+	// number of heights
+	// number of txs per height
+	// number of ops per height
+
+	testCases := []struct {
+		numHeights     int
+		numTxPerHeight int
+	}{
+		{1, 1},
+		{100, 1},
+		{100, 10},
+		{1000, 1},
+		{1000, 10},
+		{10000, 10},
+		{10000, 1000},
+	}
+
+	for _, testCase := range testCases {
+		numHeights := testCase.numHeights
+		numTxPerHeight := testCase.numTxPerHeight
+		b.Run(fmt.Sprintf("heights=%d;txPerHeight=%d", numHeights, numTxPerHeight), func(b *testing.B) {
+			for h := 0; h < numHeights; h++ {
+				// addrBook := getAddrBook(nil, n-1)
+				// addrBook = append(addrBook, &types.NetworkPeer{Address: addr})
+				// network := NewRainTreeNetwork(addr, addrBook).(*rainTreeNetwork)
+
+				// peersManagerStateView := network.peersManager.getNetworkView()
+
+				// require.Equal(b, n, len(peersManagerStateView.addrList))
+				// require.Equal(b, n, len(peersManagerStateView.addrBookMap))
+				// require.Equal(b, testCase.numExpectedLevels, int(peersManagerStateView.maxNumLevels))
+
+				// for i := 0; i < numAddressessToBeAdded; i++ {
+				// 	newAddr, err := crypto.GenerateAddress()
+				// 	require.NoError(b, err)
+				// 	network.AddPeerToAddrBook(&types.NetworkPeer{Address: newAddr})
+				// }
+
+				// peersManagerStateView = network.peersManager.getNetworkView()
+
+				// require.Equal(b, n+numAddressessToBeAdded, len(peersManagerStateView.addrList))
+				// require.Equal(b, n+numAddressessToBeAdded, len(peersManagerStateView.addrBookMap))
+
+				// db := NewTestPostgresContext(b, height)
+
+				// err = db.StoreTransaction(modules.TxResult(getRandomTxResult(height)))
+				// require.NoError(t, err)
+
+				// // db.
+
+				// // Update the state hash
+				// appHash, err := db.UpdateAppHash()
+				// require.NoError(t, err)
+				// require.Equal(t, expectedAppHash, hex.EncodeToString(appHash))
+
+				// // Commit the transactions above
+				// err = db.Commit([]byte("TODOproposer"), []byte("TODOquorumCert"))
+				// require.NoError(t, err)
+			}
+		})
+	}
+}
+
+func getRandomTxResult(height int64) *indexer.TxRes {
+	return &indexer.TxRes{
+		Tx:            getTxBytes(50),
+		Height:        height,
+		Index:         0,
+		ResultCode:    0,
+		Error:         "TODO",
+		SignerAddr:    "TODO",
+		RecipientAddr: "TODO",
+		MessageType:   "TODO",
+	}
+}
+
+func getTxBytes(numBytes int64) []byte {
+	bz := make([]byte, numBytes)
+	rand.Read(bz)
+	return bz
+}
+
+// Random transactions
+// Update state hash
diff --git a/persistence/test/setup_test.go b/persistence/test/setup_test.go
index 15e5627aa..4dcc58b88 100644
--- a/persistence/test/setup_test.go
+++ b/persistence/test/setup_test.go
@@ -59,26 +59,7 @@ func TestMain(m *testing.M) {
 }
 
 // IMPROVE(olshansky): Look into returning `testPersistenceMod` to avoid exposing underlying abstraction.
-func NewTestPostgresContext(t *testing.T, height int64) *persistence.PostgresContext {
-	ctx, err := testPersistenceMod.NewRWContext(height)
-	require.NoError(t, err)
-
-	db, ok := ctx.(*persistence.PostgresContext)
-	require.True(t, ok)
-
-	t.Cleanup(func() {
-		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
-		require.NoError(t, testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
-			Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_RESET_TO_GENESIS,
-			Message: nil,
-		}))
-	})
-
-	return db
-}
-
-// IMPROVE(olshansky): Look into returning `testPersistenceMod` to avoid exposing underlying abstraction.
-func NewFuzzTestPostgresContext(f *testing.F, height int64) *persistence.PostgresContext {
+func NewTestPostgresContext[T testing.T | testing.B | testing.F](t *T, height int64) *persistence.PostgresContext {
 	ctx, err := testPersistenceMod.NewRWContext(height)
 	if err != nil {
 		log.Fatalf("Error creating new context: %v\n", err)
@@ -89,7 +70,19 @@ func NewFuzzTestPostgresContext(f *testing.F, height int64) *persistence.Postgre
 		log.Fatalf("Error casting RW context to Postgres context")
 	}
 
-	f.Cleanup(func() {
+	var cleanupFn func(func())
+	switch any(t).(type) {
+	case *testing.T:
+		cleanupFn = any(t).(*testing.T).Cleanup
+	case *testing.B:
+		cleanupFn = any(t).(*testing.B).Cleanup
+	case *testing.F:
+		cleanupFn = any(t).(*testing.F).Cleanup
+	default:
+		log.Fatalf("Error: unsupported type %T", t)
+	}
+
+	cleanupFn(func() {
 		if err := testPersistenceMod.ReleaseWriteContext(); err != nil {
 			log.Fatalf("Error releasing write context: %v\n", err)
 		}
@@ -99,7 +92,6 @@ func NewFuzzTestPostgresContext(f *testing.F, height int64) *persistence.Postgre
 		}); err != nil {
 			log.Fatalf("Error clearing state: %v\n", err)
 		}
-
 	})
 
 	return db
@@ -133,7 +125,7 @@ func fuzzSingleProtocolActor(
 	getTestActor func(db *persistence.PostgresContext, address string) (*types.Actor, error),
 	protocolActorSchema types.ProtocolActorSchema) {
 
-	db := NewFuzzTestPostgresContext(f, 0)
+	db := NewTestPostgresContext(f, 0)
 
 	actor, err := newTestActor()
 	require.NoError(f, err)
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index fafa8ad1c..9562a9e17 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -3,7 +3,6 @@ package test
 import (
 	"encoding/binary"
 	"encoding/hex"
-	"math/rand"
 	"strconv"
 	"testing"
 
@@ -77,42 +76,35 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 			MessageType:   "TODO",
 		}
 
-		// txResult := mockTxResult(t, height, txBz)
 		err = db.StoreTransaction(modules.TxResult(&txResult))
 		require.NoError(t, err)
 
-		// Update & commit the state hash
+		// Update the state hash
 		appHash, err := db.UpdateAppHash()
 		require.NoError(t, err)
 		require.Equal(t, expectedAppHash, hex.EncodeToString(appHash))
 
+		// Commit the transactions above
 		err = db.Commit([]byte("TODOproposer"), []byte("TODOquorumCert"))
 		require.NoError(t, err)
 
-		// Verify the block contents
+		// Retrieve the block
 		blockBz, err := testPersistenceMod.GetBlockStore().Get(heightBz)
 		require.NoError(t, err)
 
+		// Verify the block contents
 		var block types.Block
 		err = codec.GetCodec().Unmarshal(blockBz, &block)
 		require.NoError(t, err)
 		require.Len(t, block.Transactions, 1)
-		// require.Equal(t, txResult.GetTx(), block.Transactions[0])
-		require.Equal(t, expectedAppHash, block.Hash) // block
+		require.Equal(t, txResult.GetTx(), block.Transactions[0])
+		require.Equal(t, expectedAppHash, block.Hash) // verify block hash
 		if i > 0 {
-			require.Equal(t, encodedAppHash[i-1], block.PrevHash) // chain
+			require.Equal(t, encodedAppHash[i-1], block.PrevHash) // verify chain chain
 		}
-
 	}
 }
 
-func getTxBytes(seed, size int64) []byte {
-	rand.Seed(seed)
-	bz := make([]byte, size)
-	rand.Read(bz)
-	return bz
-}
-
 func heightToBytes(height int64) []byte {
 	heightBytes := make([]byte, 8)
 	binary.LittleEndian.PutUint64(heightBytes, uint64(height))
diff --git a/utility/block.go b/utility/block.go
index 388c1200e..ee31475d1 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -66,7 +66,7 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 
 	appHash, err = u.Context.UpdateAppHash()
 	if err != nil {
-		log.Fatalf("Updating the app hash failed. TODO: Look into roll-backing the entire commit...")
+		log.Fatalf("Updating the app hash failed. TODO: Look into roll-backing the entire commit...", err)
 		return nil, nil, typesUtil.ErrAppHash(err)
 	}
 

From 91c2e683d720c959c446da59dff990a72b05576b Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 31 Oct 2022 13:32:24 -0700
Subject: [PATCH 106/227] Interim work on benchmarking

---
 persistence/kvstore/kvstore.go           | 11 ++-
 persistence/test/benchmark_state_test.go | 99 +++++++++++++-----------
 utility/block.go                         |  2 +-
 3 files changed, 62 insertions(+), 50 deletions(-)

diff --git a/persistence/kvstore/kvstore.go b/persistence/kvstore/kvstore.go
index cdba16f38..385270331 100644
--- a/persistence/kvstore/kvstore.go
+++ b/persistence/kvstore/kvstore.go
@@ -40,7 +40,7 @@ type badgerKVStore struct {
 }
 
 func NewKVStore(path string) (KVStore, error) {
-	db, err := badger.Open(badger.DefaultOptions(path))
+	db, err := badger.Open(badgerOptions(path))
 	if err != nil {
 		return nil, err
 	}
@@ -48,7 +48,7 @@ func NewKVStore(path string) (KVStore, error) {
 }
 
 func NewMemKVStore() KVStore {
-	db, err := badger.Open(badger.DefaultOptions("").WithInMemory(true))
+	db, err := badger.Open(badgerOptions("").WithInMemory(true))
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -156,3 +156,10 @@ func prefixEndBytes(prefix []byte) []byte {
 	end[len(end)-1]++
 	return end
 }
+
+// TODO: Propagate persistence configurations to badger
+func badgerOptions(path string) badger.Options {
+	opts := badger.DefaultOptions(path)
+	opts.Logger = nil // disable badger's logger since it's very noisy
+	return opts
+}
diff --git a/persistence/test/benchmark_state_test.go b/persistence/test/benchmark_state_test.go
index da95f758e..6472d727f 100644
--- a/persistence/test/benchmark_state_test.go
+++ b/persistence/test/benchmark_state_test.go
@@ -2,16 +2,22 @@ package test
 
 import (
 	"fmt"
+	"io/ioutil"
 	"log"
 	"math/rand"
+	"os"
+	"reflect"
 	"testing"
 
+	"github.com/pokt-network/pocket/persistence"
 	"github.com/pokt-network/pocket/persistence/indexer"
 	"github.com/pokt-network/pocket/shared/debug"
+	"github.com/pokt-network/pocket/shared/modules"
 )
 
 func BenchmarkStateHash(b *testing.B) {
-	b.StopTimer()
+	log.SetOutput(ioutil.Discard)
+	defer log.SetOutput(os.Stderr)
 
 	b.Cleanup(func() {
 		if err := testPersistenceMod.ReleaseWriteContext(); err != nil {
@@ -25,13 +31,10 @@ func BenchmarkStateHash(b *testing.B) {
 		}
 	})
 
-	// number of heights
-	// number of txs per height
-	// number of ops per height
-
+	// Rather than using `b.N` and the `-benchtime` flag, we use a fixed number of iterations
 	testCases := []struct {
-		numHeights     int
-		numTxPerHeight int
+		numHeights     int64
+		numTxPerHeight int64
 	}{
 		{1, 1},
 		{100, 1},
@@ -46,48 +49,53 @@ func BenchmarkStateHash(b *testing.B) {
 		numHeights := testCase.numHeights
 		numTxPerHeight := testCase.numTxPerHeight
 		b.Run(fmt.Sprintf("heights=%d;txPerHeight=%d", numHeights, numTxPerHeight), func(b *testing.B) {
-			for h := 0; h < numHeights; h++ {
-				// addrBook := getAddrBook(nil, n-1)
-				// addrBook = append(addrBook, &types.NetworkPeer{Address: addr})
-				// network := NewRainTreeNetwork(addr, addrBook).(*rainTreeNetwork)
-
-				// peersManagerStateView := network.peersManager.getNetworkView()
-
-				// require.Equal(b, n, len(peersManagerStateView.addrList))
-				// require.Equal(b, n, len(peersManagerStateView.addrBookMap))
-				// require.Equal(b, testCase.numExpectedLevels, int(peersManagerStateView.maxNumLevels))
-
-				// for i := 0; i < numAddressessToBeAdded; i++ {
-				// 	newAddr, err := crypto.GenerateAddress()
-				// 	require.NoError(b, err)
-				// 	network.AddPeerToAddrBook(&types.NetworkPeer{Address: newAddr})
-				// }
-
-				// peersManagerStateView = network.peersManager.getNetworkView()
-
-				// require.Equal(b, n+numAddressessToBeAdded, len(peersManagerStateView.addrList))
-				// require.Equal(b, n+numAddressessToBeAdded, len(peersManagerStateView.addrBookMap))
-
-				// db := NewTestPostgresContext(b, height)
-
-				// err = db.StoreTransaction(modules.TxResult(getRandomTxResult(height)))
-				// require.NoError(t, err)
-
-				// // db.
-
-				// // Update the state hash
-				// appHash, err := db.UpdateAppHash()
-				// require.NoError(t, err)
-				// require.Equal(t, expectedAppHash, hex.EncodeToString(appHash))
-
-				// // Commit the transactions above
-				// err = db.Commit([]byte("TODOproposer"), []byte("TODOquorumCert"))
-				// require.NoError(t, err)
+			for h := int64(0); h < numHeights; h++ {
+				db := NewTestPostgresContext(b, h)
+				helper(db)
+				for i := int64(0); i < numTxPerHeight; i++ {
+					// TODO: Perform a random operation
+					db.StoreTransaction(modules.TxResult(getRandomTxResult(h)))
+				}
+				db.UpdateAppHash()
+				db.Commit([]byte("TODOproposer"), []byte("TODOquorumCert"))
 			}
 		})
 	}
 }
 
+func helper(p *persistence.PostgresContext) {
+	v := reflect.ValueOf(p)
+	// t := reflect.TypeOf(p)
+	for m := 0; m < v.NumMethod(); m++ {
+		var callArgs []reflect.Value
+		method := v.Method(m).Type()
+		// methodName := t.Method(m).Name
+		for i := 0; i < method.NumIn(); i++ {
+			arg := method.In(i)
+			switch arg.Kind() {
+			case reflect.String:
+				v = reflect.ValueOf("123")
+			case reflect.Slice:
+				v = reflect.ValueOf([]byte("abc"))
+			case reflect.Bool:
+				v = reflect.ValueOf(false)
+			case reflect.Uint8:
+				fallthrough
+			case reflect.Int32:
+				fallthrough
+			case reflect.Int64:
+				fallthrough
+			case reflect.Int:
+				v = reflect.ValueOf(0)
+			default:
+				log.Println("OLSH, not supported", arg.Kind())
+			}
+			callArgs = append(callArgs, v)
+		}
+		// fmt.Println(methodName, callArgs)
+	}
+}
+
 func getRandomTxResult(height int64) *indexer.TxRes {
 	return &indexer.TxRes{
 		Tx:            getTxBytes(50),
@@ -106,6 +114,3 @@ func getTxBytes(numBytes int64) []byte {
 	rand.Read(bz)
 	return bz
 }
-
-// Random transactions
-// Update state hash
diff --git a/utility/block.go b/utility/block.go
index ee31475d1..28a9dfa34 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -66,7 +66,7 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 
 	appHash, err = u.Context.UpdateAppHash()
 	if err != nil {
-		log.Fatalf("Updating the app hash failed. TODO: Look into roll-backing the entire commit...", err)
+		log.Fatalf("Updating the app hash failed: %v.\n\tTODO: Look into roll-backing the entire commit...\n", err)
 		return nil, nil, typesUtil.ErrAppHash(err)
 	}
 

From 158e2b774c249b3f9e8cb9c27fd2fc190467ce52 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 31 Oct 2022 14:16:51 -0700
Subject: [PATCH 107/227] Tests pass

---
 persistence/account.go         |  2 +-
 persistence/state.go           | 43 ++++++++++++++++++++--------------
 persistence/test/setup_test.go | 13 ++++++++--
 utility/block.go               |  2 +-
 4 files changed, 39 insertions(+), 21 deletions(-)

diff --git a/persistence/account.go b/persistence/account.go
index eb6b8de0b..a5fce94b4 100644
--- a/persistence/account.go
+++ b/persistence/account.go
@@ -167,7 +167,7 @@ func (p *PostgresContext) getPoolOrAccUpdatedInternal(query string) (accounts []
 	for rows.Next() {
 		account := new(types.Account)
 		var height int64
-		if err = rows.Scan(&account.Address, &account.Amount, height); err != nil {
+		if err = rows.Scan(&account.Address, &account.Amount, &height); err != nil {
 			return nil, err
 		}
 		accounts = append(accounts, account)
diff --git a/persistence/state.go b/persistence/state.go
index 69095eba7..70e35a72f 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -103,11 +103,11 @@ func (p *PostgresContext) updateStateHash() error {
 
 		// Account Merkle Trees
 		case accountMerkleTree:
-			if err := p.updateAccountTrees(false, p.Height); err != nil {
+			if err := p.updateAccountTrees(p.Height); err != nil {
 				return err
 			}
 		case poolMerkleTree:
-			if err := p.updateAccountTrees(true, p.Height); err != nil {
+			if err := p.updatePoolTrees(p.Height); err != nil {
 				return err
 			}
 
@@ -202,20 +202,8 @@ func (p *PostgresContext) getActorsUpdatedAtHeight(actorType types.ActorType, he
 
 // Account Tree Helpers
 
-// Helper to update both `Pool` and `Account` Merkle Trees. The use of `isPool` is a bit hacky, but
-// but simplifies the code since Pools are just specialized versions of accounts.
-func (p *PostgresContext) updateAccountTrees(isPool bool, height int64) error {
-	var merkleTreeName MerkleTree
-	var accounts []*types.Account
-	var err error
-
-	if isPool {
-		merkleTreeName = poolMerkleTree
-		accounts, err = p.getPoolsUpdated(height)
-	} else {
-		merkleTreeName = accountMerkleTree
-		accounts, err = p.getAccountsUpdated(height)
-	}
+func (p *PostgresContext) updateAccountTrees(height int64) error {
+	accounts, err := p.getAccountsUpdated(height)
 	if err != nil {
 		return err
 	}
@@ -231,7 +219,28 @@ func (p *PostgresContext) updateAccountTrees(isPool bool, height int64) error {
 			return err
 		}
 
-		if _, err := p.merkleTrees[merkleTreeName].Update(bzAddr, accBz); err != nil {
+		if _, err := p.merkleTrees[accountMerkleTree].Update(bzAddr, accBz); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (p *PostgresContext) updatePoolTrees(height int64) error {
+	pools, err := p.getPoolsUpdated(height)
+	if err != nil {
+		return err
+	}
+
+	for _, pool := range pools {
+		bzAddr := []byte(pool.GetAddress())
+		accBz, err := proto.Marshal(pool)
+		if err != nil {
+			return err
+		}
+
+		if _, err := p.merkleTrees[poolMerkleTree].Update(bzAddr, accBz); err != nil {
 			return err
 		}
 	}
diff --git a/persistence/test/setup_test.go b/persistence/test/setup_test.go
index 4dcc58b88..da4aa98b8 100644
--- a/persistence/test/setup_test.go
+++ b/persistence/test/setup_test.go
@@ -87,7 +87,8 @@ func NewTestPostgresContext[T testing.T | testing.B | testing.F](t *T, height in
 			log.Fatalf("Error releasing write context: %v\n", err)
 		}
 		if err := testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
-			Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
+			// Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
+			Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_RESET_TO_GENESIS,
 			Message: nil,
 		}); err != nil {
 			log.Fatalf("Error clearing state: %v\n", err)
@@ -123,7 +124,15 @@ func fuzzSingleProtocolActor(
 	f *testing.F,
 	newTestActor func() (*types.Actor, error),
 	getTestActor func(db *persistence.PostgresContext, address string) (*types.Actor, error),
-	protocolActorSchema types.ProtocolActorSchema) {
+	protocolActorSchema types.ProtocolActorSchema,
+) {
+	// Clear the genesis state.
+	if err := testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
+		Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
+		Message: nil,
+	}); err != nil {
+		log.Fatalf("Error clearing state: %v\n", err)
+	}
 
 	db := NewTestPostgresContext(f, 0)
 
diff --git a/utility/block.go b/utility/block.go
index 28a9dfa34..4fd954423 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -66,7 +66,7 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 
 	appHash, err = u.Context.UpdateAppHash()
 	if err != nil {
-		log.Fatalf("Updating the app hash failed: %v.\n\tTODO: Look into roll-backing the entire commit...\n", err)
+		log.Fatalf("Updating the app hash failed: %v. TODO: Look into roll-backing the entire commit...\n", err)
 		return nil, nil, typesUtil.ErrAppHash(err)
 	}
 

From 26eed85cd93997fdc9526fb8a42a5813383fd4dd Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 31 Oct 2022 15:59:24 -0700
Subject: [PATCH 108/227] Add configs & all tests pass

---
 build/config/config1.json                  |  6 +-
 build/config/config2.json                  |  6 +-
 build/config/config3.json                  |  6 +-
 build/config/config4.json                  |  6 +-
 persistence/context.go                     |  3 +-
 persistence/db.go                          | 10 +--
 persistence/docs/README.md                 |  4 +-
 persistence/module.go                      | 34 +++++----
 persistence/proto/block_persistence.proto  |  2 +-
 persistence/proto/persistence_config.proto |  1 +
 persistence/state.go                       | 81 ++++++++++++++++------
 shared/modules/types.go                    |  1 +
 utility/block.go                           |  6 +-
 utility/context.go                         |  4 +-
 utility/test/module_test.go                |  1 +
 15 files changed, 111 insertions(+), 60 deletions(-)

diff --git a/build/config/config1.json b/build/config/config1.json
index 6e56a0bca..bd85884da 100755
--- a/build/config/config1.json
+++ b/build/config/config1.json
@@ -19,7 +19,9 @@
   "persistence": {
     "postgres_url": "postgres://postgres:postgres@pocket-db:5432/postgres",
     "node_schema": "node1",
-    "block_store_path": "/var/blockstore"
+    "block_store_path": "/var/blockstore",
+    "tx_indexer_path": "",
+    "trees_store_dir": "/var/trees"
   },
   "p2p": {
     "consensus_port": 8080,
@@ -32,4 +34,4 @@
     "address": "0.0.0.0:9000",
     "endpoint": "/metrics"
   }
-}
\ No newline at end of file
+}
diff --git a/build/config/config2.json b/build/config/config2.json
index c3a887637..952938c6d 100755
--- a/build/config/config2.json
+++ b/build/config/config2.json
@@ -19,7 +19,9 @@
   "persistence": {
     "postgres_url": "postgres://postgres:postgres@pocket-db:5432/postgres",
     "node_schema": "node2",
-    "block_store_path": "/var/blockstore"
+    "block_store_path": "/var/blockstore",
+    "tx_indexer_path": "",
+    "trees_store_dir": "/var/trees"
   },
   "p2p": {
     "consensus_port": 8080,
@@ -32,4 +34,4 @@
     "address": "0.0.0.0:9000",
     "endpoint": "/metrics"
   }
-}
\ No newline at end of file
+}
diff --git a/build/config/config3.json b/build/config/config3.json
index cac37220c..29f2ea6b5 100755
--- a/build/config/config3.json
+++ b/build/config/config3.json
@@ -19,7 +19,9 @@
   "persistence": {
     "postgres_url": "postgres://postgres:postgres@pocket-db:5432/postgres",
     "node_schema": "node3",
-    "block_store_path": "/var/blockstore"
+    "block_store_path": "/var/blockstore",
+    "tx_indexer_path": "",
+    "trees_store_dir": "/var/trees"
   },
   "p2p": {
     "consensus_port": 8080,
@@ -32,4 +34,4 @@
     "address": "0.0.0.0:9000",
     "endpoint": "/metrics"
   }
-}
\ No newline at end of file
+}
diff --git a/build/config/config4.json b/build/config/config4.json
index e30a8f80c..77462794d 100755
--- a/build/config/config4.json
+++ b/build/config/config4.json
@@ -19,7 +19,9 @@
   "persistence": {
     "postgres_url": "postgres://postgres:postgres@pocket-db:5432/postgres",
     "node_schema": "node4",
-    "block_store_path": "/var/blockstore"
+    "block_store_path": "/var/blockstore",
+    "tx_indexer_path": "",
+    "trees_store_dir": "/var/trees"
   },
   "p2p": {
     "consensus_port": 8080,
@@ -32,4 +34,4 @@
     "address": "0.0.0.0:9000",
     "endpoint": "/metrics"
   }
-}
\ No newline at end of file
+}
diff --git a/persistence/context.go b/persistence/context.go
index e582f7c55..6d5063b3f 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -24,7 +24,8 @@ func (p *PostgresContext) UpdateAppHash() ([]byte, error) {
 	return p.currentStateHash, nil
 }
 
-// TODO_IN_THIS_COMMIT: Make sure that `prepareBlock`, `insertBlock`, and `storeBlock` are all atomic.
+// TODO(#327): When implementing save points and rollbacks, make sure that `prepareBlock`,
+// `insertBlock`, and `storeBlock` are all atomic.
 func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
diff --git a/persistence/db.go b/persistence/db.go
index b6f9a379d..57b4d3233 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -5,7 +5,6 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/celestiaorg/smt"
 	"github.com/jackc/pgconn"
 	"github.com/jackc/pgx/v4"
 	"github.com/pokt-network/pocket/persistence/indexer"
@@ -50,12 +49,13 @@ type PostgresContext struct {
 	conn   *pgx.Conn
 	tx     pgx.Tx
 
-	txIndexer        indexer.TxIndexer
+	// TODO(#315): Should be
 	currentStateHash []byte
 
-	// REFACTOR: Access `blockStore` and `merkleTree` from the persistence module via bus.
-	blockStore  kvstore.KVStore
-	merkleTrees map[MerkleTree]*smt.SparseMerkleTree
+	// REFACTOR_IN_THIS_COMMIT: Access `blockStore` and `merkleTree` from the persistence module via bus.
+	blockStore kvstore.KVStore
+	txIndexer  indexer.TxIndexer
+	stateTrees *stateTrees
 }
 
 func (pg *PostgresContext) GetCtxAndTx() (context.Context, pgx.Tx, error) {
diff --git a/persistence/docs/README.md b/persistence/docs/README.md
index f87efd229..06ba8707a 100644
--- a/persistence/docs/README.md
+++ b/persistence/docs/README.md
@@ -30,7 +30,9 @@ The persistence specific configuration within a node's `config.json` looks like
   "persistence": {
     "postgres_url": "postgres://postgres:postgres@pocket-db:5432/postgres",
     "schema": "node1",
-    "block_store_path": "/var/blockstore"
+    "block_store_path": "/var/blockstore",
+    "tx_indexer_path": "",
+    "trees_store_dir": "/var/trees"
   }
 ```
 
diff --git a/persistence/module.go b/persistence/module.go
index a590c27e8..77b6b1fc2 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/celestiaorg/smt"
 	"github.com/jackc/pgx/v4"
 	"github.com/pokt-network/pocket/persistence/indexer"
 	"github.com/pokt-network/pocket/persistence/kvstore"
@@ -31,12 +30,10 @@ type persistenceModule struct {
 
 	blockStore kvstore.KVStore
 	txIndexer  indexer.TxIndexer
+	stateTrees *stateTrees
 
 	// TECHDEBT: Need to implement context pooling (for writes), timeouts (for read & writes), etc...
 	writeContext *PostgresContext // only one write context is allowed at a time
-
-	// Merkle trees
-	trees map[MerkleTree]*smt.SparseMerkleTree
 }
 
 const (
@@ -72,6 +69,7 @@ func (*persistenceModule) Create(runtimeMgr modules.RuntimeMgr) (modules.Module,
 	}
 	conn.Close(context.TODO())
 
+	// TODO: Follow the same pattern as txIndexer below for initializing the blockStore
 	blockStore, err := initializeBlockStore(persistenceCfg.GetBlockStorePath())
 	if err != nil {
 		return nil, err
@@ -82,22 +80,22 @@ func (*persistenceModule) Create(runtimeMgr modules.RuntimeMgr) (modules.Module,
 		return nil, err
 	}
 
+	stateTrees, err := newStateTrees(persistenceCfg.GetTreesStoreDir())
+	if err != nil {
+		return nil, err
+	}
+
 	m = &persistenceModule{
 		bus:          nil,
 		config:       persistenceCfg,
 		genesisState: persistenceGenesis,
-		blockStore:   blockStore,
-		txIndexer:    txIndexer,
-		writeContext: nil,
-		trees:        make(map[MerkleTree]*smt.SparseMerkleTree),
-	}
 
-	// TODO_IN_THIS_COMMIT: load trees from state
-	trees, err := newMerkleTrees()
-	if err != nil {
-		return nil, err
+		blockStore: blockStore,
+		txIndexer:  txIndexer,
+		stateTrees: stateTrees,
+
+		writeContext: nil,
 	}
-	m.trees = trees
 
 	// Determine if we should hydrate the genesis db or use the current state of the DB attached
 	if shouldHydrateGenesis, err := m.shouldHydrateGenesisDb(); err != nil {
@@ -169,13 +167,13 @@ func (m *persistenceModule) NewRWContext(height int64) (modules.PersistenceRWCon
 		conn:   conn,
 		tx:     tx,
 
-		// TODO_IN_THIS_COMMIT: Does this tate need to be maintained?
+		// TODO(#315): Shouldn't be necessary anymore
 		currentStateHash: make([]byte, 0),
 
 		// TODO_IN_THIS_COMMIT: Can we access these via the bus?
-		blockStore:  m.blockStore,
-		merkleTrees: m.trees,
-		txIndexer:   m.txIndexer,
+		blockStore: m.blockStore,
+		txIndexer:  m.txIndexer,
+		stateTrees: m.stateTrees,
 	}
 
 	return m.writeContext, nil
diff --git a/persistence/proto/block_persistence.proto b/persistence/proto/block_persistence.proto
index 887a9212c..3fabb3170 100644
--- a/persistence/proto/block_persistence.proto
+++ b/persistence/proto/block_persistence.proto
@@ -9,5 +9,5 @@ message Block {
     string prevHash = 3;
     bytes proposerAddress = 4;
     bytes quorumCertificate = 5;
-    repeated bytes transactions = 6; // DISCUSS_IN_THIS_COMMIT(drewskey): Just one hash here?
+    repeated bytes transactions = 6; // DISCUSS_IN_THIS_COMMIT: If we can save all the transactions here, why do we need a separate tx trie?
 }
\ No newline at end of file
diff --git a/persistence/proto/persistence_config.proto b/persistence/proto/persistence_config.proto
index 6215bb14c..ffe70c3b3 100644
--- a/persistence/proto/persistence_config.proto
+++ b/persistence/proto/persistence_config.proto
@@ -8,4 +8,5 @@ message PersistenceConfig {
   string node_schema = 2;
   string block_store_path = 3;
   string tx_indexer_path = 4;
+  string trees_store_dir = 5;
 }
\ No newline at end of file
diff --git a/persistence/state.go b/persistence/state.go
index 70e35a72f..2ed979539 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -13,7 +13,11 @@ import (
 	"google.golang.org/protobuf/proto"
 )
 
-type MerkleTree float64
+type merkleTree float64
+
+type stateTrees struct {
+	merkleTrees map[merkleTree]*smt.SparseMerkleTree
+}
 
 // A list of Merkle Trees used to maintain the state hash.
 const (
@@ -22,7 +26,7 @@ const (
 	// to generate the state hash.
 
 	// Actor Merkle Trees
-	appMerkleTree MerkleTree = iota
+	appMerkleTree merkleTree = iota
 	valMerkleTree
 	fishMerkleTree
 	serviceNodeMerkleTree
@@ -41,7 +45,21 @@ const (
 	numMerkleTrees
 )
 
-var actorTypeToMerkleTreeName map[types.ActorType]MerkleTree = map[types.ActorType]MerkleTree{
+var merkleTreeToString = map[merkleTree]string{
+	appMerkleTree:         "app",
+	valMerkleTree:         "val",
+	fishMerkleTree:        "fish",
+	serviceNodeMerkleTree: "serviceNode",
+
+	accountMerkleTree: "account",
+	poolMerkleTree:    "pool",
+
+	blocksMerkleTree: "blocks",
+	paramsMerkleTree: "params",
+	flagsMerkleTree:  "flags",
+}
+
+var actorTypeToMerkleTreeName map[types.ActorType]merkleTree = map[types.ActorType]merkleTree{
 	types.ActorType_App:  appMerkleTree,
 	types.ActorType_Val:  valMerkleTree,
 	types.ActorType_Fish: fishMerkleTree,
@@ -55,35 +73,56 @@ var actorTypeToSchemaName map[types.ActorType]types.ProtocolActorSchema = map[ty
 	types.ActorType_Node: types.ServiceNodeActor,
 }
 
-var merkleTreeToActorTypeName map[MerkleTree]types.ActorType = map[MerkleTree]types.ActorType{
+var merkleTreeToActorTypeName map[merkleTree]types.ActorType = map[merkleTree]types.ActorType{
 	appMerkleTree:         types.ActorType_App,
 	valMerkleTree:         types.ActorType_Val,
 	fishMerkleTree:        types.ActorType_Fish,
 	serviceNodeMerkleTree: types.ActorType_Node,
 }
 
-func newMerkleTrees() (map[MerkleTree]*smt.SparseMerkleTree, error) {
-	trees := make(map[MerkleTree]*smt.SparseMerkleTree, int(numMerkleTrees))
+func newStateTrees(treesStoreDir string) (*stateTrees, error) {
+	if treesStoreDir == "" {
+		return newMemStateTrees()
+	}
+
+	stateTrees := &stateTrees{
+		merkleTrees: make(map[merkleTree]*smt.SparseMerkleTree, int(numMerkleTrees)),
+	}
+
+	for tree := merkleTree(0); tree < numMerkleTrees; tree++ {
+		nodeStore, err := kvstore.NewKVStore(fmt.Sprintf("%s/%s_nodes", treesStoreDir, merkleTreeToString[tree]))
+		if err != nil {
+			return nil, err
+		}
+		valueStore, err := kvstore.NewKVStore(fmt.Sprintf("%s/%s_values", treesStoreDir, merkleTreeToString[tree]))
+		if err != nil {
+			return nil, err
+		}
+		stateTrees.merkleTrees[tree] = smt.NewSparseMerkleTree(nodeStore, valueStore, sha256.New())
+	}
+	return stateTrees, nil
+}
 
-	for treeType := MerkleTree(0); treeType < numMerkleTrees; treeType++ {
-		// TODO_IN_THIS_COMMIT: Rather than using `NewSimpleMap`, use a disk based key-value store
-		// nodeStore := smt.NewSimpleMap()
-		// valueStore := smt.NewSimpleMap()
+func newMemStateTrees() (*stateTrees, error) {
+	stateTrees := &stateTrees{
+		merkleTrees: make(map[merkleTree]*smt.SparseMerkleTree, int(numMerkleTrees)),
+	}
+	for tree := merkleTree(0); tree < numMerkleTrees; tree++ {
+		// For testing, `smt.NewSimpleMap()` can be used as well
 		nodeStore := kvstore.NewMemKVStore()
 		valueStore := kvstore.NewMemKVStore()
-
-		trees[treeType] = smt.NewSparseMerkleTree(nodeStore, valueStore, sha256.New())
+		stateTrees.merkleTrees[tree] = smt.NewSparseMerkleTree(nodeStore, valueStore, sha256.New())
 	}
-	return trees, nil
+	return stateTrees, nil
 }
 
-func loadMerkleTrees(map[MerkleTree]*smt.SparseMerkleTree, error) {
-	log.Fatalf("TODO: loadMerkleTrees not implemented yet")
+func (s *stateTrees) getTree(tree merkleTree) *smt.SparseMerkleTree {
+	return s.merkleTrees[tree]
 }
 
 func (p *PostgresContext) updateStateHash() error {
 	// Update all the merkle trees
-	for treeType := MerkleTree(0); treeType < numMerkleTrees; treeType++ {
+	for treeType := merkleTree(0); treeType < numMerkleTrees; treeType++ {
 		switch treeType {
 		// Actor Merkle Trees
 		case appMerkleTree:
@@ -127,8 +166,8 @@ func (p *PostgresContext) updateStateHash() error {
 
 	// Get the root of each Merkle Tree
 	roots := make([][]byte, 0)
-	for treeType := MerkleTree(0); treeType < numMerkleTrees; treeType++ {
-		roots = append(roots, p.merkleTrees[treeType].Root())
+	for treeType := merkleTree(0); treeType < numMerkleTrees; treeType++ {
+		roots = append(roots, p.stateTrees.getTree(treeType).Root())
 	}
 
 	// Get the state hash
@@ -163,7 +202,7 @@ func (p *PostgresContext) updateActorsTree(actorType types.ActorType, height int
 			return fmt.Errorf("no merkle tree found for actor type: %s", actorType)
 		}
 
-		if _, err := p.merkleTrees[merkleTreeName].Update(bzAddr, actorBz); err != nil {
+		if _, err := p.stateTrees.getTree(merkleTreeName).Update(bzAddr, actorBz); err != nil {
 			return err
 		}
 	}
@@ -219,7 +258,7 @@ func (p *PostgresContext) updateAccountTrees(height int64) error {
 			return err
 		}
 
-		if _, err := p.merkleTrees[accountMerkleTree].Update(bzAddr, accBz); err != nil {
+		if _, err := p.stateTrees.getTree(accountMerkleTree).Update(bzAddr, accBz); err != nil {
 			return err
 		}
 	}
@@ -240,7 +279,7 @@ func (p *PostgresContext) updatePoolTrees(height int64) error {
 			return err
 		}
 
-		if _, err := p.merkleTrees[poolMerkleTree].Update(bzAddr, accBz); err != nil {
+		if _, err := p.stateTrees.getTree(poolMerkleTree).Update(bzAddr, accBz); err != nil {
 			return err
 		}
 	}
diff --git a/shared/modules/types.go b/shared/modules/types.go
index 66c9f878e..0263979cc 100644
--- a/shared/modules/types.go
+++ b/shared/modules/types.go
@@ -45,6 +45,7 @@ type PersistenceConfig interface {
 	GetNodeSchema() string
 	GetBlockStorePath() string
 	GetTxIndexerPath() string
+	GetTreesStoreDir() string
 }
 
 type P2PConfig interface {
diff --git a/utility/block.go b/utility/block.go
index 4fd954423..6e09bf93d 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -37,10 +37,10 @@ func (u *UtilityContext) ApplyBlock(latestHeight int64, proposerAddress []byte,
 		if err := tx.ValidateBasic(); err != nil {
 			return nil, nil, err
 		}
+		// DISCUSS(#315): Currently, the pattern is allowing nil err with an error transaction...
+		//                Should we terminate applyBlock immediately if there's an invalid transaction?
+		//                Or wait until the entire lifecycle is over to evaluate an 'invalid' block
 		// Validate and apply the transaction to the Postgres database
-		// DISCUSS_IN_THIS_COMMIT(#315): currently, the pattern is allowing nil err with an error transaction...
-		//                               Should we terminate applyBlock immediately if there's an invalid transaction?
-		//                               Or wait until the entire lifecycle is over to evaluate an 'invalid' block
 		txResult, err := u.ApplyTransaction(index, tx)
 		if err != nil {
 			return nil, nil, err
diff --git a/utility/context.go b/utility/context.go
index 2e48405dd..4dd423939 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -9,7 +9,7 @@ import (
 )
 
 type UtilityContext struct {
-	// TODO_IN_THIS_COMMIT(#315): Should be removed before this is commited.
+	// TODO(#315): Should be removed by #315 before this is even done.
 	LatestHeight    int64
 	currentProposer []byte
 
@@ -21,7 +21,7 @@ type UtilityContext struct {
 type Context struct {
 	// CLEANUP: Since `Context` embeds `PersistenceRWContext`, we don't need to do `u.Context.PersistenceRWContext`, but can call `u.Context` directly
 	modules.PersistenceRWContext
-	// TODO: `SavePoints`` have not been implemented yet
+	// TODO(#327): `SavePoints`` have not been implemented yet
 	SavePointsM map[string]struct{}
 	SavePoints  [][]byte
 }
diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index d75f32b49..e5b7e9e59 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -88,6 +88,7 @@ func newTestPersistenceModule(t *testing.T, databaseUrl string) modules.Persiste
 	mockPersistenceConfig.EXPECT().GetNodeSchema().Return(testSchema).AnyTimes()
 	mockPersistenceConfig.EXPECT().GetBlockStorePath().Return("").AnyTimes()
 	mockPersistenceConfig.EXPECT().GetTxIndexerPath().Return("").AnyTimes()
+	mockPersistenceConfig.EXPECT().GetTreesStoreDir().Return("").AnyTimes()
 
 	mockRuntimeConfig := mock_modules.NewMockConfig(ctrl)
 	mockRuntimeConfig.EXPECT().GetPersistenceConfig().Return(mockPersistenceConfig).AnyTimes()

From 6fb1ab73ff549638c2f66662ff784941e01518ca Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 1 Nov 2022 14:06:26 -0700
Subject: [PATCH 109/227] Don't clear context

---
 consensus/block.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/consensus/block.go b/consensus/block.go
index cd3bdb4e4..51453e813 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -14,10 +14,10 @@ func (m *consensusModule) commitBlock(block *typesCons.Block) error {
 	if err := m.utilityContext.Commit(block.BlockHeader.QuorumCertificate); err != nil {
 		return err
 	}
-
-	if err := m.utilityContext.Release(); err != nil {
-		return err
-	}
+	// TODO_IN_THIS_COMMIT: Should `Commit` implicitly release the context?
+	// if err := m.utilityContext.Release(); err != nil {
+	// 	return err
+	// }
 	m.utilityContext = nil
 
 	m.lastAppHash = block.BlockHeader.Hash

From 46e050adf77912edda98003ab21f63425364ea4c Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 1 Nov 2022 19:55:51 -0700
Subject: [PATCH 110/227] Fucking finally printing what's in my trees

---
 Makefile                               | 11 +++++
 app/client/main.go                     |  8 ++++
 consensus/debugging.go                 |  4 +-
 go.mod                                 |  4 +-
 go.sum                                 |  4 +-
 persistence/debug.go                   | 38 ++++++++++++++-
 persistence/genesis.go                 |  6 +++
 persistence/indexer/indexer.go         |  2 +-
 persistence/kvstore/kvstore.go         | 15 ++++--
 persistence/module.go                  | 17 ++++---
 persistence/state.go                   | 65 +++++++++++++++++---------
 shared/debug/proto/debug_message.proto |  1 +
 shared/node.go                         |  4 ++
 13 files changed, 137 insertions(+), 42 deletions(-)

diff --git a/Makefile b/Makefile
index 4d5b2580c..d04592e00 100644
--- a/Makefile
+++ b/Makefile
@@ -172,6 +172,11 @@ db_show_schemas: docker_check
 db_admin:
 	echo "Open http://0.0.0.0:5050 and login with 'pgadmin4@pgadmin.org' and 'pgadmin4'.\n The password is 'postgres'"
 
+.PHONY: db_export_trees
+## Helper to export the data in the merkle trees
+db_export_trees:
+	echo "I'm not done yet"
+
 .PHONY: docker_kill_all
 ## Kill all containers started by the docker-compose file
 docker_kill_all: docker_check
@@ -185,6 +190,12 @@ docker_wipe: docker_check prompt_user
 	docker images -q | xargs -r -I {} docker rmi {}
 	docker volume ls -q | xargs -r -I {} docker volume rm {}
 
+.PHONY: docker_wipe_nodes
+## [WARNING] Remove all the node containers
+docker_wipe_nodes: docker_check prompt_user
+	docker ps -a -q --filter="name=node*" | xargs -r -I {} docker stop {}
+	docker ps -a -q --filter="name=node*" | xargs -r -I {} docker rm {}
+
 .PHONY: monitoring_start
 ## Start grafana, metrics and logging system (this is auto-triggered by compose_and_watch)
 monitoring_start: docker_check
diff --git a/app/client/main.go b/app/client/main.go
index eb305535d..b8706fc37 100644
--- a/app/client/main.go
+++ b/app/client/main.go
@@ -27,6 +27,7 @@ const (
 	PromptTriggerNextView        string = "TriggerNextView"
 	PromptTogglePacemakerMode    string = "TogglePacemakerMode"
 	PromptShowLatestBlockInStore string = "ShowLatestBlockInStore"
+	PromptExportTrees            string = "ExportTrees"
 
 	defaultConfigPath  = "build/config/config1.json"
 	defaultGenesisPath = "build/config/genesis.json"
@@ -38,6 +39,7 @@ var items = []string{
 	PromptTriggerNextView,
 	PromptTogglePacemakerMode,
 	PromptShowLatestBlockInStore,
+	PromptExportTrees,
 }
 
 // A P2P module is initialized in order to broadcast a message to the local network
@@ -138,6 +140,12 @@ func handleSelect(selection string) {
 			Message: nil,
 		}
 		sendDebugMessage(m)
+	case PromptExportTrees:
+		m := &debug.DebugMessage{
+			Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_TREE_EXPORT,
+			Message: nil,
+		}
+		sendDebugMessage(m)
 	default:
 		log.Println("Selection not yet implemented...", selection)
 	}
diff --git a/consensus/debugging.go b/consensus/debugging.go
index aad6a0353..dd0d61c04 100644
--- a/consensus/debugging.go
+++ b/consensus/debugging.go
@@ -62,9 +62,9 @@ func (m *consensusModule) printNodeState(_ *debug.DebugMessage) {
 func (m *consensusModule) triggerNextView(_ *debug.DebugMessage) {
 	m.nodeLog(typesCons.DebugTriggerNextView)
 
-	currentheight := m.Height
+	currentHeight := m.Height
 	currentStep := m.Step
-	if currentheight == 0 || (currentStep == Decide && m.paceMaker.IsManualMode()) {
+	if currentHeight == 0 || (currentStep == Decide && m.paceMaker.IsManualMode()) {
 		m.paceMaker.NewHeight()
 	} else {
 		m.paceMaker.InterruptRound()
diff --git a/go.mod b/go.mod
index 762c0ad0a..b9acdcd97 100644
--- a/go.mod
+++ b/go.mod
@@ -16,7 +16,7 @@ require (
 	golang.org/x/crypto v0.0.0-20220214200702-86341886e292
 	golang.org/x/exp v0.0.0-20220301223727-77fc55f9b6c1
 	gonum.org/v1/gonum v0.9.3
-	google.golang.org/protobuf v1.28.0
+	google.golang.org/protobuf v1.28.1
 )
 
 require (
@@ -42,7 +42,6 @@ require (
 	github.com/docker/go-connections v0.4.0 // indirect
 	github.com/docker/go-units v0.4.0 // indirect
 	github.com/dustin/go-humanize v1.0.0 // indirect
-	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b // indirect
 	github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
@@ -74,6 +73,7 @@ require (
 	github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/fsnotify/fsnotify v1.4.7 // indirect
+	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/google/go-cmp v0.5.6 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
 	github.com/jackc/chunkreader/v2 v2.0.1 // indirect
diff --git a/go.sum b/go.sum
index daf8c4279..6e6967b77 100644
--- a/go.sum
+++ b/go.sum
@@ -763,8 +763,8 @@ google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlba
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.28.0 h1:w43yiav+6bVFTBQFZX0r7ipe9JQ1QsbMgHwbBziscLw=
-google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w=
+google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
diff --git a/persistence/debug.go b/persistence/debug.go
index 586d3b1f1..379d5183a 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -1,11 +1,13 @@
 package persistence
 
 import (
+	"fmt"
 	"log"
 
 	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/debug"
+	"google.golang.org/protobuf/proto"
 )
 
 func (m *persistenceModule) HandleDebugMessage(debugMessage *debug.DebugMessage) error {
@@ -22,6 +24,10 @@ func (m *persistenceModule) HandleDebugMessage(debugMessage *debug.DebugMessage)
 		}
 		g := m.genesisState.(*types.PersistenceGenesisState)
 		m.populateGenesisState(g) // fatal if there's an error
+	case debug.DebugMessageAction_DEBUG_PERSISTENCE_TREE_EXPORT:
+		if err := m.exportTrees(debugMessage); err != nil {
+			return err
+		}
 	default:
 		log.Printf("Debug message not handled by persistence module: %s \n", debugMessage.Message)
 	}
@@ -30,7 +36,7 @@ func (m *persistenceModule) HandleDebugMessage(debugMessage *debug.DebugMessage)
 
 func (m *persistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 	// TODO: Add an iterator to the `kvstore` and use that instead
-	height := m.GetBus().GetConsensusModule().CurrentHeight() - 1 // -1 because we want the latest committed height
+	height := m.GetBus().GetConsensusModule().CurrentHeight()
 	blockBytes, err := m.GetBlockStore().Get(heightToBytes(int64(height)))
 	if err != nil {
 		log.Printf("Error getting block %d from block store: %s \n", height, err)
@@ -43,6 +49,27 @@ func (m *persistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 	log.Printf("Block at height %d with %d transactions: %+v \n", height, len(block.Transactions), block)
 }
 
+// Everyone roles their own key-value export: https://www.reddit.com/r/golang/comments/bw08dt/is_there_any_offline_database_viewer_and_editor
+func (m *persistenceModule) exportTrees(_ *debug.DebugMessage) error {
+	for treeType := merkleTree(0); treeType < numMerkleTrees; treeType++ {
+		smtValues := m.stateTrees.valueStores[treeType]
+		_, values, err := smtValues.GetAll(nil, true)
+		if err != nil {
+			return err
+		}
+		for i := 0; i < len(values); i++ {
+			vProto := merkleTreeToProtoSchema[treeType]()
+			// vProto := &types.Actor{}
+			if err := proto.Unmarshal(values[i], vProto.(proto.Message)); err != nil {
+				// if err := proto.Unmarshal(values[i], vProto); err != nil {
+				return err
+			}
+			fmt.Println(vProto)
+		}
+	}
+	return nil
+}
+
 func (m *persistenceModule) clearState(_ *debug.DebugMessage) error {
 	context, err := m.NewRWContext(-1)
 	if err != nil {
@@ -57,6 +84,15 @@ func (m *persistenceModule) clearState(_ *debug.DebugMessage) error {
 		return err
 	}
 
+	for treeType := merkleTree(0); treeType < numMerkleTrees; treeType++ {
+		if err := m.stateTrees.nodeStores[treeType].ClearAll(); err != nil {
+			return err
+		}
+		if err := m.stateTrees.valueStores[treeType].ClearAll(); err != nil {
+			return err
+		}
+	}
+
 	if err := m.ReleaseWriteContext(); err != nil {
 		return err
 	}
diff --git a/persistence/genesis.go b/persistence/genesis.go
index 9649e1b15..e7ee6d5c9 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -143,6 +143,12 @@ func (m *persistenceModule) populateGenesisState(state modules.PersistenceGenesi
 		log.Fatalf("an error occurred initializing flags: %s", err.Error())
 	}
 
+	// This populate all the merkle trees
+	if _, err = rwContext.UpdateAppHash(); err != nil {
+		log.Fatalf("an error occurred updating the app hash during genesis: %s", err.Error())
+	}
+
+	// This update the DB, blockstore, and commits the state
 	if err = rwContext.Commit([]byte("placeholderGenesisProposer"), []byte("placeholderQuorumCert")); err != nil {
 		log.Fatalf("error committing genesis state to DB %s ", err.Error())
 	}
diff --git a/persistence/indexer/indexer.go b/persistence/indexer/indexer.go
index 0b4bfbe46..527b8b747 100644
--- a/persistence/indexer/indexer.go
+++ b/persistence/indexer/indexer.go
@@ -146,7 +146,7 @@ func (indexer *txIndexer) Close() error {
 // kv helper functions
 
 func (indexer *txIndexer) getAll(prefix []byte, descending bool) (result []shared.TxResult, err error) {
-	hashKeys, err := indexer.db.GetAll(prefix, descending)
+	_, hashKeys, err := indexer.db.GetAll(prefix, descending)
 	if err != nil {
 		return nil, err
 	}
diff --git a/persistence/kvstore/kvstore.go b/persistence/kvstore/kvstore.go
index 385270331..40131d444 100644
--- a/persistence/kvstore/kvstore.go
+++ b/persistence/kvstore/kvstore.go
@@ -9,7 +9,7 @@ import (
 )
 
 type KVStore interface {
-	smt.MapStore
+	smt.MapStore // Get, Set, Delete
 
 	// Lifecycle methods
 	Stop() error
@@ -17,10 +17,14 @@ type KVStore interface {
 	// Accessors
 	// TODO: Add a proper iterator interface
 	// TODO: Add pagination for `GetAll`
-	GetAll(prefixKey []byte, descending bool) ([][]byte, error)
+	GetAll(prefixKey []byte, descending bool) (keys [][]byte, values [][]byte, err error)
 
 	Exists(key []byte) (bool, error)
 	ClearAll() error
+
+	// Get(key []byte) ([]byte, error)     // Get gets the value for a key.
+	// Set(key []byte, value []byte) error // Set updates the value for a key.
+	// Delete(key []byte) error            // Delete deletes a key.
 }
 
 const (
@@ -95,8 +99,9 @@ func (store *badgerKVStore) Delete(key []byte) error {
 	return tx.Delete(key)
 }
 
-func (store *badgerKVStore) GetAll(prefix []byte, descending bool) (values [][]byte, err error) {
+func (store *badgerKVStore) GetAll(prefix []byte, descending bool) (keys [][]byte, values [][]byte, err error) {
 	// INVESTIGATE: research `badger.views` for further improvements and optimizations
+	// Reference https://pkg.go.dev/github.com/dgraph-io/badger#readme-prefix-scans
 	txn := store.db.NewTransaction(false)
 	defer txn.Discard()
 
@@ -109,11 +114,15 @@ func (store *badgerKVStore) GetAll(prefix []byte, descending bool) (values [][]b
 	it := txn.NewIterator(opt)
 	defer it.Close()
 
+	keys = make([][]byte, 0)
+	values = make([][]byte, 0)
+
 	for it.Seek(prefix); it.Valid(); it.Next() {
 		item := it.Item()
 		err = item.Value(func(v []byte) error {
 			b := make([]byte, len(v))
 			copy(b, v)
+			keys = append(keys, item.Key())
 			values = append(values, b)
 			return nil
 		})
diff --git a/persistence/module.go b/persistence/module.go
index 77b6b1fc2..908c94296 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -97,13 +97,13 @@ func (*persistenceModule) Create(runtimeMgr modules.RuntimeMgr) (modules.Module,
 		writeContext: nil,
 	}
 
+	// TECHDEBT: reconsider if this is the best place to call `populateGenesisState`. Note that
+	// 		     this forces the genesis state to be reloaded on every node startup until state
+	//           sync is implemented.
 	// Determine if we should hydrate the genesis db or use the current state of the DB attached
 	if shouldHydrateGenesis, err := m.shouldHydrateGenesisDb(); err != nil {
 		return nil, err
 	} else if shouldHydrateGenesis {
-		// TECHDEBT: reconsider if this is the best place to call `populateGenesisState`. Note that
-		// 		     this forces the genesis state to be reloaded on every node startup until state
-		//           sync is implemented.
 		m.populateGenesisState(persistenceGenesis) // fatal if there's an error
 	} else {
 		log.Println("Loading state from previous state...")
@@ -221,8 +221,8 @@ func (m *persistenceModule) NewWriteContext() modules.PersistenceRWContext {
 	return m.writeContext
 }
 
-// TODO(olshansky): Simplify and externalize the logic for whether genesis should be populated and
-// move the if logic out of this file.
+// HACK(olshansky): Simplify and externalize the logic for whether genesis should be populated and
+//                  move the if logic out of this file.
 func (m *persistenceModule) shouldHydrateGenesisDb() (bool, error) {
 	checkContext, err := m.NewReadContext(-1)
 	if err != nil {
@@ -230,12 +230,11 @@ func (m *persistenceModule) shouldHydrateGenesisDb() (bool, error) {
 	}
 	defer checkContext.Close()
 
-	maxHeight, err := checkContext.GetLatestBlockHeight()
-	if err == nil || maxHeight == 0 {
+	_, err = checkContext.GetLatestBlockHeight()
+	if err != nil {
 		return true, nil
 	}
-
-	return m.blockStore.Exists(heightToBytes(int64(maxHeight)))
+	return false, nil
 }
 
 func initializeBlockStore(blockStorePath string) (kvstore.KVStore, error) {
diff --git a/persistence/state.go b/persistence/state.go
index 2ed979539..5a27e84a8 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -17,6 +17,11 @@ type merkleTree float64
 
 type stateTrees struct {
 	merkleTrees map[merkleTree]*smt.SparseMerkleTree
+
+	// nodeStores & valueStore are part of the SMT, but references are kept below for convenience
+	// and debugging purposes
+	nodeStores  map[merkleTree]kvstore.KVStore
+	valueStores map[merkleTree]kvstore.KVStore
 }
 
 // A list of Merkle Trees used to maintain the state hash.
@@ -80,6 +85,20 @@ var merkleTreeToActorTypeName map[merkleTree]types.ActorType = map[merkleTree]ty
 	serviceNodeMerkleTree: types.ActorType_Node,
 }
 
+var merkleTreeToProtoSchema = map[merkleTree]func() proto.Message{
+	appMerkleTree:         func() proto.Message { return &types.Actor{} },
+	valMerkleTree:         func() proto.Message { return &types.Actor{} },
+	fishMerkleTree:        func() proto.Message { return &types.Actor{} },
+	serviceNodeMerkleTree: func() proto.Message { return &types.Actor{} },
+
+	accountMerkleTree: func() proto.Message { return &types.Account{} },
+	poolMerkleTree:    func() proto.Message { return &types.Account{} },
+
+	blocksMerkleTree: func() proto.Message { return &types.Block{} },
+	// paramsMerkleTree: func() proto.Message { return &types.Params{} },
+	// flagsMerkleTree:  func() proto.Message { return &types.Flags{} },
+}
+
 func newStateTrees(treesStoreDir string) (*stateTrees, error) {
 	if treesStoreDir == "" {
 		return newMemStateTrees()
@@ -87,6 +106,8 @@ func newStateTrees(treesStoreDir string) (*stateTrees, error) {
 
 	stateTrees := &stateTrees{
 		merkleTrees: make(map[merkleTree]*smt.SparseMerkleTree, int(numMerkleTrees)),
+		nodeStores:  make(map[merkleTree]kvstore.KVStore, int(numMerkleTrees)),
+		valueStores: make(map[merkleTree]kvstore.KVStore, int(numMerkleTrees)),
 	}
 
 	for tree := merkleTree(0); tree < numMerkleTrees; tree++ {
@@ -98,6 +119,8 @@ func newStateTrees(treesStoreDir string) (*stateTrees, error) {
 		if err != nil {
 			return nil, err
 		}
+		stateTrees.nodeStores[tree] = nodeStore
+		stateTrees.valueStores[tree] = valueStore
 		stateTrees.merkleTrees[tree] = smt.NewSparseMerkleTree(nodeStore, valueStore, sha256.New())
 	}
 	return stateTrees, nil
@@ -106,20 +129,19 @@ func newStateTrees(treesStoreDir string) (*stateTrees, error) {
 func newMemStateTrees() (*stateTrees, error) {
 	stateTrees := &stateTrees{
 		merkleTrees: make(map[merkleTree]*smt.SparseMerkleTree, int(numMerkleTrees)),
+		nodeStores:  make(map[merkleTree]kvstore.KVStore, int(numMerkleTrees)),
+		valueStores: make(map[merkleTree]kvstore.KVStore, int(numMerkleTrees)),
 	}
 	for tree := merkleTree(0); tree < numMerkleTrees; tree++ {
-		// For testing, `smt.NewSimpleMap()` can be used as well
-		nodeStore := kvstore.NewMemKVStore()
+		nodeStore := kvstore.NewMemKVStore() // For testing, `smt.NewSimpleMap()` can be used as well
 		valueStore := kvstore.NewMemKVStore()
+		stateTrees.nodeStores[tree] = nodeStore
+		stateTrees.valueStores[tree] = valueStore
 		stateTrees.merkleTrees[tree] = smt.NewSparseMerkleTree(nodeStore, valueStore, sha256.New())
 	}
 	return stateTrees, nil
 }
 
-func (s *stateTrees) getTree(tree merkleTree) *smt.SparseMerkleTree {
-	return s.merkleTrees[tree]
-}
-
 func (p *PostgresContext) updateStateHash() error {
 	// Update all the merkle trees
 	for treeType := merkleTree(0); treeType < numMerkleTrees; treeType++ {
@@ -166,8 +188,8 @@ func (p *PostgresContext) updateStateHash() error {
 
 	// Get the root of each Merkle Tree
 	roots := make([][]byte, 0)
-	for treeType := merkleTree(0); treeType < numMerkleTrees; treeType++ {
-		roots = append(roots, p.stateTrees.getTree(treeType).Root())
+	for tree := merkleTree(0); tree < numMerkleTrees; tree++ {
+		roots = append(roots, p.stateTrees.merkleTrees[tree].Root())
 	}
 
 	// Get the state hash
@@ -201,8 +223,7 @@ func (p *PostgresContext) updateActorsTree(actorType types.ActorType, height int
 		if !ok {
 			return fmt.Errorf("no merkle tree found for actor type: %s", actorType)
 		}
-
-		if _, err := p.stateTrees.getTree(merkleTreeName).Update(bzAddr, actorBz); err != nil {
+		if _, err := p.stateTrees.merkleTrees[merkleTreeName].Update(bzAddr, actorBz); err != nil {
 			return err
 		}
 	}
@@ -222,19 +243,19 @@ func (p *PostgresContext) getActorsUpdatedAtHeight(actorType types.ActorType, he
 	}
 
 	actors = make([]*types.Actor, len(schemaActors))
-	for _, actor := range schemaActors {
+	for i, schemaActor := range schemaActors {
 		actor := &types.Actor{
 			ActorType:       actorType,
-			Address:         actor.Address,
-			PublicKey:       actor.PublicKey,
-			Chains:          actor.Chains,
-			GenericParam:    actor.GenericParam,
-			StakedAmount:    actor.StakedAmount,
-			PausedHeight:    actor.PausedHeight,
-			UnstakingHeight: actor.UnstakingHeight,
-			Output:          actor.Output,
+			Address:         schemaActor.Address,
+			PublicKey:       schemaActor.PublicKey,
+			Chains:          schemaActor.Chains,
+			GenericParam:    schemaActor.GenericParam,
+			StakedAmount:    schemaActor.StakedAmount,
+			PausedHeight:    schemaActor.PausedHeight,
+			UnstakingHeight: schemaActor.UnstakingHeight,
+			Output:          schemaActor.Output,
 		}
-		actors = append(actors, actor)
+		actors[i] = actor
 	}
 	return
 }
@@ -258,7 +279,7 @@ func (p *PostgresContext) updateAccountTrees(height int64) error {
 			return err
 		}
 
-		if _, err := p.stateTrees.getTree(accountMerkleTree).Update(bzAddr, accBz); err != nil {
+		if _, err := p.stateTrees.merkleTrees[accountMerkleTree].Update(bzAddr, accBz); err != nil {
 			return err
 		}
 	}
@@ -279,7 +300,7 @@ func (p *PostgresContext) updatePoolTrees(height int64) error {
 			return err
 		}
 
-		if _, err := p.stateTrees.getTree(poolMerkleTree).Update(bzAddr, accBz); err != nil {
+		if _, err := p.stateTrees.merkleTrees[poolMerkleTree].Update(bzAddr, accBz); err != nil {
 			return err
 		}
 	}
diff --git a/shared/debug/proto/debug_message.proto b/shared/debug/proto/debug_message.proto
index 85941eeb2..08867e48d 100644
--- a/shared/debug/proto/debug_message.proto
+++ b/shared/debug/proto/debug_message.proto
@@ -17,6 +17,7 @@ enum DebugMessageAction {
 
 	DEBUG_PERSISTENCE_CLEAR_STATE = 6;
 	DEBUG_PERSISTENCE_RESET_TO_GENESIS = 7;
+	DEBUG_PERSISTENCE_TREE_EXPORT = 8;
 }
 
 message DebugMessage {
diff --git a/shared/node.go b/shared/node.go
index 026a2c9f8..2e700179e 100644
--- a/shared/node.go
+++ b/shared/node.go
@@ -158,6 +158,7 @@ func (node *Node) handleDebugEvent(anyMessage *anypb.Any) error {
 		return err
 	}
 	switch debugMessage.Action {
+	// Consensus Debug
 	case debug.DebugMessageAction_DEBUG_CONSENSUS_RESET_TO_GENESIS:
 		fallthrough
 	case debug.DebugMessageAction_DEBUG_CONSENSUS_PRINT_NODE_STATE:
@@ -166,7 +167,10 @@ func (node *Node) handleDebugEvent(anyMessage *anypb.Any) error {
 		fallthrough
 	case debug.DebugMessageAction_DEBUG_CONSENSUS_TOGGLE_PACE_MAKER_MODE:
 		return node.GetBus().GetConsensusModule().HandleDebugMessage(&debugMessage)
+	// Persistence Debug
 	case debug.DebugMessageAction_DEBUG_SHOW_LATEST_BLOCK_IN_STORE:
+		fallthrough
+	case debug.DebugMessageAction_DEBUG_PERSISTENCE_TREE_EXPORT:
 		return node.GetBus().GetPersistenceModule().HandleDebugMessage(&debugMessage)
 	default:
 		log.Printf("Debug message: %s \n", debugMessage.Message)

From 2100975b26078f2417264b24851ca96725cfad7e Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 3 Nov 2022 16:52:48 -0700
Subject: [PATCH 111/227] Made some progress on benchmarking

---
 persistence/db.go                        |  2 +
 persistence/debug.go                     | 18 ++++--
 persistence/state.go                     |  4 +-
 persistence/test/account_test.go         |  6 +-
 persistence/test/benchmark_state_test.go | 82 ++++++++++++++++--------
 persistence/test/setup_test.go           | 20 ++----
 persistence/test/state_test.go           |  6 +-
 7 files changed, 83 insertions(+), 55 deletions(-)

diff --git a/persistence/db.go b/persistence/db.go
index 57b4d3233..c9c009109 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -45,6 +45,8 @@ var nonActorClearFunctions = []func() string{
 var _ modules.PersistenceRWContext = &PostgresContext{}
 
 type PostgresContext struct {
+	// modules.PersistenceRWContext
+
 	Height int64 // TODO(olshansky): `Height` is only externalized for testing purposes. Replace with helpers...
 	conn   *pgx.Conn
 	tx     pgx.Tx
diff --git a/persistence/debug.go b/persistence/debug.go
index 379d5183a..e9add4757 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -70,32 +70,38 @@ func (m *persistenceModule) exportTrees(_ *debug.DebugMessage) error {
 	return nil
 }
 
+// TODO: MAke sure this is atomic
 func (m *persistenceModule) clearState(_ *debug.DebugMessage) error {
 	context, err := m.NewRWContext(-1)
 	if err != nil {
 		return err
 	}
 
+	// Clear the SQL DB
 	if err := context.(*PostgresContext).DebugClearAll(); err != nil {
 		return err
 	}
 
+	if err := m.ReleaseWriteContext(); err != nil {
+		return err
+	}
+
+	// Clear the KV Stores
+
 	if err := m.blockStore.ClearAll(); err != nil {
 		return err
 	}
 
 	for treeType := merkleTree(0); treeType < numMerkleTrees; treeType++ {
-		if err := m.stateTrees.nodeStores[treeType].ClearAll(); err != nil {
-			return err
-		}
 		if err := m.stateTrees.valueStores[treeType].ClearAll(); err != nil {
 			return err
 		}
+		// if err := m.stateTrees.nodeStores[treeType].ClearAll(); err != nil {
+		// 	return err
+		// }
 	}
 
-	if err := m.ReleaseWriteContext(); err != nil {
-		return err
-	}
+	log.Println("Cleared all the state")
 
 	return nil
 }
diff --git a/persistence/state.go b/persistence/state.go
index 5a27e84a8..0833fc9b5 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -176,9 +176,9 @@ func (p *PostgresContext) updateStateHash() error {
 		case blocksMerkleTree:
 			p.updateBlockTree(p.Height)
 		case paramsMerkleTree:
-			log.Printf("TODO: merkle tree not implemented yet. Merkle tree #{%v}\n", treeType)
+			// log.Printf("TODO: merkle tree not implemented yet. Merkle tree #{%v}\n", treeType)
 		case flagsMerkleTree:
-			log.Printf("TODO: merkle tree not implemented yet. Merkle tree #{%v}\n", treeType)
+			// log.Printf("TODO: merkle tree not implemented yet. Merkle tree #{%v}\n", treeType)
 
 		// Default
 		default:
diff --git a/persistence/test/account_test.go b/persistence/test/account_test.go
index 6ac11cdad..a1b0c3197 100644
--- a/persistence/test/account_test.go
+++ b/persistence/test/account_test.go
@@ -89,12 +89,16 @@ func FuzzAccountAmount(f *testing.F) {
 
 func TestDefaultNonExistentAccountAmount(t *testing.T) {
 	db := NewTestPostgresContext(t, 0)
+	fmt.Println("BEFORE TESTG")
 	addr, err := crypto.GenerateAddress()
 	require.NoError(t, err)
-
+	fmt.Println("BEFORE TESTG 2")
 	accountAmount, err := db.GetAccountAmount(addr, db.Height)
+	fmt.Println("BEFORE TESTG 3")
 	require.NoError(t, err)
+	fmt.Println("BEFORE TESTG 4")
 	require.Equal(t, "0", accountAmount)
+	fmt.Println("BEFORE TESTG 5")
 }
 
 func TestSetAccountAmount(t *testing.T) {
diff --git a/persistence/test/benchmark_state_test.go b/persistence/test/benchmark_state_test.go
index 6472d727f..057dc4912 100644
--- a/persistence/test/benchmark_state_test.go
+++ b/persistence/test/benchmark_state_test.go
@@ -7,6 +7,7 @@ import (
 	"math/rand"
 	"os"
 	"reflect"
+	"regexp"
 	"testing"
 
 	"github.com/pokt-network/pocket/persistence"
@@ -15,6 +16,8 @@ import (
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
+var re = regexp.MustCompile(`^[Insert|Update|Set|Add|Subtract]`)
+
 func BenchmarkStateHash(b *testing.B) {
 	log.SetOutput(ioutil.Discard)
 	defer log.SetOutput(os.Stderr)
@@ -36,13 +39,14 @@ func BenchmarkStateHash(b *testing.B) {
 		numHeights     int64
 		numTxPerHeight int64
 	}{
-		{1, 1},
-		{100, 1},
-		{100, 10},
-		{1000, 1},
-		{1000, 10},
-		{10000, 10},
-		{10000, 1000},
+		// {1, 1},
+		{1, 100},
+		// {100, 1},
+		// {100, 10},
+		// {1000, 1},
+		// {1000, 10},
+		// {10000, 10},
+		// {10000, 1000},
 	}
 
 	for _, testCase := range testCases {
@@ -51,9 +55,8 @@ func BenchmarkStateHash(b *testing.B) {
 		b.Run(fmt.Sprintf("heights=%d;txPerHeight=%d", numHeights, numTxPerHeight), func(b *testing.B) {
 			for h := int64(0); h < numHeights; h++ {
 				db := NewTestPostgresContext(b, h)
-				helper(db)
 				for i := int64(0); i < numTxPerHeight; i++ {
-					// TODO: Perform a random operation
+					callRandomModifierFunc(db, h)
 					db.StoreTransaction(modules.TxResult(getRandomTxResult(h)))
 				}
 				db.UpdateAppHash()
@@ -63,42 +66,61 @@ func BenchmarkStateHash(b *testing.B) {
 	}
 }
 
-func helper(p *persistence.PostgresContext) {
-	v := reflect.ValueOf(p)
-	// t := reflect.TypeOf(p)
-	for m := 0; m < v.NumMethod(); m++ {
+func callRandomModifierFunc(p *persistence.PostgresContext, height int64) error {
+	t := reflect.TypeOf(modules.PersistenceWriteContext(p))
+
+MethodLoop:
+	for m := 0; m < t.NumMethod(); m++ {
+		method := t.Method(m)
+		methodName := method.Name
+
+		if !re.MatchString(methodName) {
+			continue
+		}
+
 		var callArgs []reflect.Value
-		method := v.Method(m).Type()
-		// methodName := t.Method(m).Name
-		for i := 0; i < method.NumIn(); i++ {
-			arg := method.In(i)
+		for i := 1; i < method.Type.NumIn(); i++ {
+			var v reflect.Value
+			arg := method.Type.In(i)
 			switch arg.Kind() {
 			case reflect.String:
-				v = reflect.ValueOf("123")
+				v = reflect.ValueOf(getRandomString(50))
 			case reflect.Slice:
-				v = reflect.ValueOf([]byte("abc"))
+				switch arg.Elem().Kind() {
+				case reflect.Uint8:
+					v = reflect.ValueOf([]uint8{0})
+				case reflect.String:
+					v = reflect.ValueOf([]string{"abc"})
+				default:
+					continue MethodLoop
+				}
 			case reflect.Bool:
-				v = reflect.ValueOf(false)
+				v = reflect.ValueOf(rand.Intn(2) == 1)
 			case reflect.Uint8:
-				fallthrough
+				v = reflect.ValueOf(uint8(rand.Intn(2 ^ 8 - 1)))
 			case reflect.Int32:
-				fallthrough
+				v = reflect.ValueOf(rand.Int31())
 			case reflect.Int64:
-				fallthrough
+				v = reflect.ValueOf(rand.Int63())
 			case reflect.Int:
-				v = reflect.ValueOf(0)
+				v = reflect.ValueOf(rand.Int())
+			case reflect.Pointer:
+				fallthrough
 			default:
-				log.Println("OLSH, not supported", arg.Kind())
+				continue MethodLoop
 			}
 			callArgs = append(callArgs, v)
 		}
-		// fmt.Println(methodName, callArgs)
+		// fmt.Println(methodName, "~~~", method.Type.NumIn(), callArgs)
+		// return reflect.ValueOf(p).MethodByName(method.Name).Call(callArgs)
+		reflect.ValueOf(p).MethodByName(method.Name).Call(callArgs)
 	}
+	return nil
 }
 
 func getRandomTxResult(height int64) *indexer.TxRes {
 	return &indexer.TxRes{
-		Tx:            getTxBytes(50),
+		Tx:            getRandomBytes(50),
 		Height:        height,
 		Index:         0,
 		ResultCode:    0,
@@ -109,7 +131,11 @@ func getRandomTxResult(height int64) *indexer.TxRes {
 	}
 }
 
-func getTxBytes(numBytes int64) []byte {
+func getRandomString(numChars int64) string {
+	return string(getRandomBytes(numChars))
+}
+
+func getRandomBytes(numBytes int64) []byte {
 	bz := make([]byte, numBytes)
 	rand.Read(bz)
 	return bz
diff --git a/persistence/test/setup_test.go b/persistence/test/setup_test.go
index da4aa98b8..5db7f067c 100644
--- a/persistence/test/setup_test.go
+++ b/persistence/test/setup_test.go
@@ -59,7 +59,7 @@ func TestMain(m *testing.M) {
 }
 
 // IMPROVE(olshansky): Look into returning `testPersistenceMod` to avoid exposing underlying abstraction.
-func NewTestPostgresContext[T testing.T | testing.B | testing.F](t *T, height int64) *persistence.PostgresContext {
+func NewTestPostgresContext(t testing.TB, height int64) *persistence.PostgresContext {
 	ctx, err := testPersistenceMod.NewRWContext(height)
 	if err != nil {
 		log.Fatalf("Error creating new context: %v\n", err)
@@ -70,24 +70,12 @@ func NewTestPostgresContext[T testing.T | testing.B | testing.F](t *T, height in
 		log.Fatalf("Error casting RW context to Postgres context")
 	}
 
-	var cleanupFn func(func())
-	switch any(t).(type) {
-	case *testing.T:
-		cleanupFn = any(t).(*testing.T).Cleanup
-	case *testing.B:
-		cleanupFn = any(t).(*testing.B).Cleanup
-	case *testing.F:
-		cleanupFn = any(t).(*testing.F).Cleanup
-	default:
-		log.Fatalf("Error: unsupported type %T", t)
-	}
-
-	cleanupFn(func() {
+	t.Cleanup(func() {
 		if err := testPersistenceMod.ReleaseWriteContext(); err != nil {
 			log.Fatalf("Error releasing write context: %v\n", err)
 		}
 		if err := testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
-			// Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
+			// Action: debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
 			Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_RESET_TO_GENESIS,
 			Message: nil,
 		}); err != nil {
@@ -108,6 +96,8 @@ func newTestPersistenceModule(databaseUrl string) modules.PersistenceModule {
 		PostgresUrl:    databaseUrl,
 		NodeSchema:     testSchema,
 		BlockStorePath: "",
+		TxIndexerPath:  "",
+		TreesStoreDir:  "",
 	}))
 	genesisState, _ := test_artifacts.NewGenesisState(5, 1, 1, 1)
 	runtimeCfg := runtime.NewManager(cfg, genesisState)
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index 9562a9e17..73dbd23bf 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -37,9 +37,9 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 	// that the business logic doesn't change and that they remain deterministic. Anytime the business
 	// logic changes, these hashes will need to be updated based on the test output.
 	encodedAppHash := []string{
-		"3078d5c1dc45f3f76f5daef585097c4029e6d5837e2d6bc2bfb8c2c3d3766e4c",
-		"021b96cd367323c1d97832580d47ad3e54bfe79141aa507b7d60e3b0ddd107d6",
-		"70db812fb2b397252fb49b189d405d6e001bc7e2452914ca5c231af1166f2675",
+		"5c2d66d8dae3e823f573fe62f403d492045c22191bc2610396e1a20fc6a19af4",
+		"1e736e8c94c899f9ac6544744a0f12d2ed29d4e611e7c088f14fc338499fb166",
+		"ce9bf6328228cd8caf138ddc440a8fd512af6a25542c9863562abeb5c793dd82",
 	}
 
 	stakeAmount := initialStakeAmount

From 82f0fd410a693d33cd28a0076139e5aaad3ec55b Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 3 Nov 2022 17:48:09 -0700
Subject: [PATCH 112/227] Exporting state correctly

---
 app/client/main.go               | 12 ++++++------
 persistence/debug.go             | 20 +++++++++++++++++++-
 persistence/test/account_test.go |  5 -----
 persistence/test/state_test.go   |  6 +++---
 4 files changed, 28 insertions(+), 15 deletions(-)

diff --git a/app/client/main.go b/app/client/main.go
index b8706fc37..1893e51f0 100644
--- a/app/client/main.go
+++ b/app/client/main.go
@@ -22,12 +22,12 @@ import (
 // TODO(olshansky): Lowercase variables / constants that do not need to be exported.
 
 const (
-	PromptResetToGenesis         string = "ResetToGenesis"
-	PromptPrintNodeState         string = "PrintNodeState"
-	PromptTriggerNextView        string = "TriggerNextView"
-	PromptTogglePacemakerMode    string = "TogglePacemakerMode"
-	PromptShowLatestBlockInStore string = "ShowLatestBlockInStore"
-	PromptExportTrees            string = "ExportTrees"
+	PromptResetToGenesis         string = "ResetToGenesis (broadcast)"
+	PromptPrintNodeState         string = "PrintNodeState (broadcast)"
+	PromptTriggerNextView        string = "TriggerNextView (broadcast)"
+	PromptTogglePacemakerMode    string = "TogglePacemakerMode (broadcast)"
+	PromptShowLatestBlockInStore string = "ShowLatestBlockInStore (send)"
+	PromptExportTrees            string = "ExportTrees (send)"
 
 	defaultConfigPath  = "build/config/config1.json"
 	defaultGenesisPath = "build/config/genesis.json"
diff --git a/persistence/debug.go b/persistence/debug.go
index e9add4757..af010c2ef 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -3,10 +3,14 @@ package persistence
 import (
 	"fmt"
 	"log"
+	"os"
+	"strings"
 
 	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/debug"
+
+	"google.golang.org/protobuf/encoding/protojson"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -50,13 +54,20 @@ func (m *persistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 }
 
 // Everyone roles their own key-value export: https://www.reddit.com/r/golang/comments/bw08dt/is_there_any_offline_database_viewer_and_editor
+// docker exec node4.consensus sh -c "cat /tmp/trees/val.json";
 func (m *persistenceModule) exportTrees(_ *debug.DebugMessage) error {
+	if err := os.Mkdir("/tmp/trees", os.ModePerm); err != nil {
+		return err
+	}
+
 	for treeType := merkleTree(0); treeType < numMerkleTrees; treeType++ {
 		smtValues := m.stateTrees.valueStores[treeType]
 		_, values, err := smtValues.GetAll(nil, true)
 		if err != nil {
 			return err
 		}
+
+		var sb strings.Builder
 		for i := 0; i < len(values); i++ {
 			vProto := merkleTreeToProtoSchema[treeType]()
 			// vProto := &types.Actor{}
@@ -64,9 +75,16 @@ func (m *persistenceModule) exportTrees(_ *debug.DebugMessage) error {
 				// if err := proto.Unmarshal(values[i], vProto); err != nil {
 				return err
 			}
-			fmt.Println(vProto)
+			sb.WriteString(protojson.Format(vProto))
+		}
+		f, err := os.Create("/tmp/trees/" + merkleTreeToString[treeType] + ".json")
+		if err != nil {
+			return err
 		}
+		f.Write([]byte(sb.String()))
+		f.Close()
 	}
+	fmt.Println("Wrote trees to /tmp/trees/")
 	return nil
 }
 
diff --git a/persistence/test/account_test.go b/persistence/test/account_test.go
index a1b0c3197..2e5825364 100644
--- a/persistence/test/account_test.go
+++ b/persistence/test/account_test.go
@@ -89,16 +89,11 @@ func FuzzAccountAmount(f *testing.F) {
 
 func TestDefaultNonExistentAccountAmount(t *testing.T) {
 	db := NewTestPostgresContext(t, 0)
-	fmt.Println("BEFORE TESTG")
 	addr, err := crypto.GenerateAddress()
 	require.NoError(t, err)
-	fmt.Println("BEFORE TESTG 2")
 	accountAmount, err := db.GetAccountAmount(addr, db.Height)
-	fmt.Println("BEFORE TESTG 3")
 	require.NoError(t, err)
-	fmt.Println("BEFORE TESTG 4")
 	require.Equal(t, "0", accountAmount)
-	fmt.Println("BEFORE TESTG 5")
 }
 
 func TestSetAccountAmount(t *testing.T) {
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index 73dbd23bf..d88c8f88e 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -38,12 +38,12 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 	// logic changes, these hashes will need to be updated based on the test output.
 	encodedAppHash := []string{
 		"5c2d66d8dae3e823f573fe62f403d492045c22191bc2610396e1a20fc6a19af4",
-		"1e736e8c94c899f9ac6544744a0f12d2ed29d4e611e7c088f14fc338499fb166",
-		"ce9bf6328228cd8caf138ddc440a8fd512af6a25542c9863562abeb5c793dd82",
+		// "1e736e8c94c899f9ac6544744a0f12d2ed29d4e611e7c088f14fc338499fb166",
+		// "ce9bf6328228cd8caf138ddc440a8fd512af6a25542c9863562abeb5c793dd82",
 	}
 
 	stakeAmount := initialStakeAmount
-	for i := 0; i < 3; i++ {
+	for i := 0; i < len(encodedAppHash); i++ {
 		// Get the context at the new height and retrieve one of the apps
 		height := int64(i + 1)
 		heightBz := heightToBytes(height)

From 0d22faadcf81dd8a85638f6e4944eb7db7f450b9 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 3 Nov 2022 20:30:40 -0700
Subject: [PATCH 113/227] Added tx indexer

---
 persistence/block.go                      | 14 +++++---
 persistence/debug.go                      |  2 +-
 persistence/indexer/indexer.go            |  2 +-
 persistence/proto/block_persistence.proto |  8 ++++-
 persistence/state.go                      | 43 ++++++++++++++++++-----
 persistence/test/state_test.go            |  6 ++--
 6 files changed, 56 insertions(+), 19 deletions(-)

diff --git a/persistence/block.go b/persistence/block.go
index aa1b42eec..32cc8b632 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -7,6 +7,7 @@ import (
 	"github.com/pokt-network/pocket/persistence/kvstore"
 	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/codec"
+	"github.com/pokt-network/pocket/shared/crypto"
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
@@ -74,14 +75,19 @@ func (p *PostgresContext) prepareBlock(proposerAddr []byte, quorumCert []byte) (
 		}
 	}
 
+	// The order (descending) is important here since it is used to comprise the hash in the block
 	txResults, err := p.txIndexer.GetByHeight(p.Height, false)
 	if err != nil {
 		return nil, err
 	}
 
-	txs := make([][]byte, len(txResults))
-	for i, txResult := range txResults {
-		txs[i] = txResult.GetTx()
+	txs := make([]byte, 0)
+	for _, txResult := range txResults {
+		txHash, err := txResult.Hash()
+		if err != nil {
+			return nil, err
+		}
+		txs = append(txs, txHash...)
 	}
 
 	block := &types.Block{
@@ -90,7 +96,7 @@ func (p *PostgresContext) prepareBlock(proposerAddr []byte, quorumCert []byte) (
 		PrevHash:          hex.EncodeToString(prevHash),
 		ProposerAddress:   proposerAddr,
 		QuorumCertificate: quorumCert,
-		Transactions:      txs,
+		TransactionsHash:  crypto.SHA3Hash(txs), // TODO: Externalize this elsewhere?
 	}
 
 	return block, nil
diff --git a/persistence/debug.go b/persistence/debug.go
index af010c2ef..9529720d9 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -50,7 +50,7 @@ func (m *persistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 	block := &types.Block{}
 	codec.Unmarshal(blockBytes, block)
 
-	log.Printf("Block at height %d with %d transactions: %+v \n", height, len(block.Transactions), block)
+	log.Printf("Block at height %d: %+v \n", height, block)
 }
 
 // Everyone roles their own key-value export: https://www.reddit.com/r/golang/comments/bw08dt/is_there_any_offline_database_viewer_and_editor
diff --git a/persistence/indexer/indexer.go b/persistence/indexer/indexer.go
index 527b8b747..95808fa7b 100644
--- a/persistence/indexer/indexer.go
+++ b/persistence/indexer/indexer.go
@@ -25,7 +25,7 @@ type TxIndexer interface {
 	// `GetByHash` returns the transaction specified by the hash if indexed or nil otherwise
 	GetByHash(hash []byte) (shared.TxResult, error)
 
-	// `GetByHeight` returns all transactions specified by height or nil if there are no transactions at that height
+	// `GetByHeight` returns all transactions specified by height or nil if there are no transactions at that height; may be ordered descending/ascending
 	GetByHeight(height int64, descending bool) ([]shared.TxResult, error)
 
 	// `GetBySender` returns all transactions signed by *sender*; may be ordered descending/ascending
diff --git a/persistence/proto/block_persistence.proto b/persistence/proto/block_persistence.proto
index 3fabb3170..9b2541249 100644
--- a/persistence/proto/block_persistence.proto
+++ b/persistence/proto/block_persistence.proto
@@ -9,5 +9,11 @@ message Block {
     string prevHash = 3;
     bytes proposerAddress = 4;
     bytes quorumCertificate = 5;
-    repeated bytes transactions = 6; // DISCUSS_IN_THIS_COMMIT: If we can save all the transactions here, why do we need a separate tx trie?
+    bytes transactionsHash = 6; // The has of all the translactions in the block
+}
+
+// DISUCSS: What else do we need here?
+message Transaction {
+    uint64 height = 1;
+    bytes tx = 2;
 }
\ No newline at end of file
diff --git a/persistence/state.go b/persistence/state.go
index 0833fc9b5..36d04c563 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -42,9 +42,10 @@ const (
 
 	// Data Merkle Trees
 	blocksMerkleTree
+	transactionsMerkleTree
+
 	paramsMerkleTree
 	flagsMerkleTree
-	// txMerkleTree ??
 
 	// Used for iteration purposes only; see https://stackoverflow.com/a/64178235/768439 as a reference
 	numMerkleTrees
@@ -59,7 +60,9 @@ var merkleTreeToString = map[merkleTree]string{
 	accountMerkleTree: "account",
 	poolMerkleTree:    "pool",
 
-	blocksMerkleTree: "blocks",
+	blocksMerkleTree:       "blocks",
+	transactionsMerkleTree: "transactions",
+
 	paramsMerkleTree: "params",
 	flagsMerkleTree:  "flags",
 }
@@ -94,9 +97,11 @@ var merkleTreeToProtoSchema = map[merkleTree]func() proto.Message{
 	accountMerkleTree: func() proto.Message { return &types.Account{} },
 	poolMerkleTree:    func() proto.Message { return &types.Account{} },
 
-	blocksMerkleTree: func() proto.Message { return &types.Block{} },
-	// paramsMerkleTree: func() proto.Message { return &types.Params{} },
-	// flagsMerkleTree:  func() proto.Message { return &types.Flags{} },
+	blocksMerkleTree:       func() proto.Message { return &types.Block{} },
+	transactionsMerkleTree: func() proto.Message { return &types.Transaction{} },
+
+	paramsMerkleTree: func() proto.Message { return &types.Params{} },
+	flagsMerkleTree:  func() proto.Message { return &types.Params{} },
 }
 
 func newStateTrees(treesStoreDir string) (*stateTrees, error) {
@@ -174,11 +179,16 @@ func (p *PostgresContext) updateStateHash() error {
 
 		// Data Merkle Trees
 		case blocksMerkleTree:
-			p.updateBlockTree(p.Height)
+			continue
+		case transactionsMerkleTree:
+			if err := p.updateTransactionsTree(p.Height); err != nil {
+				return err
+			}
+
 		case paramsMerkleTree:
-			// log.Printf("TODO: merkle tree not implemented yet. Merkle tree #{%v}\n", treeType)
+			// TODO: Implement paramsMerkleTree
 		case flagsMerkleTree:
-			// log.Printf("TODO: merkle tree not implemented yet. Merkle tree #{%v}\n", treeType)
+			// TODO: Implement flagsMerkleTree
 
 		// Default
 		default:
@@ -310,6 +320,21 @@ func (p *PostgresContext) updatePoolTrees(height int64) error {
 
 // Data Tree Helpers
 
-func (p *PostgresContext) updateBlockTree(height int64) {
+func (p *PostgresContext) updateTransactionsTree(height int64) error {
+	txResults, err := p.txIndexer.GetByHeight(p.Height, false)
+	if err != nil {
+		return err
+	}
 
+	for _, txResult := range txResults {
+		txHash, err := txResult.Hash()
+		if err != nil {
+			return err
+		}
+		if _, err := p.stateTrees.merkleTrees[transactionsMerkleTree].Update(txHash, txResult.GetTx()); err != nil {
+			return err
+		}
+	}
+
+	return nil
 }
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index d88c8f88e..466cc8947 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -37,7 +37,7 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 	// that the business logic doesn't change and that they remain deterministic. Anytime the business
 	// logic changes, these hashes will need to be updated based on the test output.
 	encodedAppHash := []string{
-		"5c2d66d8dae3e823f573fe62f403d492045c22191bc2610396e1a20fc6a19af4",
+		"a68dbbcddb69355f893000f9ba07dee1d9615cfd1c5db2a41296bff331b4e99d",
 		// "1e736e8c94c899f9ac6544744a0f12d2ed29d4e611e7c088f14fc338499fb166",
 		// "ce9bf6328228cd8caf138ddc440a8fd512af6a25542c9863562abeb5c793dd82",
 	}
@@ -96,8 +96,8 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 		var block types.Block
 		err = codec.GetCodec().Unmarshal(blockBz, &block)
 		require.NoError(t, err)
-		require.Len(t, block.Transactions, 1)
-		require.Equal(t, txResult.GetTx(), block.Transactions[0])
+		// require.Len(t, block.Transactions, 1)
+		// require.Equal(t, txResult.GetTx(), block.Transactions[0])
 		require.Equal(t, expectedAppHash, block.Hash) // verify block hash
 		if i > 0 {
 			require.Equal(t, encodedAppHash[i-1], block.PrevHash) // verify chain chain

From a6333d9ddaf4922ea6760cb6129ccb3be3bd6eeb Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 3 Nov 2022 20:46:42 -0700
Subject: [PATCH 114/227] Updated db_export_trees

---
 Makefile           | 6 ++++--
 app/client/main.go | 4 ++--
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/Makefile b/Makefile
index d04592e00..9663d54ec 100644
--- a/Makefile
+++ b/Makefile
@@ -172,10 +172,12 @@ db_show_schemas: docker_check
 db_admin:
 	echo "Open http://0.0.0.0:5050 and login with 'pgadmin4@pgadmin.org' and 'pgadmin4'.\n The password is 'postgres'"
 
+# IMPROVE: Make this part of the CLI
 .PHONY: db_export_trees
-## Helper to export the data in the merkle trees
+## Assuming `ExportTrees` was from the client, this will copy those json files locally from node1 to local
 db_export_trees:
-	echo "I'm not done yet"
+	echo "Copying trees from node1.consensus to /tmp/node1_trees"
+	docker cp node1.consensus:/tmp/trees /tmp/node1_trees
 
 .PHONY: docker_kill_all
 ## Kill all containers started by the docker-compose file
diff --git a/app/client/main.go b/app/client/main.go
index 1893e51f0..c15151b2b 100644
--- a/app/client/main.go
+++ b/app/client/main.go
@@ -27,7 +27,7 @@ const (
 	PromptTriggerNextView        string = "TriggerNextView (broadcast)"
 	PromptTogglePacemakerMode    string = "TogglePacemakerMode (broadcast)"
 	PromptShowLatestBlockInStore string = "ShowLatestBlockInStore (send)"
-	PromptExportTrees            string = "ExportTrees (send)"
+	PromptExportTrees            string = "ExportTrees (broadcast)"
 
 	defaultConfigPath  = "build/config/config1.json"
 	defaultGenesisPath = "build/config/genesis.json"
@@ -145,7 +145,7 @@ func handleSelect(selection string) {
 			Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_TREE_EXPORT,
 			Message: nil,
 		}
-		sendDebugMessage(m)
+		broadcastDebugMessage(m)
 	default:
 		log.Println("Selection not yet implemented...", selection)
 	}

From dbcb9807241438276a0c2db80f3d0c8684e5b15e Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 3 Nov 2022 20:48:44 -0700
Subject: [PATCH 115/227] Self review upto consensus/block.go

---
 consensus/block.go | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/consensus/block.go b/consensus/block.go
index 51453e813..fa1137ad3 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -14,10 +14,6 @@ func (m *consensusModule) commitBlock(block *typesCons.Block) error {
 	if err := m.utilityContext.Commit(block.BlockHeader.QuorumCertificate); err != nil {
 		return err
 	}
-	// TODO_IN_THIS_COMMIT: Should `Commit` implicitly release the context?
-	// if err := m.utilityContext.Release(); err != nil {
-	// 	return err
-	// }
 	m.utilityContext = nil
 
 	m.lastAppHash = block.BlockHeader.Hash

From 510824012d298915f1dbd6d5a9d9e3de822b0e0d Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sat, 5 Nov 2022 17:37:23 -0700
Subject: [PATCH 116/227] WIP

---
 Makefile                                      |  3 +--
 consensus/block.go                            |  6 +++--
 consensus/consensus_tests/utils_test.go       |  6 ++---
 consensus/hotstuff_leader.go                  |  5 ++--
 consensus/hotstuff_replica.go                 |  3 ++-
 persistence/block.go                          | 11 ++++----
 persistence/context.go                        | 11 +++-----
 persistence/db.go                             | 25 +++++++------------
 persistence/debug.go                          |  2 +-
 .../{AppHash.md => PROTOCOL_STATE_HASH.md}    |  0
 persistence/genesis.go                        |  2 +-
 persistence/module.go                         |  2 +-
 .../AppHash.md => PROTOCOL_STATE_HASH.md}     | 22 ++++++++++------
 shared/modules/persistence_module.go          | 16 ++++++------
 shared/modules/utility_module.go              | 17 +++++++------
 utility/context.go                            | 17 ++++---------
 utility/test/block_test.go                    |  2 +-
 17 files changed, 70 insertions(+), 80 deletions(-)
 rename persistence/docs/{AppHash.md => PROTOCOL_STATE_HASH.md} (100%)
 rename shared/docs/{flows/AppHash.md => PROTOCOL_STATE_HASH.md} (78%)

diff --git a/Makefile b/Makefile
index 8b1f98114..a5dd7cdb6 100644
--- a/Makefile
+++ b/Makefile
@@ -379,10 +379,9 @@ benchmark_p2p_addrbook:
 # CONSIDERATION - A comment that involves extra work but was thoughts / considered as part of some implementation
 # CONSOLIDATE   - We likely have similar implementations/types of the same thing, and we should consolidate them.
 # DEPRECATE     - Code that should be removed in the future
-# INTRODUCE     - Code that should be introduced in the future
 # DISCUSS_IN_THIS_COMMIT - SHOULD NEVER BE COMMITTED TO MASTER. It is a way for the reviewer of a PR to start / reply to a discussion.
 # TODO_IN_THIS_COMMIT    - SHOULD NEVER BE COMMITTED TO MASTER. It is a way to start the review process while non-critical changes are still in progress
-TODO_KEYWORDS = -e "TODO" -e "TECHDEBT" -e "IMPROVE" -e "DISCUSS" -e "INCOMPLETE" -e "INVESTIGATE" -e "CLEANUP" -e "HACK" -e "REFACTOR" -e "CONSIDERATION" -e "TODO_IN_THIS_COMMIT" -e "DISCUSS_IN_THIS_COMMIT" -e "CONSOLIDATE" -e "DEPRECATE" -e "INTRODUCE"
+TODO_KEYWORDS = -e "TODO" -e "TECHDEBT" -e "IMPROVE" -e "DISCUSS" -e "INCOMPLETE" -e "INVESTIGATE" -e "CLEANUP" -e "HACK" -e "REFACTOR" -e "CONSIDERATION" -e "TODO_IN_THIS_COMMIT" -e "DISCUSS_IN_THIS_COMMIT" -e "CONSOLIDATE" -e "DEPRECATE"
 
 # How do I use TODOs?
 # 1. <KEYWORD>: <Description of follow up work>;
diff --git a/consensus/block.go b/consensus/block.go
index ee3eb259a..420b85ae4 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -11,11 +11,13 @@ func (m *consensusModule) commitBlock(block *typesCons.Block) error {
 	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
 
 	// Commit and release the context
-	if err := m.utilityContext.CommitPersistenceContext(); err != nil {
+	if err := m.utilityContext.Commit(block.BlockHeader.QuorumCertificate); err != nil {
 		return err
 	}
 
-	m.utilityContext.ReleaseContext()
+	if err := m.utilityContext.Release(); err != nil {
+		return err
+	}
 	m.utilityContext = nil
 
 	return nil
diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 551f03ddd..2ae0ed444 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -359,7 +359,7 @@ func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 	ctrl := gomock.NewController(t)
 	utilityContextMock := modulesMock.NewMockUtilityContext(ctrl)
 	persistenceContextMock := modulesMock.NewMockPersistenceRWContext(ctrl)
-	persistenceContextMock.EXPECT().SetProposalBlock(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+	persistenceContextMock.EXPECT().SetProposalBlock(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
 	persistenceContextMock.EXPECT().GetPrevAppHash().Return("", nil).AnyTimes()
 
 	utilityContextMock.EXPECT().
@@ -370,8 +370,8 @@ func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 		ApplyBlock().
 		Return(appHash, nil).
 		AnyTimes()
-	utilityContextMock.EXPECT().CommitPersistenceContext().Return(nil).AnyTimes()
-	utilityContextMock.EXPECT().ReleaseContext().Return().AnyTimes()
+	utilityContextMock.EXPECT().Commit(nil).Return(nil).AnyTimes()
+	utilityContextMock.EXPECT().Release().Return(nil).AnyTimes()
 	utilityContextMock.EXPECT().GetPersistenceContext().Return(persistenceContextMock).AnyTimes()
 
 	persistenceContextMock.EXPECT().IndexTransactions().Return(nil).AnyTimes()
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 9a67a6138..16bc9a306 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -2,9 +2,10 @@ package consensus
 
 import (
 	"encoding/hex"
-	"github.com/pokt-network/pocket/shared/codec"
 	"unsafe"
 
+	"github.com/pokt-network/pocket/shared/codec"
+
 	consensusTelemetry "github.com/pokt-network/pocket/consensus/telemetry"
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 )
@@ -376,7 +377,7 @@ func (m *consensusModule) prepareAndApplyBlock() (*typesCons.Block, error) {
 	}
 
 	// Set the proposal block in the persistence context
-	if err = persistenceContext.SetProposalBlock(blockHeader.Hash, blockProtoBz, blockHeader.ProposerAddress, blockHeader.QuorumCertificate, block.Transactions); err != nil {
+	if err = persistenceContext.SetProposalBlock(blockHeader.Hash, blockProtoBz, blockHeader.ProposerAddress, block.Transactions); err != nil {
 		return nil, err
 	}
 
diff --git a/consensus/hotstuff_replica.go b/consensus/hotstuff_replica.go
index 73f783a3d..0f57c88d8 100644
--- a/consensus/hotstuff_replica.go
+++ b/consensus/hotstuff_replica.go
@@ -3,6 +3,7 @@ package consensus
 import (
 	"encoding/hex"
 	"fmt"
+
 	consensusTelemetry "github.com/pokt-network/pocket/consensus/telemetry"
 	"github.com/pokt-network/pocket/consensus/types"
 	typesCons "github.com/pokt-network/pocket/consensus/types"
@@ -232,7 +233,7 @@ func (m *consensusModule) applyBlock(block *typesCons.Block) error {
 	}
 	persistenceContext := m.utilityContext.GetPersistenceContext()
 	// Set the proposal block in the persistence context
-	if err = persistenceContext.SetProposalBlock(block.BlockHeader.Hash, blockProtoBz, block.BlockHeader.ProposerAddress, block.BlockHeader.QuorumCertificate, block.Transactions); err != nil {
+	if err = persistenceContext.SetProposalBlock(block.BlockHeader.Hash, blockProtoBz, block.BlockHeader.ProposerAddress, block.Transactions); err != nil {
 		return err
 	}
 
diff --git a/persistence/block.go b/persistence/block.go
index af8cb1eb5..317375687 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -4,6 +4,7 @@ import (
 	"encoding/binary"
 	"encoding/hex"
 	"fmt"
+
 	"github.com/pokt-network/pocket/persistence/kvstore"
 	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
@@ -52,8 +53,7 @@ func (p PostgresContext) GetPrevAppHash() (string, error) {
 	if err != nil {
 		return "", fmt.Errorf("error getting block hash for height %d even though it's in the database: %s", height, err)
 	}
-	// IMPROVE/CLEANUP(#284): returning the whole protoblock - should just return hash
-	return hex.EncodeToString(block), nil
+	return hex.EncodeToString(block), nil // TODO(#284): Return `block.Hash` instead of the hex encoded representation of the blockBz
 }
 
 func (p PostgresContext) GetTxResults() []modules.TxResult {
@@ -89,11 +89,10 @@ func (p PostgresContext) IndexTransactions() error {
 // DISCUSS: this might be retrieved from the block store - temporarily we will access it directly from the module
 //       following the pattern of the Consensus Module prior to pocket/issue-#315
 // TODO(#284): Remove blockProtoBytes from the interface
-func (p *PostgresContext) SetProposalBlock(blockHash string, blockProtoBytes, proposerAddr, qc []byte, transactions [][]byte) error {
+func (p *PostgresContext) SetProposalBlock(blockHash string, blockProtoBytes, proposerAddr []byte, transactions [][]byte) error {
 	p.blockHash = blockHash
 	p.blockProtoBytes = blockProtoBytes
 	p.proposerAddr = proposerAddr
-	p.quorumCertificate = qc
 	p.blockTxs = transactions
 	return nil
 }
@@ -102,7 +101,7 @@ func (p *PostgresContext) SetProposalBlock(blockHash string, blockProtoBytes, pr
 //                 until we include the schema as part of the SQL Store because persistence
 //                 currently has no access to the protobuf schema which is the source of truth.
 // TODO: atomic operations needed here - inherited pattern from consensus module
-func (p PostgresContext) StoreBlock() error {
+func (p PostgresContext) StoreBlock(quorumCert []byte) error {
 	if p.blockProtoBytes == nil {
 		// IMPROVE/CLEANUP: HACK - currently tests call Commit() on the same height and it throws a
 		// ERROR: duplicate key value violates unique constraint "block_pkey", because it attempts to
@@ -117,7 +116,7 @@ func (p PostgresContext) StoreBlock() error {
 		return err
 	}
 	// Store in SQL Store
-	if err := p.InsertBlock(uint64(p.Height), p.blockHash, p.proposerAddr, p.quorumCertificate); err != nil {
+	if err := p.InsertBlock(uint64(p.Height), p.blockHash, p.proposerAddr, quorumCert); err != nil {
 		return err
 	}
 	// Store transactions in indexer
diff --git a/persistence/context.go b/persistence/context.go
index 5e4a4e347..b8c79b6ef 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -6,13 +6,9 @@ import (
 )
 
 func (p PostgresContext) UpdateAppHash() ([]byte, error) {
-	panic("INTRODUCE(#284): Add this function in #284 per the interface changes in #252.")
+	panic("TODO(#284): Implement this function.")
 }
 
-// func (p PostgresContext) Commit(proposerAddr []byte, quorumCert []byte) error {
-// 	panic("INTRODUCE(#284): Add this function in #284 per the interface changes in #252.")
-// }
-
 func (p PostgresContext) NewSavePoint(bytes []byte) error {
 	log.Println("TODO: NewSavePoint not implemented")
 	return nil
@@ -31,21 +27,20 @@ func (p PostgresContext) AppHash() ([]byte, error) {
 func (p *PostgresContext) Reset() error {
 	p.txResults = nil
 	p.blockHash = ""
-	p.quorumCertificate = nil
 	p.proposerAddr = nil
 	p.blockProtoBytes = nil
 	p.blockTxs = nil
 	return nil
 }
 
-func (p PostgresContext) Commit() error {
+func (p PostgresContext) Commit(quorumCert []byte) error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
 	ctx := context.TODO()
 	if err := p.GetTx().Commit(context.TODO()); err != nil {
 		return err
 	}
-	if err := p.StoreBlock(); err != nil {
+	if err := p.StoreBlock(quorumCert); err != nil {
 		return err
 	}
 	if err := p.conn.Close(ctx); err != nil {
diff --git a/persistence/db.go b/persistence/db.go
index db102c6ed..e4f61f5f3 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -4,9 +4,10 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"github.com/pokt-network/pocket/persistence/indexer"
 	"log"
 
+	"github.com/pokt-network/pocket/persistence/indexer"
+
 	"github.com/pokt-network/pocket/persistence/types"
 
 	"github.com/jackc/pgconn"
@@ -44,21 +45,12 @@ type PostgresContext struct {
 	blockstore kvstore.KVStore
 	txIndexer  indexer.TxIndexer
 	// DISCUSS(#284): this might be retrieved from the block store - temporarily we will access it directly from the module
-	//       following the pattern of the Consensus Module prior to pocket/issue-#315
-	quorumCertificate []byte
-	proposerAddr      []byte
-	blockProtoBytes   []byte
-	blockHash         string
-	blockTxs          [][]byte
-	txResults         []modules.TxResult
-}
-
-func (p PostgresContext) LatestQC() []byte {
-	return p.quorumCertificate
-}
-
-func (p PostgresContext) SetLatestQC(latestQC []byte) {
-	p.quorumCertificate = latestQC
+	//                following the pattern of the Consensus Module prior to pocket/issue-#315
+	proposerAddr    []byte
+	blockProtoBytes []byte
+	blockHash       string
+	blockTxs        [][]byte
+	txResults       []modules.TxResult
 }
 
 func (pg *PostgresContext) GetCtxAndTx() (context.Context, pgx.Tx, error) {
@@ -94,6 +86,7 @@ func (pg *PostgresContext) ResetContext() error {
 	return nil
 }
 
+// TODO: Remove `Latest` from these Setter & Getter methods
 func (p PostgresContext) GetLatestProposerAddr() []byte {
 	return p.proposerAddr
 }
diff --git a/persistence/debug.go b/persistence/debug.go
index 51cf8939c..5a964ac1f 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -41,7 +41,7 @@ func (m *persistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 
 func (m *persistenceModule) clearState(_ *debug.DebugMessage) {
 	context, err := m.NewRWContext(-1)
-	defer context.Commit()
+	defer context.Commit(nil)
 	if err != nil {
 		log.Printf("Error creating new context: %s \n", err)
 		return
diff --git a/persistence/docs/AppHash.md b/persistence/docs/PROTOCOL_STATE_HASH.md
similarity index 100%
rename from persistence/docs/AppHash.md
rename to persistence/docs/PROTOCOL_STATE_HASH.md
diff --git a/persistence/genesis.go b/persistence/genesis.go
index 876fd33fb..37c03455b 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -150,7 +150,7 @@ func (m *persistenceModule) populateGenesisState(state modules.PersistenceGenesi
 		log.Fatalf("an error occurred initializing flags: %s", err.Error())
 	}
 
-	if err = rwContext.Commit(); err != nil {
+	if err = rwContext.Commit([]byte("TODO(#284): Genesis QC")); err != nil {
 		log.Fatalf("an error occurred during commit() on genesis state %s ", err.Error())
 	}
 }
diff --git a/persistence/module.go b/persistence/module.go
index aa16dd590..4cfd4c20a 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -191,7 +191,7 @@ func (m *persistenceModule) NewReadContext(height int64) (modules.PersistenceRea
 }
 
 func (m *persistenceModule) ReleaseWriteContext() error {
-	panic("INTRODUCE(#284): Add this function in #284 per the interface changes in #252.")
+	panic("TODO(#284): Implement proper write context release.")
 }
 
 func (m *persistenceModule) GetBlockStore() kvstore.KVStore {
diff --git a/shared/docs/flows/AppHash.md b/shared/docs/PROTOCOL_STATE_HASH.md
similarity index 78%
rename from shared/docs/flows/AppHash.md
rename to shared/docs/PROTOCOL_STATE_HASH.md
index b5598a339..1abf166d8 100644
--- a/shared/docs/flows/AppHash.md
+++ b/shared/docs/PROTOCOL_STATE_HASH.md
@@ -1,14 +1,22 @@
-# AppHash <!-- omit in toc -->
+# State Hash <!-- omit in toc -->
 
-- [Context Initialization](#context-initialization)
+- [1.Context Management](#1context-management)
 - [Block Application](#block-application)
 - [Block Commit](#block-commit)
 
 <!-- See if there's an answer in this question to add links to notes: https://stackoverflow.com/questions/74103729/adding-hyperlinks-to-notes-in-mermaid-sequence-diagrams -->
 
-## Context Initialization
+Describes of the cross-module communication using the interfaces in [shared/modules](../shared/modules) to compute a new state hash.
 
-This flow shows the process of context initialization between all the modules required to apply a block and compute a state hash during the consensus lifecycle.
+See module specific documentation & implementation details inside each module respecively.their respective modules.
+
+_NOTE: The diagrams below use some [Hotstuff specific](https://arxiv.org/abs/1803.05069) terminology as described in the [HotPOKT Consensus Specification](https://github.com/pokt-network/pocket-network-protocol/tree/main/consensus) but can be adapted to other BFT protocols as well._
+
+NOTE:
+
+## 1.Context Management
+
+The `Utility` and `Persistence` modules maintain **ephemeral states** driven by the `Consensus` module that can be released & reverted as a result of various (e.g. lack of Validator consensus) before the state is committed and persisted to disk (i.e. the block is finalized).
 
 The `Hotstuff lifecycle` part refers to the so-called `PreCommit` and `Commit` phases of the protocol.
 
@@ -20,8 +28,8 @@ sequenceDiagram
     participant P as Persistence
     participant P2P as P2P
 
-    N-->>C: HandleMessage(anypb.Any)
-    critical NewRound Message
+    N-->>C: HandleMessage(msg)
+    critical NewRound
         C->>+U: NewContext(height)
         U->>+P: NewRWContext(height)
         P->>-U: PersistenceRWContext
@@ -108,7 +116,7 @@ sequenceDiagram
 
     %% Commit Context
     C->>+U: CommitContext(quorumCert)
-    U->>+P: Commit(proposerAddr, quorumCert)
+    U->>+P: Commit(quorumCert)
     P->>P: See 'Store Block'
     P->>-U: result, err_code
     U->>+P: Release()
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index cb62529a8..2f0351a7a 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -3,7 +3,7 @@ package modules
 //go:generate mockgen -source=$GOFILE -destination=./mocks/persistence_module_mock.go -aux_files=github.com/pokt-network/pocket/shared/modules=module.go
 
 import (
-	"github.com/pokt-network/pocket/persistence/kvstore" // Should be moved to shared
+	"github.com/pokt-network/pocket/persistence/kvstore"
 	"github.com/pokt-network/pocket/shared/debug"
 )
 
@@ -12,13 +12,12 @@ type PersistenceModule interface {
 	ConfigurableModule
 	GenesisDependentModule
 
-	// Context interface
+	// Context operations
 	NewRWContext(height int64) (PersistenceRWContext, error)
 	NewReadContext(height int64) (PersistenceReadContext, error)
 	ReleaseWriteContext() error // Only one write context can exist at a time
 
-	// BlockStore interface
-	// ResetContext() error // DEPRECATE(#252): Remove in #284 per the interface changes in #252
+	// BlockStore operations
 	GetBlockStore() kvstore.KVStore
 	NewWriteContext() PersistenceRWContext
 
@@ -56,22 +55,21 @@ type PersistenceWriteContext interface {
 	UpdateAppHash() ([]byte, error)
 
 	// Commits the current context (height, hash, transactions, etc...) to finality.
-	// Commit(proposerAddr []byte, quorumCert []byte) error // INTRODUCE(#284): Add this function in #284 per the interface changes in #252.
+	Commit(quorumCert []byte) error
 
 	// Indexer Operations
 	IndexTransactions() error
 
 	// Block Operations
 	SetLatestTxResults(txResults []TxResult)
-	// TODO_IN_THIS_COMMIT: Remove `blockProtoBytes` in this commit
-	SetProposalBlock(blockHash string, blockProtoBytes, proposerAddr, qc []byte, transactions [][]byte) error
-	StoreBlock() error // Store the block into persistence
+	SetProposalBlock(blockHash string, blockProtoBytes, proposerAddr []byte, transactions [][]byte) error // TODO(#284): Remove `blockProtoBytes`
+	StoreBlock() error                                                                                    // Store the block into persistence
 
 	// Pool Operations
 	AddPoolAmount(name string, amount string) error
 	SubtractPoolAmount(name string, amount string) error
 	SetPoolAmount(name string, amount string) error
-	InsertPool(name string, address []byte, amount string) error // TODO (Andrew) remove address from pool #149
+	InsertPool(name string, address []byte, amount string) error // TODO(#149): remove address from pool
 
 	// Account Operations
 	AddAccountAmount(address []byte, amount string) error
diff --git a/shared/modules/utility_module.go b/shared/modules/utility_module.go
index 7d4f73966..7bb143af9 100644
--- a/shared/modules/utility_module.go
+++ b/shared/modules/utility_module.go
@@ -15,20 +15,21 @@ type UtilityModule interface {
 // operations.
 type UtilityContext interface {
 	// Block operations
-	// Reaps the mempool for transactions that are ready to be proposed in a new block
+
+	// Reaps the mempool for transactions to be proposed in a new block, and applies them to this
+	// context; intended to be used by the block proposer.
 	CreateAndApplyProposalBlock(proposer []byte, maxTransactionBytes int) (appHash []byte, transactions [][]byte, err error)
-	// Applies the transactions to an ephemeral state in the utility & underlying persistence context; similar to `SafeNode` in the Hotstuff whitepaper.
+	// Applies the transactions in the local state to the current context; intended to be used by
+	// the block verifiers (i.e. non proposers)..
 	ApplyBlock() (appHash []byte, err error)
 
 	// Context operations
-	Release() error                 // INTRODUCE(#284): Add in #284 per the interface changes in #252.
-	Commit(quorumCert []byte) error // INTRODUCE(#284): Add in #284 per the interface changes in #252.
-
-	ReleaseContext()                             // DEPRECATE(#252): Remove in #284 per the interface changes in #252
-	GetPersistenceContext() PersistenceRWContext // DEPRECATE(#252): Remove in #284 per the interface changes in #252
-	CommitPersistenceContext() error             // DEPRECATE(#252): Remove in #284 per the interface changes in #252
+	Release() error                 // Releases the utility context and any underlying contexts it references
+	Commit(quorumCert []byte) error // State commitment of the current context
+	GetPersistenceContext() PersistenceRWContext
 
 	// Validation operations
+
 	CheckTransaction(tx []byte) error
 }
 
diff --git a/utility/context.go b/utility/context.go
index 547426281..f6b2909b1 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -44,21 +44,14 @@ func (u *UtilityContext) GetPersistenceContext() modules.PersistenceRWContext {
 	return u.Context.PersistenceRWContext
 }
 
-func (u *UtilityContext) CommitPersistenceContext() error {
-	return u.Context.PersistenceRWContext.Commit()
-}
-
-func (u *UtilityContext) ReleaseContext() {
-	u.Context.Release()
-	u.Context = nil
+func (u *UtilityContext) Commit(quorumCert []byte) error {
+	return u.Context.PersistenceRWContext.Commit(quorumCert)
 }
 
 func (u *UtilityContext) Release() error {
-	panic("INTRODUCE(#284): Add in #284 per the interface changes in #252.")
-}
-
-func (u *UtilityContext) Commit(quorumCert []byte) error {
-	panic("INTRODUCE(#284): Add in #284 per the interface changes in #252.")
+	err := u.Context.Release()
+	u.Context = nil
+	return err
 }
 
 func (u *UtilityContext) GetLatestBlockHeight() (int64, typesUtil.Error) {
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index cf6529f80..0d009d904 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -24,7 +24,7 @@ func TestUtilityContext_ApplyBlock(t *testing.T) {
 	require.NoError(t, er)
 	proposerBeforeBalance, err := ctx.GetAccountAmount(addrBz)
 	require.NoError(t, err)
-	er = ctx.GetPersistenceContext().SetProposalBlock("", nil, addrBz, nil, [][]byte{txBz})
+	er = ctx.GetPersistenceContext().SetProposalBlock("", nil, addrBz, [][]byte{txBz})
 	require.NoError(t, er)
 	// apply block
 	_, er = ctx.ApplyBlock()

From 4152c145d45470adeea6d3eecdbb98c47a29d505 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sat, 5 Nov 2022 17:54:39 -0700
Subject: [PATCH 117/227] Unit tests passing

---
 consensus/block.go                      | 4 +++-
 consensus/consensus_tests/utils_test.go | 4 ++--
 persistence/context.go                  | 2 +-
 persistence/db.go                       | 7 +++++--
 persistence/test/module_test.go         | 2 +-
 shared/modules/persistence_module.go    | 8 +++-----
 utility/block.go                        | 5 +++--
 utility/context.go                      | 2 +-
 utility/test/block_test.go              | 6 +++---
 9 files changed, 22 insertions(+), 18 deletions(-)

diff --git a/consensus/block.go b/consensus/block.go
index 420b85ae4..b7c338b54 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -57,7 +57,9 @@ func (m *consensusModule) refreshUtilityContext() error {
 	// Ideally, this should not be called.
 	if m.utilityContext != nil {
 		m.nodeLog(typesCons.NilUtilityContextWarning)
-		m.utilityContext.ReleaseContext()
+		if err := m.utilityContext.Release(); err != nil {
+			log.Printf("[ERROR] Error releasing utility context: %v\n", err)
+		}
 		m.utilityContext = nil
 	}
 
diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 2ae0ed444..051133afa 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -370,12 +370,12 @@ func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 		ApplyBlock().
 		Return(appHash, nil).
 		AnyTimes()
-	utilityContextMock.EXPECT().Commit(nil).Return(nil).AnyTimes()
+	utilityContextMock.EXPECT().Commit(gomock.Any()).Return(nil).AnyTimes()
 	utilityContextMock.EXPECT().Release().Return(nil).AnyTimes()
 	utilityContextMock.EXPECT().GetPersistenceContext().Return(persistenceContextMock).AnyTimes()
 
 	persistenceContextMock.EXPECT().IndexTransactions().Return(nil).AnyTimes()
-	persistenceContextMock.EXPECT().StoreBlock().Return(nil).AnyTimes()
+	persistenceContextMock.EXPECT().StoreBlock(gomock.Any()).Return(nil).AnyTimes()
 
 	return utilityContextMock
 }
diff --git a/persistence/context.go b/persistence/context.go
index b8c79b6ef..9796d7849 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -6,7 +6,7 @@ import (
 )
 
 func (p PostgresContext) UpdateAppHash() ([]byte, error) {
-	panic("TODO(#284): Implement this function.")
+	return []byte("TODO(#284): Implement this function."), nil
 }
 
 func (p PostgresContext) NewSavePoint(bytes []byte) error {
diff --git a/persistence/db.go b/persistence/db.go
index e4f61f5f3..7ddddfe71 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -50,7 +50,7 @@ type PostgresContext struct {
 	blockProtoBytes []byte
 	blockHash       string
 	blockTxs        [][]byte
-	txResults       []modules.TxResult
+	txResults       []modules.TxResult // DISCUSS_IN_THIS_COMMIT: Can this be removed and retrieved from `txIndexer` using `height`?
 }
 
 func (pg *PostgresContext) GetCtxAndTx() (context.Context, pgx.Tx, error) {
@@ -86,7 +86,10 @@ func (pg *PostgresContext) ResetContext() error {
 	return nil
 }
 
-// TODO: Remove `Latest` from these Setter & Getter methods
+// DISCUSS_IN_THIS_COMMIT:
+// 1. Can we remove `Latest` from these Setter & Getter methods
+// 2. Can we scope that to this package?
+// 3. Is `context.go` more appropriate for these than `db.go`?
 func (p PostgresContext) GetLatestProposerAddr() []byte {
 	return p.proposerAddr
 }
diff --git a/persistence/test/module_test.go b/persistence/test/module_test.go
index 040612eff..a0c54c45e 100644
--- a/persistence/test/module_test.go
+++ b/persistence/test/module_test.go
@@ -20,7 +20,7 @@ func TestPersistenceContextParallelReadWrite(t *testing.T) {
 	context, err := testPersistenceMod.NewRWContext(0)
 	require.NoError(t, err)
 	require.NoError(t, context.InsertPool(poolName, poolAddress, originalAmount))
-	require.NoError(t, context.Commit())
+	require.NoError(t, context.Commit(nil))
 
 	// verify the insert in the previously committed context worked
 	contextA, err := testPersistenceMod.NewRWContext(0)
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index 2f0351a7a..1e2eea252 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -51,9 +51,6 @@ type PersistenceWriteContext interface {
 	RollbackToSavePoint([]byte) error
 	Release() error
 
-	// Block / indexer operations
-	UpdateAppHash() ([]byte, error)
-
 	// Commits the current context (height, hash, transactions, etc...) to finality.
 	Commit(quorumCert []byte) error
 
@@ -61,9 +58,10 @@ type PersistenceWriteContext interface {
 	IndexTransactions() error
 
 	// Block Operations
-	SetLatestTxResults(txResults []TxResult)
+	SetLatestTxResults(txResults []TxResult)                                                              // DISCUSS_IN_THIS_COMMIT: Can we remove `TxResult` from the public facing interface given that we set transactions in `SetProposalBlock`?
 	SetProposalBlock(blockHash string, blockProtoBytes, proposerAddr []byte, transactions [][]byte) error // TODO(#284): Remove `blockProtoBytes`
-	StoreBlock() error                                                                                    // Store the block into persistence
+	StoreBlock(quorumCert []byte) error                                                                   // Store the block into persistence
+	UpdateAppHash() ([]byte, error)
 
 	// Pool Operations
 	AddPoolAmount(name string, amount string) error
diff --git a/utility/block.go b/utility/block.go
index 8cea2d508..f4954e219 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -1,9 +1,10 @@
 package utility
 
 import (
+	"math/big"
+
 	"github.com/pokt-network/pocket/shared/modules"
 	typesUtil "github.com/pokt-network/pocket/utility/types"
-	"math/big"
 )
 
 /*
@@ -144,7 +145,7 @@ func (u *UtilityContext) EndBlock(proposer []byte) typesUtil.Error {
 
 func (u *UtilityContext) GetAppHash() ([]byte, typesUtil.Error) {
 	// Get the root hash of the merkle state tree for state consensus integrity
-	appHash, er := u.Context.AppHash()
+	appHash, er := u.Context.UpdateAppHash()
 	if er != nil {
 		return nil, typesUtil.ErrAppHash(er)
 	}
diff --git a/utility/context.go b/utility/context.go
index f6b2909b1..b0dfb47c2 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -103,7 +103,7 @@ func (u *UtilityContext) NewSavePoint(transactionHash []byte) typesUtil.Error {
 }
 
 func (c *Context) Reset() typesUtil.Error {
-	if err := c.PersistenceRWContext.Reset(); err != nil {
+	if err := c.PersistenceRWContext.Release(); err != nil {
 		return typesUtil.ErrResetContext(err)
 	}
 	return nil
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index 0d009d904..4c7d6a67a 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -72,7 +72,7 @@ func TestUtilityContext_BeginBlock(t *testing.T) {
 	require.NoError(t, err)
 	addrBz, er := hex.DecodeString(proposer.GetAddress())
 	require.NoError(t, er)
-	er = ctx.GetPersistenceContext().SetProposalBlock("", nil, addrBz, nil, [][]byte{txBz})
+	er = ctx.GetPersistenceContext().SetProposalBlock("", nil, addrBz, [][]byte{txBz})
 	require.NoError(t, er)
 	// apply block
 	_, er = ctx.ApplyBlock()
@@ -133,7 +133,7 @@ func TestUtilityContext_EndBlock(t *testing.T) {
 	require.NoError(t, er)
 	proposerBeforeBalance, err := ctx.GetAccountAmount(addrBz)
 	require.NoError(t, err)
-	er = ctx.GetPersistenceContext().SetProposalBlock("", nil, addrBz, nil, [][]byte{txBz})
+	er = ctx.GetPersistenceContext().SetProposalBlock("", nil, addrBz, [][]byte{txBz})
 	require.NoError(t, er)
 	// apply block
 	_, er = ctx.ApplyBlock()
@@ -165,7 +165,7 @@ func TestUtilityContext_GetAppHash(t *testing.T) {
 	appHashTest, err := ctx.GetAppHash()
 	require.NoError(t, err)
 
-	appHashSource, er := ctx.Context.AppHash()
+	appHashSource, er := ctx.Context.UpdateAppHash()
 	require.NoError(t, er)
 	require.Equal(t, appHashTest, appHashSource, "unexpected appHash")
 

From 6e0259ee8dabd4e46186bc41250594a035286164 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sat, 5 Nov 2022 19:53:52 -0700
Subject: [PATCH 118/227] Updated some comments

---
 shared/modules/persistence_module.go | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index 1e2eea252..e4617b9a5 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -39,11 +39,12 @@ type PersistenceRWContext interface {
 	PersistenceWriteContext
 }
 
-// TODO (andrew) convert address and public key to string not bytes #149
-// TODO: Simplify the interface (reference - https://dave.cheney.net/practical-go/presentations/gophercon-israel.html#_prefer_single_method_interfaces)
+// REFACTOR: Simplify the interface
 // - Add general purpose methods such as `ActorOperation(enum_actor_type, ...)` which can be use like so: `Insert(FISHERMAN, ...)`
 // - Use general purpose parameter methods such as `Set(enum_gov_type, ...)` such as `Set(STAKING_ADJUSTMENT, ...)`
+// - Reference: https://dave.cheney.net/practical-go/presentations/gophercon-israel.html#_prefer_single_method_interfaces
 
+// TOD (#149): convert address and public key to string from bytes
 // NOTE: There's not really a use case for a write only interface, but it abstracts and contrasts nicely against the read only context
 type PersistenceWriteContext interface {
 	// Context Operations
@@ -58,9 +59,12 @@ type PersistenceWriteContext interface {
 	IndexTransactions() error
 
 	// Block Operations
-	SetLatestTxResults(txResults []TxResult)                                                              // DISCUSS_IN_THIS_COMMIT: Can we remove `TxResult` from the public facing interface given that we set transactions in `SetProposalBlock`?
-	SetProposalBlock(blockHash string, blockProtoBytes, proposerAddr []byte, transactions [][]byte) error // TODO(#284): Remove `blockProtoBytes`
-	StoreBlock(quorumCert []byte) error                                                                   // Store the block into persistence
+	// DISCUSS_IN_THIS_COMMIT: Can we remove `TxResult` from the public facing interface given that we set transactions in `SetProposalBlock`?
+	SetLatestTxResults(txResults []TxResult)
+	// TODO(#284): Remove `blockProtoBytes`
+	SetProposalBlock(blockHash string, blockProtoBytes, proposerAddr []byte, transactions [][]byte) error
+	// Store the block into persistence
+	StoreBlock(quorumCert []byte) error
 	UpdateAppHash() ([]byte, error)
 
 	// Pool Operations

From 51e7ebee71927d735c9fe93178e53b350a66f3a4 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sun, 6 Nov 2022 13:05:03 -0800
Subject: [PATCH 119/227] Update most of the external interfaces

---
 consensus/consensus_tests/utils_test.go |   3 -
 consensus/helpers.go                    |   1 +
 persistence/block.go                    |   6 +-
 persistence/context.go                  |   2 +-
 shared/docs/PROTOCOL_STATE_HASH.md      | 200 ++++++++++++++----------
 shared/modules/persistence_module.go    |   6 +-
 6 files changed, 127 insertions(+), 91 deletions(-)

diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 051133afa..30b7d0625 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -374,9 +374,6 @@ func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 	utilityContextMock.EXPECT().Release().Return(nil).AnyTimes()
 	utilityContextMock.EXPECT().GetPersistenceContext().Return(persistenceContextMock).AnyTimes()
 
-	persistenceContextMock.EXPECT().IndexTransactions().Return(nil).AnyTimes()
-	persistenceContextMock.EXPECT().StoreBlock(gomock.Any()).Return(nil).AnyTimes()
-
 	return utilityContextMock
 }
 
diff --git a/consensus/helpers.go b/consensus/helpers.go
index a04a53a5d..883d826c4 100644
--- a/consensus/helpers.go
+++ b/consensus/helpers.go
@@ -83,6 +83,7 @@ func (m *consensusModule) findHighQC(msgs []*typesCons.HotstuffMessage) (qc *typ
 		if m.GetQuorumCertificate() == nil {
 			continue
 		}
+		// TODO: Make sure to validate the "highest QC" first and add tests
 		if qc == nil || m.GetQuorumCertificate().Height > qc.Height {
 			qc = m.GetQuorumCertificate()
 		}
diff --git a/persistence/block.go b/persistence/block.go
index 317375687..3a0d9d585 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -76,7 +76,7 @@ func (p PostgresContext) TransactionExists(transactionHash string) (bool, error)
 	return true, err
 }
 
-func (p PostgresContext) IndexTransactions() error {
+func (p PostgresContext) indexTransactions() error {
 	// TODO: store in batch
 	for _, txResult := range p.GetLatestTxResults() {
 		if err := p.txIndexer.Index(txResult); err != nil {
@@ -101,7 +101,7 @@ func (p *PostgresContext) SetProposalBlock(blockHash string, blockProtoBytes, pr
 //                 until we include the schema as part of the SQL Store because persistence
 //                 currently has no access to the protobuf schema which is the source of truth.
 // TODO: atomic operations needed here - inherited pattern from consensus module
-func (p PostgresContext) StoreBlock(quorumCert []byte) error {
+func (p PostgresContext) storeBlock(quorumCert []byte) error {
 	if p.blockProtoBytes == nil {
 		// IMPROVE/CLEANUP: HACK - currently tests call Commit() on the same height and it throws a
 		// ERROR: duplicate key value violates unique constraint "block_pkey", because it attempts to
@@ -120,7 +120,7 @@ func (p PostgresContext) StoreBlock(quorumCert []byte) error {
 		return err
 	}
 	// Store transactions in indexer
-	return p.IndexTransactions()
+	return p.indexTransactions()
 }
 
 func (p PostgresContext) InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error {
diff --git a/persistence/context.go b/persistence/context.go
index 9796d7849..499cfebed 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -40,7 +40,7 @@ func (p PostgresContext) Commit(quorumCert []byte) error {
 	if err := p.GetTx().Commit(context.TODO()); err != nil {
 		return err
 	}
-	if err := p.StoreBlock(quorumCert); err != nil {
+	if err := p.storeBlock(quorumCert); err != nil {
 		return err
 	}
 	if err := p.conn.Close(ctx); err != nil {
diff --git a/shared/docs/PROTOCOL_STATE_HASH.md b/shared/docs/PROTOCOL_STATE_HASH.md
index 1abf166d8..001cb2b8e 100644
--- a/shared/docs/PROTOCOL_STATE_HASH.md
+++ b/shared/docs/PROTOCOL_STATE_HASH.md
@@ -1,38 +1,43 @@
 # State Hash <!-- omit in toc -->
 
-- [1.Context Management](#1context-management)
-- [Block Application](#block-application)
-- [Block Commit](#block-commit)
-
-<!-- See if there's an answer in this question to add links to notes: https://stackoverflow.com/questions/74103729/adding-hyperlinks-to-notes-in-mermaid-sequence-diagrams -->
+This document describes of the cross-module communication using the interfaces in [../shared/modules](../shared/modules) to compute a new state hash.
 
-Describes of the cross-module communication using the interfaces in [shared/modules](../shared/modules) to compute a new state hash.
+See module specific documentation & implementation details inside each module respectively.
 
-See module specific documentation & implementation details inside each module respecively.their respective modules.
+- [Context Management](#context-management)
+- [Block Application](#block-application)
 
 _NOTE: The diagrams below use some [Hotstuff specific](https://arxiv.org/abs/1803.05069) terminology as described in the [HotPOKT Consensus Specification](https://github.com/pokt-network/pocket-network-protocol/tree/main/consensus) but can be adapted to other BFT protocols as well._
 
-NOTE:
+<!-- See if there's an answer in this question to add links to notes: https://stackoverflow.com/questions/74103729/adding-hyperlinks-to-notes-in-mermaid-sequence-diagrams -->
+
+## Context Management
 
-## 1.Context Management
+The `Utility` and `Persistence` modules maintain a context (i.e. an ephemeral states) driven by the `Consensus` module that can be released & reverted as a result of various (e.g. lack of Validator consensus) before the state is committed and persisted to disk (i.e. the block is finalized).
 
-The `Utility` and `Persistence` modules maintain **ephemeral states** driven by the `Consensus` module that can be released & reverted as a result of various (e.g. lack of Validator consensus) before the state is committed and persisted to disk (i.e. the block is finalized).
+On every round of every height:
 
-The `Hotstuff lifecycle` part refers to the so-called `PreCommit` and `Commit` phases of the protocol.
+1. The `Consensus` module handle a `NEWROUND` message
+2. A new `UtilityContext` is initialized at the current height
+3. A new `PersistenceRWContext` is initialized at the current height
+4. The [Block Application](#block-application) flow commences
 
 ```mermaid
 sequenceDiagram
-    participant N as Node
+    title Steps 1-4
+    participant B as Bus
     participant C as Consensus
     participant U as Utility
     participant P as Persistence
-    participant P2P as P2P
 
-    N-->>C: HandleMessage(msg)
+    %% Handle New Message
+    B-->>C: HandleMessage(msg)
+
     critical NewRound
+        %% Create Contexts
         C->>+U: NewContext(height)
         U->>+P: NewRWContext(height)
-        P->>-U: PersistenceRWContext
+        P->>-U: PersistenceContext
         U->>U: store context<br>locally
         activate U
         deactivate U
@@ -40,95 +45,130 @@ sequenceDiagram
         C->>C: store context<br>locally
         activate C
         deactivate C
+
+        %% Apply Block
         Note over C, P: See 'Block Application'
     end
+```
+
+5. The **HotPOKT lifecycle** takes place so Validators achieve consensus; steps `PRECOMMIT` and `COMMIT`
+6. The `Consensus` module handle a `DECIDE` message
+7. The final `quorumCertificate` is propagated to the `UtilityContext` on Commit
+8. The final `quorumCertificate` is propagated to the `PersistenceContext` on Commit
+9. The persistence module's internal implementation for [Store Block](../../persistence/docs/PROTOCOL_STATE_HASH.md) must execute.
+10. Both the `UtilityContext` and `PersistenceContext` are released
+
+```mermaid
+sequenceDiagram
+    title Steps 6-10
+    participant B as Bus
+    participant C as Consensus
+    participant U as Utility
+    participant P as Persistence
 
-    Note over N, P2P: Hotstuff lifecycle
-    N-->>C: HandleMessage(anypb.Any)
+    %% Handle New Message
+    B-->>C: HandleMessage(msg)
+
+    critical Decide
+        %% Commit Context
+        C->>+U: Context.Commit(quorumCert)
+        U->>+P: Context.Commit(quorumCert)
+        P->>P: Internal Implementation
+        Note over P: Store Block
+        P->>-U: err_code
+        U->>C: err_code
+        deactivate U
 
-    critical Decide Message
-        Note over C, P: See 'Block Commit'
+        %% Release Context
+        C->>+U: Context.Release()
+        U->>+P: Context.Release()
+        P->>-U: err_code
+        U->>-C: err_code
     end
+
 ```
 
 ## Block Application
 
-This flow shows how the `leader` and the `replica`s behave in order to apply a `block` and return a `stateHash`.
+When applying the block block during the `NEWROUND` message shown above, the majority of the flow is similar between the _leader_ and the _replica_ with one of the major differences being a call to the `Utility` module as seen below.
+
+- `ApplyBlock` - Uses the existing set of transactions to validate & propose.
+- `CreateAndApplyProposalBlock` - Reaps the mempool for a new set of transaction to validate and propose.
+
+```mermaid
+graph TD
+    B[Should I prepare a new block?] --> |Wait for 2/3+ NEWROUND messages| C
+
+    C[Am I the leader?] --> |Yes| D
+    C[Am I the leader?] --> |No| Z
+
+    D[Did I get any prepareQCs?] --> |Find highest valid PrepareQC| E
+    D[Did I get any prepareQCs?] --> |No| Z
+
+    E[Am I ahead of highPrepareQC?] --> |Yes| G
+    E[Am I ahead of highPrepareQC?] --> |No| Z
+
+    G[CreateAndApplyProposalBlock]
+    Z[ApplyBlock]
+```
+
+As either the _leader_ or _replica_, the following steps are followed to apply the proposal transactions in the block.
+
+1.  Retrieve the `PersistenceContext` from the `UtilityContext`
+2.  Update the `PersistenceContext` with the proposed block
+3.  Call either `ApplyBlock` or `CreateAndApplyProposalBlock` based on the flow above
 
 ```mermaid
 sequenceDiagram
+    title Steps 1-3
     participant C as Consensus
     participant U as Utility
     participant P as Persistence
 
-    %% Prepare or get block as leader
-    opt if leader
-        C->>U: GetProposalTransactions(proposer, maxTxBz, [lastVal])
-        activate U
-        alt no QC in NewRound
-        U->>U: reap mempool <br> & prepare block
-        activate U
-        deactivate U
-    else
-        U->>U: find QC <br> & get block
-        activate U
-        deactivate U
-        end
-        U-->>C: txs
-        deactivate U
-    end
+        %% Retrieve the persistence context
+        C->>+U: GetPersistenceContext()
+        U->>-C: PersistenceContext
 
-    %% Apply block as leader or replica
-    C->>+U: ApplyBlock(height, proposer, txs, lastVals)
-    loop [for each op in tx] for each tx in txs
-        U->>+P: TransactionExists(txHash)
-        P->>-U: true | false
-        opt if tx is not indexed
-            U->>+P: Get*/Set*
-            P-->>-U: result, err_code
-            U->>U: Validation logic
-            activate U
-            deactivate U
-            U->>+P: StoreTransaction(tx)
-            P->>P: Store tx locally
-            activate P
-            deactivate P
-            P-->>-U: result, err_code
-        end
-    end
-    U->>+P: UpdateAppHash()
-    P->>P: Update state hash
-    activate P
-    deactivate P
-    P-->>-U: stateHash
-    U-->>-C: stateHash
-```
+        %% Update the proposal in the persistence context
+        C->>+P: SetProposalBlock
+        P->>-C: err_code
 
-The [V1 Persistence Specification](https://github.com/pokt-network/pocket-network-protocol/tree/main/persistence) outlines the use of a **PostgresDB** and **Merkle Trees** to implement the `Update State Hash` component. This is an internal detail which can be done differently depending on the implementation. For the core V1 implementation, see the flows outlined [here](../../../persistence/docs/AppHash.md).
+        %% Apply the block to the local proposal state
+        C->>+U: ApplyBlock / CreateAndApplyProposalBlock
+```
 
-## Block Commit
+4. Loop over all transactions proposed
+5. Check if the transaction has already been applied to the local state
+6. Perform the CRUD operation(s) corresponding to each transaction
+7. The persistence module's internal implementation for [Updating a State hash](../../persistence/docs/PROTOCOL_STATE_HASH.md) must execute.
+8. Validate that the local state hash computed is the same as that proposed.
 
 ```mermaid
 sequenceDiagram
+    title Steps 4-8
     participant C as Consensus
     participant U as Utility
     participant P as Persistence
 
-    %% Commit Context
-    C->>+U: CommitContext(quorumCert)
-    U->>+P: Commit(quorumCert)
-    P->>P: See 'Store Block'
-    P->>-U: result, err_code
-    U->>+P: Release()
-    P->>-U: result, err_code
-    deactivate U
-
-    %% Release Context
-    C->>+U: Release()
-    U->>-C: result, err_code
-    C->>C: release utilityContext
-    activate C
-    deactivate C
-```
+    loop for each tx in txs
+        U->>+P: TransactionExists(txHash)
+        P->>-U: true | false
+        opt if tx is not indexed
+            loop for each operation in tx
+                U->>+P: Get*/Set*/Update*/Insert*
+                P-->>-U: err_code
+                U->>U: Validation logic
+                activate U
+                deactivate U
+            end
+        end
+    end
+    U->>+P: UpdateAppHash()
+    P->>P: Internal Implementation
+    Note over P: Update state hash
+    P->>-U: stateHash
+    U->>C: stateHash
 
-The [V1 Persistence Specification](https://github.com/pokt-network/pocket-network-protocol/tree/main/persistence) outlines the use of a **key-value store** to implement the `Create And Store Block` component. This is an internal detail which can be done differently depending on the implementation. For the core V1 implementation, see the flows outlined [here](../../../persistence/docs/AppHash.md).
+    %% Validate the updated hash
+    C->>C: Compare local hash against proposed hash
+```
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index e4617b9a5..978408774 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -15,7 +15,7 @@ type PersistenceModule interface {
 	// Context operations
 	NewRWContext(height int64) (PersistenceRWContext, error)
 	NewReadContext(height int64) (PersistenceReadContext, error)
-	ReleaseWriteContext() error // Only one write context can exist at a time
+	ReleaseWriteContext() error // The module can maintain many read contexts, but only one write context can exist at a time
 
 	// BlockStore operations
 	GetBlockStore() kvstore.KVStore
@@ -56,15 +56,13 @@ type PersistenceWriteContext interface {
 	Commit(quorumCert []byte) error
 
 	// Indexer Operations
-	IndexTransactions() error
 
 	// Block Operations
-	// DISCUSS_IN_THIS_COMMIT: Can we remove `TxResult` from the public facing interface given that we set transactions in `SetProposalBlock`?
+	// DISCUSS_IN_THIS_COMMIT: Can this function be removed ? If so, could we remove `TxResult` from the public facing interface given that we set transactions in `SetProposalBlock`?
 	SetLatestTxResults(txResults []TxResult)
 	// TODO(#284): Remove `blockProtoBytes`
 	SetProposalBlock(blockHash string, blockProtoBytes, proposerAddr []byte, transactions [][]byte) error
 	// Store the block into persistence
-	StoreBlock(quorumCert []byte) error
 	UpdateAppHash() ([]byte, error)
 
 	// Pool Operations

From e60e22a7658fdd62228234f97d7db9e77416a2c2 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sun, 6 Nov 2022 13:50:27 -0800
Subject: [PATCH 120/227] Update comment

---
 persistence/db.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/persistence/db.go b/persistence/db.go
index 7ddddfe71..91929c226 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -86,7 +86,7 @@ func (pg *PostgresContext) ResetContext() error {
 	return nil
 }
 
-// DISCUSS_IN_THIS_COMMIT:
+// DISCUSS:
 // 1. Can we remove `Latest` from these Setter & Getter methods
 // 2. Can we scope that to this package?
 // 3. Is `context.go` more appropriate for these than `db.go`?

From 51d1401d147d288bd22a92ef6bbd9f7443ff4e14 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sun, 6 Nov 2022 14:00:50 -0800
Subject: [PATCH 121/227] Self review of most parts of the code

---
 shared/docs/PROTOCOL_STATE_HASH.md | 25 ++++++++++++-------------
 shared/modules/doc/CHANGELOG.md    | 24 ------------------------
 2 files changed, 12 insertions(+), 37 deletions(-)

diff --git a/shared/docs/PROTOCOL_STATE_HASH.md b/shared/docs/PROTOCOL_STATE_HASH.md
index 001cb2b8e..67f1240a6 100644
--- a/shared/docs/PROTOCOL_STATE_HASH.md
+++ b/shared/docs/PROTOCOL_STATE_HASH.md
@@ -1,8 +1,6 @@
 # State Hash <!-- omit in toc -->
 
-This document describes of the cross-module communication using the interfaces in [../shared/modules](../shared/modules) to compute a new state hash.
-
-See module specific documentation & implementation details inside each module respectively.
+This document describes the cross-module communication using the interfaces in [../shared/modules](../shared/modules) to compute a new state hash. See module specific documentation & implementation details inside each module respectively.
 
 - [Context Management](#context-management)
 - [Block Application](#block-application)
@@ -17,7 +15,7 @@ The `Utility` and `Persistence` modules maintain a context (i.e. an ephemeral st
 
 On every round of every height:
 
-1. The `Consensus` module handle a `NEWROUND` message
+1. The `Consensus` module handles a `NEWROUND` message
 2. A new `UtilityContext` is initialized at the current height
 3. A new `PersistenceRWContext` is initialized at the current height
 4. The [Block Application](#block-application) flow commences
@@ -51,8 +49,8 @@ sequenceDiagram
     end
 ```
 
-5. The **HotPOKT lifecycle** takes place so Validators achieve consensus; steps `PRECOMMIT` and `COMMIT`
-6. The `Consensus` module handle a `DECIDE` message
+5. The **HotPOKT lifecycle** takes place so Validators achieve consensus (i.e. steps `PRECOMMIT` and `COMMIT`)
+6. The `Consensus` module handle the `DECIDE` message
 7. The final `quorumCertificate` is propagated to the `UtilityContext` on Commit
 8. The final `quorumCertificate` is propagated to the `PersistenceContext` on Commit
 9. The persistence module's internal implementation for [Store Block](../../persistence/docs/PROTOCOL_STATE_HASH.md) must execute.
@@ -90,10 +88,10 @@ sequenceDiagram
 
 ## Block Application
 
-When applying the block block during the `NEWROUND` message shown above, the majority of the flow is similar between the _leader_ and the _replica_ with one of the major differences being a call to the `Utility` module as seen below.
+When applying the block during the `NEWROUND` message shown above, the majority of the flow is similar between the _leader_ and the _replica_ with one of the major differences being a call to the `Utility` module as seen below.
 
-- `ApplyBlock` - Uses the existing set of transactions to validate & propose.
-- `CreateAndApplyProposalBlock` - Reaps the mempool for a new set of transaction to validate and propose.
+- `ApplyBlock` - Uses the existing set of transactions to validate & propose
+- `CreateAndApplyProposalBlock` - Reaps the mempool for a new set of transaction to validate and propose
 
 ```mermaid
 graph TD
@@ -135,13 +133,14 @@ sequenceDiagram
 
         %% Apply the block to the local proposal state
         C->>+U: ApplyBlock / CreateAndApplyProposalBlock
+        U->>-C: err_code
 ```
 
 4. Loop over all transactions proposed
 5. Check if the transaction has already been applied to the local state
 6. Perform the CRUD operation(s) corresponding to each transaction
-7. The persistence module's internal implementation for [Updating a State hash](../../persistence/docs/PROTOCOL_STATE_HASH.md) must execute.
-8. Validate that the local state hash computed is the same as that proposed.
+7. The persistence module's internal implementation for [Updating a State hash](../../persistence/docs/PROTOCOL_STATE_HASH.md) must be triggered
+8. Validate that the local state hash computed is the same as that proposed
 
 ```mermaid
 sequenceDiagram
@@ -156,7 +155,7 @@ sequenceDiagram
         opt if tx is not indexed
             loop for each operation in tx
                 U->>+P: Get*/Set*/Update*/Insert*
-                P-->>-U: err_code
+                P->>-U: err_code
                 U->>U: Validation logic
                 activate U
                 deactivate U
@@ -170,5 +169,5 @@ sequenceDiagram
     U->>C: stateHash
 
     %% Validate the updated hash
-    C->>C: Compare local hash against proposed hash
+    C->>C: Compare local hash<br>against proposed hash
 ```
diff --git a/shared/modules/doc/CHANGELOG.md b/shared/modules/doc/CHANGELOG.md
index 5cc114ed7..3a47a7671 100644
--- a/shared/modules/doc/CHANGELOG.md
+++ b/shared/modules/doc/CHANGELOG.md
@@ -7,36 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.0.0.3] - 2022-10-20
-
-Interface changes (w/o implementation) to support a StateHash computation.
-
-### Persistence Module Changes
-
-- Updates to the `PersistenceModule` interface
-
-  - Introduce `ReleaseWriteContext`
-  - Deprecate `ResetContext`
-
-- Updates to the `PersistenceContext` interface
-
-  - Change `Commit()` to `Commit(proposerAddr, quorumCert)`
-  - Change `AppHash()` to `UpdateAppHash()`
-  - Deprecate `StoreBlock`, `InsertBlock`, `Reset`
-
-- Updates to the `UtilityContext` interface
-  - Change `ReleaseContext()` to `Release()`
-  - Changed `CommitPersistenceContext()` to `Commit(quorumCert)`
-  - Deprecate `GetPersistenceContext`
-
 ## [0.0.0.2] - 2022-10-12
 
 - Modified interface for Utility Module `ApplyBlock` and `GetProposalTransactions` to return `TxResults`
 - Modified interface for Persistence Module `StoreTransaction` to store the `TxResult`
 - Added shared interface `TxResult` under types.go
 
-# Most GenesisTypes moved to persistence
-
 ## [0.0.0.1] - 2022-08-21
 
 - Minimized shared module with [#163](https://github.com/pokt-network/pocket/issues/163)

From 6bf28d563606407b900fd28724004aed3aade687 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sun, 6 Nov 2022 14:14:39 -0800
Subject: [PATCH 122/227] Small commit

---
 persistence/docs/PROTOCOL_STATE_HASH.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/persistence/docs/PROTOCOL_STATE_HASH.md b/persistence/docs/PROTOCOL_STATE_HASH.md
index f6ae4b57e..fc5fabb46 100644
--- a/persistence/docs/PROTOCOL_STATE_HASH.md
+++ b/persistence/docs/PROTOCOL_STATE_HASH.md
@@ -1,5 +1,7 @@
 # AppHash <!-- omit in toc -->
 
+This document describes the persistence module internal implementation of how the state hash is updated. Specifically, what happens once the `UpdateStateHash` function in [persistence module interface](../../shared/modules/persistence_module.go) is called.
+
 ## Update State Hash
 
 This flow shows the interaction between the PostgresDB and MerkleTrees to compute the state hash.
@@ -7,7 +9,7 @@ This flow shows the interaction between the PostgresDB and MerkleTrees to comput
 ```mermaid
 sequenceDiagram
     participant P as Persistence Module
-    participant PP as Persistence (PostgresDB)
+    participant PP as Persistence (SQLDatabase)
     participant PM as Persistence (MerkleTree)
 
     loop for each protocol actor type

From d7deb633da5ccf69ca374e50e9e409cb6aad0ee2 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sun, 6 Nov 2022 14:54:43 -0800
Subject: [PATCH 123/227] First attempt at fixing things

---
 Makefile                  |  6 ++++++
 build/config/config1.json |  8 ++++----
 build/config/config2.json |  8 ++++----
 build/config/config3.json |  8 ++++----
 build/config/config4.json |  8 ++++----
 consensus/debugging.go    |  4 ++--
 consensus/pacemaker.go    |  8 ++++++++
 persistence/debug.go      |  3 ++-
 persistence/module.go     | 14 +++++++-------
 9 files changed, 41 insertions(+), 26 deletions(-)

diff --git a/Makefile b/Makefile
index a5dd7cdb6..665c67090 100644
--- a/Makefile
+++ b/Makefile
@@ -195,6 +195,12 @@ docker_wipe: docker_check prompt_user
 	docker images -q | xargs -r -I {} docker rmi {}
 	docker volume ls -q | xargs -r -I {} docker volume rm {}
 
+.PHONY: docker_wipe_nodes
+## [WARNING] Remove all the node containers
+docker_wipe_nodes: docker_check prompt_user db_drop
+	docker ps -a -q --filter="name=node*" | xargs -r -I {} docker stop {}
+	docker ps -a -q --filter="name=node*" | xargs -r -I {} docker rm {}
+
 .PHONY: monitoring_start
 ## Start grafana, metrics and logging system (this is auto-triggered by compose_and_watch)
 monitoring_start: docker_check
diff --git a/build/config/config1.json b/build/config/config1.json
index 6e56a0bca..3b3825e5a 100755
--- a/build/config/config1.json
+++ b/build/config/config1.json
@@ -1,7 +1,7 @@
 {
   "base": {
     "root_directory": "/go/src/github.com/pocket-network",
-    "private_key": "6fd0bc54cc2dd205eaf226eebdb0451629b321f11d279013ce6fdd5a33059256b2eda2232ffb2750bf761141f70f75a03a025f65b2b2b417c7f8b3c9ca91e8e4"
+    "private_key": "c6c136d010d07d7f5e9944aa3594a10f9210dd3e26ebc1bc1516a6d957fd0df353ee26c82826694ffe1773d7b60d5f20dd9e91bdf8745544711bec5ff9c6fb4a"
   },
   "consensus": {
     "max_mempool_bytes": 500000000,
@@ -10,7 +10,7 @@
       "manual": true,
       "debug_time_between_steps_msec": 1000
     },
-    "private_key": "6fd0bc54cc2dd205eaf226eebdb0451629b321f11d279013ce6fdd5a33059256b2eda2232ffb2750bf761141f70f75a03a025f65b2b2b417c7f8b3c9ca91e8e4"
+    "private_key": "c6c136d010d07d7f5e9944aa3594a10f9210dd3e26ebc1bc1516a6d957fd0df353ee26c82826694ffe1773d7b60d5f20dd9e91bdf8745544711bec5ff9c6fb4a"
   },
   "utility": {
     "max_mempool_transaction_bytes": 1073741824,
@@ -25,11 +25,11 @@
     "consensus_port": 8080,
     "use_rain_tree": true,
     "is_empty_connection_type": false,
-    "private_key": "6fd0bc54cc2dd205eaf226eebdb0451629b321f11d279013ce6fdd5a33059256b2eda2232ffb2750bf761141f70f75a03a025f65b2b2b417c7f8b3c9ca91e8e4"
+    "private_key": "c6c136d010d07d7f5e9944aa3594a10f9210dd3e26ebc1bc1516a6d957fd0df353ee26c82826694ffe1773d7b60d5f20dd9e91bdf8745544711bec5ff9c6fb4a"
   },
   "telemetry": {
     "enabled": true,
     "address": "0.0.0.0:9000",
     "endpoint": "/metrics"
   }
-}
\ No newline at end of file
+}
diff --git a/build/config/config2.json b/build/config/config2.json
index c3a887637..4bd1dd114 100755
--- a/build/config/config2.json
+++ b/build/config/config2.json
@@ -1,7 +1,7 @@
 {
   "base": {
     "root_directory": "/go/src/github.com/pocket-network",
-    "private_key": "5db3e9d97d04d6d70359de924bb02039c602080d6bf01a692bad31ad5ef93524c16043323c83ffd901a8bf7d73543814b8655aa4695f7bfb49d01926fc161cdb"
+    "private_key": "b37d3ba2f232060c41ba1177fea6008d885fcccad6826d64ee7d49f94d1dbc49a8b6be75d7551da093f788f7286c3a9cb885cfc8e52710eac5f1d5e5b4bf19b2"
   },
   "consensus": {
     "max_mempool_bytes": 500000000,
@@ -10,7 +10,7 @@
       "manual": true,
       "debug_time_between_steps_msec": 1000
     },
-    "private_key": "5db3e9d97d04d6d70359de924bb02039c602080d6bf01a692bad31ad5ef93524c16043323c83ffd901a8bf7d73543814b8655aa4695f7bfb49d01926fc161cdb"
+    "private_key": "b37d3ba2f232060c41ba1177fea6008d885fcccad6826d64ee7d49f94d1dbc49a8b6be75d7551da093f788f7286c3a9cb885cfc8e52710eac5f1d5e5b4bf19b2"
   },
   "utility": {
     "max_mempool_transaction_bytes": 1073741824,
@@ -25,11 +25,11 @@
     "consensus_port": 8080,
     "use_rain_tree": true,
     "is_empty_connection_type": false,
-    "private_key": "5db3e9d97d04d6d70359de924bb02039c602080d6bf01a692bad31ad5ef93524c16043323c83ffd901a8bf7d73543814b8655aa4695f7bfb49d01926fc161cdb"
+    "private_key": "b37d3ba2f232060c41ba1177fea6008d885fcccad6826d64ee7d49f94d1dbc49a8b6be75d7551da093f788f7286c3a9cb885cfc8e52710eac5f1d5e5b4bf19b2"
   },
   "telemetry": {
     "enabled": true,
     "address": "0.0.0.0:9000",
     "endpoint": "/metrics"
   }
-}
\ No newline at end of file
+}
diff --git a/build/config/config3.json b/build/config/config3.json
index cac37220c..c1ed890c6 100755
--- a/build/config/config3.json
+++ b/build/config/config3.json
@@ -1,7 +1,7 @@
 {
   "base": {
     "root_directory": "/go/src/github.com/pocket-network",
-    "private_key": "b37d3ba2f232060c41ba1177fea6008d885fcccad6826d64ee7d49f94d1dbc49a8b6be75d7551da093f788f7286c3a9cb885cfc8e52710eac5f1d5e5b4bf19b2"
+    "private_key": "5db3e9d97d04d6d70359de924bb02039c602080d6bf01a692bad31ad5ef93524c16043323c83ffd901a8bf7d73543814b8655aa4695f7bfb49d01926fc161cdb"
   },
   "consensus": {
     "max_mempool_bytes": 500000000,
@@ -10,7 +10,7 @@
       "manual": true,
       "debug_time_between_steps_msec": 1000
     },
-    "private_key": "b37d3ba2f232060c41ba1177fea6008d885fcccad6826d64ee7d49f94d1dbc49a8b6be75d7551da093f788f7286c3a9cb885cfc8e52710eac5f1d5e5b4bf19b2"
+    "private_key": "5db3e9d97d04d6d70359de924bb02039c602080d6bf01a692bad31ad5ef93524c16043323c83ffd901a8bf7d73543814b8655aa4695f7bfb49d01926fc161cdb"
   },
   "utility": {
     "max_mempool_transaction_bytes": 1073741824,
@@ -25,11 +25,11 @@
     "consensus_port": 8080,
     "use_rain_tree": true,
     "is_empty_connection_type": false,
-    "private_key": "b37d3ba2f232060c41ba1177fea6008d885fcccad6826d64ee7d49f94d1dbc49a8b6be75d7551da093f788f7286c3a9cb885cfc8e52710eac5f1d5e5b4bf19b2"
+    "private_key": "5db3e9d97d04d6d70359de924bb02039c602080d6bf01a692bad31ad5ef93524c16043323c83ffd901a8bf7d73543814b8655aa4695f7bfb49d01926fc161cdb"
   },
   "telemetry": {
     "enabled": true,
     "address": "0.0.0.0:9000",
     "endpoint": "/metrics"
   }
-}
\ No newline at end of file
+}
diff --git a/build/config/config4.json b/build/config/config4.json
index e30a8f80c..fd9e6ca64 100755
--- a/build/config/config4.json
+++ b/build/config/config4.json
@@ -1,7 +1,7 @@
 {
   "base": {
     "root_directory": "/go/src/github.com/pocket-network",
-    "private_key": "c6c136d010d07d7f5e9944aa3594a10f9210dd3e26ebc1bc1516a6d957fd0df353ee26c82826694ffe1773d7b60d5f20dd9e91bdf8745544711bec5ff9c6fb4a"
+    "private_key": "6fd0bc54cc2dd205eaf226eebdb0451629b321f11d279013ce6fdd5a33059256b2eda2232ffb2750bf761141f70f75a03a025f65b2b2b417c7f8b3c9ca91e8e4"
   },
   "consensus": {
     "max_mempool_bytes": 500000000,
@@ -10,7 +10,7 @@
       "manual": true,
       "debug_time_between_steps_msec": 1000
     },
-    "private_key": "c6c136d010d07d7f5e9944aa3594a10f9210dd3e26ebc1bc1516a6d957fd0df353ee26c82826694ffe1773d7b60d5f20dd9e91bdf8745544711bec5ff9c6fb4a"
+    "private_key": "6fd0bc54cc2dd205eaf226eebdb0451629b321f11d279013ce6fdd5a33059256b2eda2232ffb2750bf761141f70f75a03a025f65b2b2b417c7f8b3c9ca91e8e4"
   },
   "utility": {
     "max_mempool_transaction_bytes": 1073741824,
@@ -25,11 +25,11 @@
     "consensus_port": 8080,
     "use_rain_tree": true,
     "is_empty_connection_type": false,
-    "private_key": "c6c136d010d07d7f5e9944aa3594a10f9210dd3e26ebc1bc1516a6d957fd0df353ee26c82826694ffe1773d7b60d5f20dd9e91bdf8745544711bec5ff9c6fb4a"
+    "private_key": "6fd0bc54cc2dd205eaf226eebdb0451629b321f11d279013ce6fdd5a33059256b2eda2232ffb2750bf761141f70f75a03a025f65b2b2b417c7f8b3c9ca91e8e4"
   },
   "telemetry": {
     "enabled": true,
     "address": "0.0.0.0:9000",
     "endpoint": "/metrics"
   }
-}
\ No newline at end of file
+}
diff --git a/consensus/debugging.go b/consensus/debugging.go
index 1a3fe0f5c..18a524012 100644
--- a/consensus/debugging.go
+++ b/consensus/debugging.go
@@ -62,9 +62,9 @@ func (m *consensusModule) printNodeState(_ *debug.DebugMessage) {
 func (m *consensusModule) triggerNextView(_ *debug.DebugMessage) {
 	m.nodeLog(typesCons.DebugTriggerNextView)
 
-	currentheight := m.Height
+	currentHeight := m.Height
 	currentStep := m.Step
-	if currentheight == 0 || (currentStep == Decide && m.paceMaker.IsManualMode()) {
+	if currentHeight == 0 || (currentStep == Decide && m.paceMaker.IsManualMode()) {
 		m.paceMaker.NewHeight()
 	} else {
 		m.paceMaker.InterruptRound()
diff --git a/consensus/pacemaker.go b/consensus/pacemaker.go
index 4f0651418..a2228e33c 100644
--- a/consensus/pacemaker.go
+++ b/consensus/pacemaker.go
@@ -220,9 +220,17 @@ func (p *paceMaker) NewHeight() {
 }
 
 func (p *paceMaker) startNextView(qc *typesCons.QuorumCertificate, forceNextView bool) {
+	p.consensusMod.m.Lock()
+	defer p.consensusMod.m.Unlock()
+
 	p.consensusMod.Step = NewRound
 	p.consensusMod.clearLeader()
 	p.consensusMod.clearMessagesPool()
+	// TECHDEBT: This should be avoidable altogether
+	if p.consensusMod.utilityContext != nil {
+		p.consensusMod.utilityContext.ReleaseContext()
+		p.consensusMod.utilityContext = nil
+	}
 
 	// TODO(olshansky): This if structure for debug purposes only; think of a way to externalize it...
 	if p.manualMode && !forceNextView {
diff --git a/persistence/debug.go b/persistence/debug.go
index 51cf8939c..565381ffa 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -41,11 +41,12 @@ func (m *persistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 
 func (m *persistenceModule) clearState(_ *debug.DebugMessage) {
 	context, err := m.NewRWContext(-1)
-	defer context.Commit()
 	if err != nil {
 		log.Printf("Error creating new context: %s \n", err)
 		return
 	}
+	defer context.Commit()
+
 	if err := context.(*PostgresContext).DebugClearAll(); err != nil {
 		log.Printf("Error clearing state: %s \n", err)
 		return
diff --git a/persistence/module.go b/persistence/module.go
index dfbb88689..fa8db1744 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -3,9 +3,10 @@ package persistence
 import (
 	"context"
 	"fmt"
-	"github.com/pokt-network/pocket/persistence/indexer"
 	"log"
 
+	"github.com/pokt-network/pocket/persistence/indexer"
+
 	"github.com/pokt-network/pocket/persistence/types"
 
 	"github.com/jackc/pgx/v4"
@@ -204,8 +205,8 @@ func initializeBlockStore(blockStorePath string) (kvstore.KVStore, error) {
 	return kvstore.NewKVStore(blockStorePath)
 }
 
-// TODO(drewsky): Simplify and externalize the logic for whether genesis should be populated and
-// move the if logic out of this file.
+// HACK(olshansky): Simplify and externalize the logic for whether genesis should be populated and
+//                  move the if logic out of this file.
 func (m *persistenceModule) shouldHydrateGenesisDb() (bool, error) {
 	checkContext, err := m.NewReadContext(-1)
 	if err != nil {
@@ -213,10 +214,9 @@ func (m *persistenceModule) shouldHydrateGenesisDb() (bool, error) {
 	}
 	defer checkContext.Close()
 
-	maxHeight, err := checkContext.GetLatestBlockHeight()
-	if err == nil || maxHeight == 0 {
+	_, err = checkContext.GetLatestBlockHeight()
+	if err != nil {
 		return true, nil
 	}
-
-	return m.blockStore.Exists(heightToBytes(int64(maxHeight)))
+	return false, nil
 }

From a9de39715912fade53e2dd010a17b72a66e6e49c Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sun, 6 Nov 2022 17:03:54 -0800
Subject: [PATCH 124/227] Made things kind of work

---
 build/config/config1.json      |  6 +++---
 build/config/config2.json      |  6 +++---
 build/config/config3.json      |  6 +++---
 build/config/config4.json      |  6 +++---
 build/config/genesis.json      | 14 ++++----------
 consensus/hotstuff_handler.go  |  7 ++++---
 consensus/module.go            | 19 +++++++++++++++++++
 consensus/pacemaker.go         |  3 +--
 consensus/types/errors.go      |  2 +-
 p2p/raintree/addrbook_utils.go |  6 +++---
 p2p/raintree/network.go        |  2 +-
 p2p/raintree/peers_manager.go  |  1 +
 p2p/raintree/target.go         |  4 ++--
 13 files changed, 48 insertions(+), 34 deletions(-)

diff --git a/build/config/config1.json b/build/config/config1.json
index 3b3825e5a..e6a377cae 100755
--- a/build/config/config1.json
+++ b/build/config/config1.json
@@ -1,7 +1,7 @@
 {
   "base": {
     "root_directory": "/go/src/github.com/pocket-network",
-    "private_key": "c6c136d010d07d7f5e9944aa3594a10f9210dd3e26ebc1bc1516a6d957fd0df353ee26c82826694ffe1773d7b60d5f20dd9e91bdf8745544711bec5ff9c6fb4a"
+    "private_key": "6fd0bc54cc2dd205eaf226eebdb0451629b321f11d279013ce6fdd5a33059256b2eda2232ffb2750bf761141f70f75a03a025f65b2b2b417c7f8b3c9ca91e8e4"
   },
   "consensus": {
     "max_mempool_bytes": 500000000,
@@ -10,7 +10,7 @@
       "manual": true,
       "debug_time_between_steps_msec": 1000
     },
-    "private_key": "c6c136d010d07d7f5e9944aa3594a10f9210dd3e26ebc1bc1516a6d957fd0df353ee26c82826694ffe1773d7b60d5f20dd9e91bdf8745544711bec5ff9c6fb4a"
+    "private_key": "6fd0bc54cc2dd205eaf226eebdb0451629b321f11d279013ce6fdd5a33059256b2eda2232ffb2750bf761141f70f75a03a025f65b2b2b417c7f8b3c9ca91e8e4"
   },
   "utility": {
     "max_mempool_transaction_bytes": 1073741824,
@@ -25,7 +25,7 @@
     "consensus_port": 8080,
     "use_rain_tree": true,
     "is_empty_connection_type": false,
-    "private_key": "c6c136d010d07d7f5e9944aa3594a10f9210dd3e26ebc1bc1516a6d957fd0df353ee26c82826694ffe1773d7b60d5f20dd9e91bdf8745544711bec5ff9c6fb4a"
+    "private_key": "6fd0bc54cc2dd205eaf226eebdb0451629b321f11d279013ce6fdd5a33059256b2eda2232ffb2750bf761141f70f75a03a025f65b2b2b417c7f8b3c9ca91e8e4"
   },
   "telemetry": {
     "enabled": true,
diff --git a/build/config/config2.json b/build/config/config2.json
index 4bd1dd114..e8bb9c78e 100755
--- a/build/config/config2.json
+++ b/build/config/config2.json
@@ -1,7 +1,7 @@
 {
   "base": {
     "root_directory": "/go/src/github.com/pocket-network",
-    "private_key": "b37d3ba2f232060c41ba1177fea6008d885fcccad6826d64ee7d49f94d1dbc49a8b6be75d7551da093f788f7286c3a9cb885cfc8e52710eac5f1d5e5b4bf19b2"
+    "private_key": "5db3e9d97d04d6d70359de924bb02039c602080d6bf01a692bad31ad5ef93524c16043323c83ffd901a8bf7d73543814b8655aa4695f7bfb49d01926fc161cdb"
   },
   "consensus": {
     "max_mempool_bytes": 500000000,
@@ -10,7 +10,7 @@
       "manual": true,
       "debug_time_between_steps_msec": 1000
     },
-    "private_key": "b37d3ba2f232060c41ba1177fea6008d885fcccad6826d64ee7d49f94d1dbc49a8b6be75d7551da093f788f7286c3a9cb885cfc8e52710eac5f1d5e5b4bf19b2"
+    "private_key": "5db3e9d97d04d6d70359de924bb02039c602080d6bf01a692bad31ad5ef93524c16043323c83ffd901a8bf7d73543814b8655aa4695f7bfb49d01926fc161cdb"
   },
   "utility": {
     "max_mempool_transaction_bytes": 1073741824,
@@ -25,7 +25,7 @@
     "consensus_port": 8080,
     "use_rain_tree": true,
     "is_empty_connection_type": false,
-    "private_key": "b37d3ba2f232060c41ba1177fea6008d885fcccad6826d64ee7d49f94d1dbc49a8b6be75d7551da093f788f7286c3a9cb885cfc8e52710eac5f1d5e5b4bf19b2"
+    "private_key": "5db3e9d97d04d6d70359de924bb02039c602080d6bf01a692bad31ad5ef93524c16043323c83ffd901a8bf7d73543814b8655aa4695f7bfb49d01926fc161cdb"
   },
   "telemetry": {
     "enabled": true,
diff --git a/build/config/config3.json b/build/config/config3.json
index c1ed890c6..5352ab5e3 100755
--- a/build/config/config3.json
+++ b/build/config/config3.json
@@ -1,7 +1,7 @@
 {
   "base": {
     "root_directory": "/go/src/github.com/pocket-network",
-    "private_key": "5db3e9d97d04d6d70359de924bb02039c602080d6bf01a692bad31ad5ef93524c16043323c83ffd901a8bf7d73543814b8655aa4695f7bfb49d01926fc161cdb"
+    "private_key": "b37d3ba2f232060c41ba1177fea6008d885fcccad6826d64ee7d49f94d1dbc49a8b6be75d7551da093f788f7286c3a9cb885cfc8e52710eac5f1d5e5b4bf19b2"
   },
   "consensus": {
     "max_mempool_bytes": 500000000,
@@ -10,7 +10,7 @@
       "manual": true,
       "debug_time_between_steps_msec": 1000
     },
-    "private_key": "5db3e9d97d04d6d70359de924bb02039c602080d6bf01a692bad31ad5ef93524c16043323c83ffd901a8bf7d73543814b8655aa4695f7bfb49d01926fc161cdb"
+    "private_key": "b37d3ba2f232060c41ba1177fea6008d885fcccad6826d64ee7d49f94d1dbc49a8b6be75d7551da093f788f7286c3a9cb885cfc8e52710eac5f1d5e5b4bf19b2"
   },
   "utility": {
     "max_mempool_transaction_bytes": 1073741824,
@@ -25,7 +25,7 @@
     "consensus_port": 8080,
     "use_rain_tree": true,
     "is_empty_connection_type": false,
-    "private_key": "5db3e9d97d04d6d70359de924bb02039c602080d6bf01a692bad31ad5ef93524c16043323c83ffd901a8bf7d73543814b8655aa4695f7bfb49d01926fc161cdb"
+    "private_key": "b37d3ba2f232060c41ba1177fea6008d885fcccad6826d64ee7d49f94d1dbc49a8b6be75d7551da093f788f7286c3a9cb885cfc8e52710eac5f1d5e5b4bf19b2"
   },
   "telemetry": {
     "enabled": true,
diff --git a/build/config/config4.json b/build/config/config4.json
index fd9e6ca64..11f98b275 100755
--- a/build/config/config4.json
+++ b/build/config/config4.json
@@ -1,7 +1,7 @@
 {
   "base": {
     "root_directory": "/go/src/github.com/pocket-network",
-    "private_key": "6fd0bc54cc2dd205eaf226eebdb0451629b321f11d279013ce6fdd5a33059256b2eda2232ffb2750bf761141f70f75a03a025f65b2b2b417c7f8b3c9ca91e8e4"
+    "private_key": "c6c136d010d07d7f5e9944aa3594a10f9210dd3e26ebc1bc1516a6d957fd0df353ee26c82826694ffe1773d7b60d5f20dd9e91bdf8745544711bec5ff9c6fb4a"
   },
   "consensus": {
     "max_mempool_bytes": 500000000,
@@ -10,7 +10,7 @@
       "manual": true,
       "debug_time_between_steps_msec": 1000
     },
-    "private_key": "6fd0bc54cc2dd205eaf226eebdb0451629b321f11d279013ce6fdd5a33059256b2eda2232ffb2750bf761141f70f75a03a025f65b2b2b417c7f8b3c9ca91e8e4"
+    "private_key": "c6c136d010d07d7f5e9944aa3594a10f9210dd3e26ebc1bc1516a6d957fd0df353ee26c82826694ffe1773d7b60d5f20dd9e91bdf8745544711bec5ff9c6fb4a"
   },
   "utility": {
     "max_mempool_transaction_bytes": 1073741824,
@@ -25,7 +25,7 @@
     "consensus_port": 8080,
     "use_rain_tree": true,
     "is_empty_connection_type": false,
-    "private_key": "6fd0bc54cc2dd205eaf226eebdb0451629b321f11d279013ce6fdd5a33059256b2eda2232ffb2750bf761141f70f75a03a025f65b2b2b417c7f8b3c9ca91e8e4"
+    "private_key": "c6c136d010d07d7f5e9944aa3594a10f9210dd3e26ebc1bc1516a6d957fd0df353ee26c82826694ffe1773d7b60d5f20dd9e91bdf8745544711bec5ff9c6fb4a"
   },
   "telemetry": {
     "enabled": true,
diff --git a/build/config/genesis.json b/build/config/genesis.json
index dde0b80bc..ad0784df5 100755
--- a/build/config/genesis.json
+++ b/build/config/genesis.json
@@ -106,9 +106,7 @@
       {
         "address": "88a792b7aca673620132ef01f50e62caa58eca83",
         "public_key": "5f78658599943dc3e623539ce0b3c9fe4e192034a1e3fef308bc9f96915754e0",
-        "chains": [
-          "0001"
-        ],
+        "chains": ["0001"],
         "generic_param": "1000000",
         "staked_amount": "1000000000000",
         "paused_height": -1,
@@ -121,9 +119,7 @@
       {
         "address": "43d9ea9d9ad9c58bb96ec41340f83cb2cabb6496",
         "public_key": "16cd0a304c38d76271f74dd3c90325144425d904ef1b9a6fbab9b201d75a998b",
-        "chains": [
-          "0001"
-        ],
+        "chains": ["0001"],
         "generic_param": "node1.consensus:8080",
         "staked_amount": "1000000000000",
         "paused_height": -1,
@@ -136,9 +132,7 @@
       {
         "address": "9ba047197ec043665ad3f81278ab1f5d3eaf6b8b",
         "public_key": "68efd26af01692fcd77dc135ca1de69ede464e8243e6832bd6c37f282db8c9cb",
-        "chains": [
-          "0001"
-        ],
+        "chains": ["0001"],
         "generic_param": "node1.consensus:8080",
         "staked_amount": "1000000000000",
         "paused_height": -1,
@@ -312,4 +306,4 @@
       }
     ]
   }
-}
\ No newline at end of file
+}
diff --git a/consensus/hotstuff_handler.go b/consensus/hotstuff_handler.go
index f1b580a0a..364bbf6ac 100644
--- a/consensus/hotstuff_handler.go
+++ b/consensus/hotstuff_handler.go
@@ -20,10 +20,11 @@ func (m *consensusModule) handleHotstuffMessage(msg *typesCons.HotstuffMessage)
 
 	// Pacemaker - Liveness & safety checks
 	if err := m.paceMaker.ValidateMessage(msg); err != nil {
-		if m.shouldLogHotstuffDiscardMessage(step) {
+		if m.shouldHandleHotstuffMessage(step) {
 			m.nodeLog(typesCons.WarnDiscardHotstuffMessage(msg, err.Error()))
+			return err
 		}
-		return err
+		return nil
 	}
 
 	if m.shouldElectNextLeader() {
@@ -47,7 +48,7 @@ func (m *consensusModule) shouldElectNextLeader() bool {
 	return m.Step == NewRound && m.LeaderId == nil
 }
 
-func (m *consensusModule) shouldLogHotstuffDiscardMessage(step typesCons.HotstuffStep) bool {
+func (m *consensusModule) shouldHandleHotstuffMessage(step typesCons.HotstuffStep) bool {
 	// If a replica is not a leader for this round, but has already determined a leader,
 	// and continues to receive NewRound messages, we avoid logging the "message discard"
 	// because it creates unnecessary spam.
diff --git a/consensus/module.go b/consensus/module.go
index 3a84370c8..f6dc63e3a 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -3,6 +3,7 @@ package consensus
 import (
 	"fmt"
 	"log"
+	"sort"
 	"sync"
 
 	"github.com/pokt-network/pocket/consensus/leader_election"
@@ -201,6 +202,24 @@ func (*consensusModule) ValidateConfig(cfg modules.Config) error {
 }
 
 func (*consensusModule) ValidateGenesis(genesis modules.GenesisState) error {
+	// Sort the validators by their generic param (i.e. service URL)
+	vals := genesis.GetConsensusGenesisState().GetVals()
+	sort.Slice(vals, func(i, j int) bool {
+		return vals[i].GetGenericParam() < vals[j].GetGenericParam()
+	})
+
+	// Sort the validators by their address
+	vals2 := vals[:]
+	sort.Slice(vals, func(i, j int) bool {
+		return vals[i].GetAddress() < vals[j].GetAddress()
+	})
+
+	for i := 0; i < len(vals); i++ {
+		if vals2[i].GetAddress() != vals[i].GetAddress() {
+			panic("HACK(olshansky): service url and address must be sorted the same way")
+		}
+	}
+
 	return nil
 }
 
diff --git a/consensus/pacemaker.go b/consensus/pacemaker.go
index a2228e33c..dd059c325 100644
--- a/consensus/pacemaker.go
+++ b/consensus/pacemaker.go
@@ -220,8 +220,7 @@ func (p *paceMaker) NewHeight() {
 }
 
 func (p *paceMaker) startNextView(qc *typesCons.QuorumCertificate, forceNextView bool) {
-	p.consensusMod.m.Lock()
-	defer p.consensusMod.m.Unlock()
+	// DISCUSS: Should we lock the consensus module here?
 
 	p.consensusMod.Step = NewRound
 	p.consensusMod.clearLeader()
diff --git a/consensus/types/errors.go b/consensus/types/errors.go
index 5368ee1bf..351f875fa 100644
--- a/consensus/types/errors.go
+++ b/consensus/types/errors.go
@@ -104,7 +104,7 @@ func DebugTogglePacemakerManualMode(mode string) string {
 }
 
 func DebugNodeState(state ConsensusNodeState) string {
-	return fmt.Sprintf("\t[DEBUG] NODE STATE: Node %d is at (Height, Step, Round): (%d, %d, %d)\n", state.NodeId, state.Height, state.Step, state.Round)
+	return fmt.Sprintf("[DEBUG] NODE STATE: Node %d is at (Height, Step, Round): (%d, %d, %d)\n", state.NodeId, state.Height, state.Step, state.Round)
 }
 
 func DebugHandlingHotstuffMessage(msg *HotstuffMessage) string {
diff --git a/p2p/raintree/addrbook_utils.go b/p2p/raintree/addrbook_utils.go
index 963449ea9..f9b7a570f 100644
--- a/p2p/raintree/addrbook_utils.go
+++ b/p2p/raintree/addrbook_utils.go
@@ -28,9 +28,9 @@ func (n *rainTreeNetwork) getAddrBookLength(level uint32, _height uint64) int {
 // getTargetsAtLevel returns the targets for a given level
 func (n *rainTreeNetwork) getTargetsAtLevel(level uint32) []target {
 	height := n.GetBus().GetConsensusModule().CurrentHeight()
-	addrBookLenghtAtHeight := n.getAddrBookLength(level, height)
-	firstTarget := n.getTarget(firstMsgTargetPercentage, addrBookLenghtAtHeight, level)
-	secondTarget := n.getTarget(secondMsgTargetPercentage, addrBookLenghtAtHeight, level)
+	addrBookLengthAtHeight := n.getAddrBookLength(level, height)
+	firstTarget := n.getTarget(firstMsgTargetPercentage, addrBookLengthAtHeight, level)
+	secondTarget := n.getTarget(secondMsgTargetPercentage, addrBookLengthAtHeight, level)
 
 	log.Printf("[DEBUG] Targets at height (%d): %s", level, n.debugMsgTargetString(firstTarget, secondTarget))
 
diff --git a/p2p/raintree/network.go b/p2p/raintree/network.go
index 265aeaf70..944dc4916 100644
--- a/p2p/raintree/network.go
+++ b/p2p/raintree/network.go
@@ -179,7 +179,7 @@ func (n *rainTreeNetwork) HandleNetworkData(data []byte) ([]byte, error) {
 
 	n.mempool[rainTreeMsg.Nonce] = struct{}{}
 
-	// Return the data back to the caller so it can be handeled by the app specific bus
+	// Return the data back to the caller so it can be handled by the app specific bus
 	return rainTreeMsg.Data, nil
 }
 
diff --git a/p2p/raintree/peers_manager.go b/p2p/raintree/peers_manager.go
index f07c2be4f..87cfabf44 100644
--- a/p2p/raintree/peers_manager.go
+++ b/p2p/raintree/peers_manager.go
@@ -117,6 +117,7 @@ func (pm *peersManager) getNetworkView() networkView {
 	}
 }
 
+// DISCUSS: This is only used in tests. Should we remove it?
 func (pm *peersManager) getSelfIndexInAddrBook() (int, bool) {
 	if len(pm.addrList) == 0 {
 		return -1, false
diff --git a/p2p/raintree/target.go b/p2p/raintree/target.go
index 10c4eb365..878529c74 100644
--- a/p2p/raintree/target.go
+++ b/p2p/raintree/target.go
@@ -25,11 +25,11 @@ func (t target) DebugString(n *rainTreeNetwork) string {
 	if !t.isSelf {
 		fmt.Fprintf(&s, " (%s) ", serviceUrl)
 	} else {
-		fmt.Fprintf(&s, "(self) %s ", serviceUrl)
+		fmt.Fprintf(&s, "(self %s) ", serviceUrl)
 	}
 
 	peersManagerStateView := n.peersManager.getNetworkView()
-	for i := 1; i < t.addrBookLengthAtHeight; i++ {
+	for i := 0; i < t.addrBookLengthAtHeight; i++ {
 		serviceUrl := peersManagerStateView.addrBookMap[peersManagerStateView.addrList[i]].ServiceUrl
 		if i == t.index {
 			fmt.Fprintf(&s, " **%s** ", serviceUrl)

From b72173e9f7c2deb09519924c6fa57bca7e8193f7 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sun, 6 Nov 2022 17:21:15 -0800
Subject: [PATCH 125/227] Make code easier to understand

---
 consensus/module.go    |  5 ++++-
 p2p/raintree/target.go | 17 ++++++++---------
 2 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/consensus/module.go b/consensus/module.go
index f6dc63e3a..d0f968fe8 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -215,7 +215,10 @@ func (*consensusModule) ValidateGenesis(genesis modules.GenesisState) error {
 	})
 
 	for i := 0; i < len(vals); i++ {
-		if vals2[i].GetAddress() != vals[i].GetAddress() {
+		if vals[i].GetAddress() != vals2[i].GetAddress() {
+			// There is an implicit dependency because of how RainTree works and how the validator map
+			// is currently managed to make sure that the ordering of the address and the service URL
+			// are the same. This will be addressed once the # of validators will scale.
 			panic("HACK(olshansky): service url and address must be sorted the same way")
 		}
 	}
diff --git a/p2p/raintree/target.go b/p2p/raintree/target.go
index 878529c74..4ce4d77a4 100644
--- a/p2p/raintree/target.go
+++ b/p2p/raintree/target.go
@@ -21,20 +21,19 @@ type target struct {
 func (t target) DebugString(n *rainTreeNetwork) string {
 	s := strings.Builder{}
 	s.WriteString("[")
-	serviceUrl := t.serviceUrl
-	if !t.isSelf {
-		fmt.Fprintf(&s, " (%s) ", serviceUrl)
-	} else {
-		fmt.Fprintf(&s, "(self %s) ", serviceUrl)
-	}
-
 	peersManagerStateView := n.peersManager.getNetworkView()
 	for i := 0; i < t.addrBookLengthAtHeight; i++ {
 		serviceUrl := peersManagerStateView.addrBookMap[peersManagerStateView.addrList[i]].ServiceUrl
-		if i == t.index {
+		switch {
+		case i == t.index && t.isSelf:
+			fmt.Fprintf(&s, " (**%s**) ", serviceUrl)
+		case i == t.index:
 			fmt.Fprintf(&s, " **%s** ", serviceUrl)
-		} else {
+		case t.isSelf:
+			fmt.Fprintf(&s, " (%s) ", serviceUrl)
+		default:
 			fmt.Fprintf(&s, " %s ", serviceUrl)
+
 		}
 	}
 	s.WriteString("]")

From 8011f8d384ec7803fadb2b123ca95032899eeeb6 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sun, 6 Nov 2022 17:26:22 -0800
Subject: [PATCH 126/227] Improve logging for p2p

---
 p2p/raintree/target.go | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/p2p/raintree/target.go b/p2p/raintree/target.go
index 4ce4d77a4..fb29589fc 100644
--- a/p2p/raintree/target.go
+++ b/p2p/raintree/target.go
@@ -22,14 +22,16 @@ func (t target) DebugString(n *rainTreeNetwork) string {
 	s := strings.Builder{}
 	s.WriteString("[")
 	peersManagerStateView := n.peersManager.getNetworkView()
+	selfAddr := n.selfAddr.String()
 	for i := 0; i < t.addrBookLengthAtHeight; i++ {
-		serviceUrl := peersManagerStateView.addrBookMap[peersManagerStateView.addrList[i]].ServiceUrl
+		addr := peersManagerStateView.addrList[i]
+		serviceUrl := peersManagerStateView.addrBookMap[addr].ServiceUrl
 		switch {
 		case i == t.index && t.isSelf:
 			fmt.Fprintf(&s, " (**%s**) ", serviceUrl)
 		case i == t.index:
 			fmt.Fprintf(&s, " **%s** ", serviceUrl)
-		case t.isSelf:
+		case addr == selfAddr:
 			fmt.Fprintf(&s, " (%s) ", serviceUrl)
 		default:
 			fmt.Fprintf(&s, " %s ", serviceUrl)

From 16860017e500c663ba603a49875b7ad711fda045 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sun, 6 Nov 2022 17:37:30 -0800
Subject: [PATCH 127/227] Removed persistence/docs/PROTOCOL_STATE_HASH.md from
 this commit

---
 persistence/docs/PROTOCOL_STATE_HASH.md | 51 -------------------------
 1 file changed, 51 deletions(-)
 delete mode 100644 persistence/docs/PROTOCOL_STATE_HASH.md

diff --git a/persistence/docs/PROTOCOL_STATE_HASH.md b/persistence/docs/PROTOCOL_STATE_HASH.md
deleted file mode 100644
index fc5fabb46..000000000
--- a/persistence/docs/PROTOCOL_STATE_HASH.md
+++ /dev/null
@@ -1,51 +0,0 @@
-# AppHash <!-- omit in toc -->
-
-This document describes the persistence module internal implementation of how the state hash is updated. Specifically, what happens once the `UpdateStateHash` function in [persistence module interface](../../shared/modules/persistence_module.go) is called.
-
-## Update State Hash
-
-This flow shows the interaction between the PostgresDB and MerkleTrees to compute the state hash.
-
-```mermaid
-sequenceDiagram
-    participant P as Persistence Module
-    participant PP as Persistence (SQLDatabase)
-    participant PM as Persistence (MerkleTree)
-
-    loop for each protocol actor type
-        P->>+PP: GetActorsUpdated(height)
-        PP->>-P: actors
-        loop for each state tree
-            P->>+PM: Update(addr, serialized(actor))
-            PM->>-P: result, err_code
-        end
-        P->>+PM: GetRoot()
-        PM->>-P: rootHash
-    end
-
-    P->>P: stateHash = hash(aggregated(rootHashes))
-    activate P
-    deactivate P
-```
-
-## Store Block
-
-This flow shows the interaction between the PostgresDB and Key-Value Store to compute the state hash.
-
-```mermaid
-sequenceDiagram
-    %% autonumber
-    participant P as Persistence
-    participant PP as Persistence (PostgresDB)
-    participant PK as Persistence (Key-Value Store)
-
-    activate P
-    P->>P: reap stored transactions
-    P->>P: prepare, serialize <br> & store block
-    deactivate P
-
-    P->>+PP: insertBlock(height, serialized(block))
-    PP->>-P: result, err_code
-    P->>+PK: Put(height, serialized(block))
-    PK->>-P: result, err_code
-```

From 6b7f5564189581b78f12d2ecd96404bd39f595fc Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 7 Nov 2022 16:22:23 -0800
Subject: [PATCH 128/227] Almost code random but determinstic test going

---
 go.mod                                   |  12 +++
 go.sum                                   |  31 +++++++
 persistence/debug.go                     |  16 +++-
 persistence/docs/PROTOCOL_STATE_HASH.md  |  51 +++++++++++
 persistence/state.go                     |   1 +
 persistence/test/benchmark_state_test.go |  55 ++++++++---
 persistence/test/setup_test.go           |  47 +++++++---
 persistence/test/state_test.go           | 112 +++++++++++++++++++++++
 8 files changed, 294 insertions(+), 31 deletions(-)
 create mode 100644 persistence/docs/PROTOCOL_STATE_HASH.md

diff --git a/go.mod b/go.mod
index b9acdcd97..007beaaa8 100644
--- a/go.mod
+++ b/go.mod
@@ -23,8 +23,10 @@ require (
 	github.com/benbjohnson/clock v1.3.0
 	github.com/celestiaorg/smt v0.2.1-0.20220414134126-dba215ccb884
 	github.com/dgraph-io/badger/v3 v3.2103.2
+	github.com/getkin/kin-openapi v0.107.0
 	github.com/jackc/pgconn v1.11.0
 	github.com/jordanorelli/lexnum v0.0.0-20141216151731-460eeb125754
+	github.com/labstack/echo/v4 v4.9.1
 	github.com/mitchellh/mapstructure v1.1.2
 	github.com/quasilyte/go-ruleguard/dsl v0.3.21
 	github.com/spf13/viper v1.3.2
@@ -73,9 +75,12 @@ require (
 	github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/fsnotify/fsnotify v1.4.7 // indirect
+	github.com/go-openapi/jsonpointer v0.19.5 // indirect
+	github.com/go-openapi/swag v0.19.5 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/google/go-cmp v0.5.6 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
+	github.com/invopop/yaml v0.1.0 // indirect
 	github.com/jackc/chunkreader/v2 v2.0.1 // indirect
 	github.com/jackc/pgio v1.0.0 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
@@ -83,13 +88,20 @@ require (
 	github.com/jackc/pgservicefile v0.0.0-20200714003250-2b9c44734f2b // indirect
 	github.com/jackc/pgtype v1.10.0 // indirect
 	github.com/kr/pretty v0.3.0 // indirect
+	github.com/labstack/gommon v0.4.0 // indirect
 	github.com/magiconair/properties v1.8.0 // indirect
+	github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e // indirect
+	github.com/mattn/go-colorable v0.1.11 // indirect
+	github.com/mattn/go-isatty v0.0.14 // indirect
+	github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 // indirect
 	github.com/pelletier/go-toml v1.2.0 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/spf13/afero v1.1.2 // indirect
 	github.com/spf13/cast v1.3.0 // indirect
 	github.com/spf13/jwalterweatherman v1.0.0 // indirect
 	github.com/spf13/pflag v1.0.3 // indirect
+	github.com/valyala/bytebufferpool v1.0.0 // indirect
+	github.com/valyala/fasttemplate v1.2.1 // indirect
 	golang.org/x/sys v0.0.0-20220405210540-1e041c57c461 // indirect
 	golang.org/x/text v0.3.7 // indirect
 	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
diff --git a/go.sum b/go.sum
index 6e6967b77..514a2fb07 100644
--- a/go.sum
+++ b/go.sum
@@ -122,6 +122,8 @@ github.com/fogleman/gg v1.3.0/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzP
 github.com/frankban/quicktest v1.11.3/go.mod h1:wRf/ReqHper53s+kmmSZizM8NamnL3IM0I9ntUbOk+k=
 github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/getkin/kin-openapi v0.107.0 h1:bxhL6QArW7BXQj8NjXfIJQy680NsMKd25nwhvpCXchg=
+github.com/getkin/kin-openapi v0.107.0/go.mod h1:9Dhr+FasATJZjS4iOLvB0hkaxgYdulrNYm2e9epLWOo=
 github.com/go-fonts/dejavu v0.1.0/go.mod h1:4Wt4I4OU2Nq9asgDCteaAaWZOV24E+0/Pwo0gppep4g=
 github.com/go-fonts/latin-modern v0.2.0/go.mod h1:rQVLdDMK+mK1xscDwsqM5J8U2jrRa3T0ecnM9pNujks=
 github.com/go-fonts/liberation v0.1.1/go.mod h1:K6qoJYypsmfVjWg8KOVDQhLc8UDgIK2HYqyqAO9z7GY=
@@ -136,6 +138,10 @@ github.com/go-latex/latex v0.0.0-20210118124228-b3d85cf34e07/go.mod h1:CO1AlKB2C
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
 github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
+github.com/go-openapi/jsonpointer v0.19.5 h1:gZr+CIYByUqjcgeLXnQu2gHYQC9o73G2XUeOFYEICuY=
+github.com/go-openapi/jsonpointer v0.19.5/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg=
+github.com/go-openapi/swag v0.19.5 h1:lTz6Ys4CmqqCQmZPBlbQENR1/GucA2bzYTE12Pw4tFY=
+github.com/go-openapi/swag v0.19.5/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/godbus/dbus/v5 v5.0.6/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
@@ -207,6 +213,7 @@ github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hf
 github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
 github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
 github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
+github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
 github.com/gotestyourself/gotestyourself v2.2.0+incompatible h1:AQwinXlbQR2HvPjQZOmDhRqsv5mZf+Jb1RnSLxcqZcI=
 github.com/gotestyourself/gotestyourself v2.2.0+incompatible/go.mod h1:zZKM6oeNM8k+FRljX1mnzVYeS8wiGgQyvST1/GafPbY=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
@@ -215,6 +222,8 @@ github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
 github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
+github.com/invopop/yaml v0.1.0 h1:YW3WGUoJEXYfzWBjn00zIlrw7brGVD0fUKRYDPAPhrc=
+github.com/invopop/yaml v0.1.0/go.mod h1:2XuRLgs/ouIrW3XNzuNj7J3Nvu/Dig5MXvbCEdiBN3Q=
 github.com/jackc/chunkreader v1.0.0/go.mod h1:RT6O25fNZIuasFJRyZ4R/Y2BbhasbmZXF9QQ7T3kePo=
 github.com/jackc/chunkreader/v2 v2.0.0/go.mod h1:odVSm741yZoC3dpHEUXIqA9tQRhFrgOHwnPIn9lDKlk=
 github.com/jackc/chunkreader/v2 v2.0.1 h1:i+RDz65UE+mmpjTfyz0MoVTnzeYxroil2G82ki7MGG8=
@@ -292,6 +301,10 @@ github.com/kr/pty v1.1.8/go.mod h1:O1sed60cT9XZ5uDucP5qwvh+TE3NnUj51EiZO/lmSfw=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/labstack/echo/v4 v4.9.1 h1:GliPYSpzGKlyOhqIbG8nmHBo3i1saKWFOgh41AN3b+Y=
+github.com/labstack/echo/v4 v4.9.1/go.mod h1:Pop5HLc+xoc4qhTZ1ip6C0RtP7Z+4VzRLWZZFKqbbjo=
+github.com/labstack/gommon v0.4.0 h1:y7cvthEAEbU0yHOf4axH8ZG2NH8knB9iNSoTO8dyIk8=
+github.com/labstack/gommon v0.4.0/go.mod h1:uW6kP17uPlLJsD3ijUYn3/M5bAxtlZhMI6m3MFxTMTM=
 github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/lib/pq v1.1.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
@@ -299,13 +312,20 @@ github.com/lib/pq v1.10.2 h1:AqzbZs4ZoCBp+GtejcpCpcxM3zlSMx29dXbUSeVtJb8=
 github.com/lib/pq v1.10.2/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
 github.com/magiconair/properties v1.8.0 h1:LLgXmsheXeRoUOBOjtwPQCWIYqM/LU1ayDtDePerRcY=
 github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
+github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
+github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e h1:hB2xlXdHp/pmPZq0y3QnmWAArdw9PqbmotexnWx/FU8=
+github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
 github.com/manifoldco/promptui v0.9.0 h1:3V4HzJk1TtXW1MTZMP7mdlwbBpIinw3HztaIlYthEiA=
 github.com/manifoldco/promptui v0.9.0/go.mod h1:ka04sppxSGFAtxX0qhlYQjISsg9mR4GWtQEhdbn6Pgg=
 github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ=
 github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-colorable v0.1.11 h1:nQ+aFkoE2TMGc0b68U2OKSexC+eq46+XwZzWXHRmPYs=
+github.com/mattn/go-colorable v0.1.11/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
 github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
 github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
+github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
 github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
@@ -317,6 +337,8 @@ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJ
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 h1:RWengNIwukTxcDr9M+97sNutRR1RKhG96O6jWumTTnw=
+github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826/go.mod h1:TaXosZuwdSHYgviHp1DAtfrULt5eUgsSMsZf+YrPgl8=
 github.com/mrunalp/fileutils v0.5.0/go.mod h1:M1WthSahJixYnrXQl/DFQuteStB1weuxD2QJNHXfbSQ=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
@@ -412,6 +434,10 @@ github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
 github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635/go.mod h1:hkRG7XYTFWNJGYcbNJQlaLq0fg1yr4J4t/NcTQtrfww=
 github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
 github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
+github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
+github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasttemplate v1.2.1 h1:TVEnxayobAdVkhQfrfes2IzOB6o+z4roRkPF52WA1u4=
+github.com/valyala/fasttemplate v1.2.1/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
 github.com/vishvananda/netlink v1.1.0/go.mod h1:cTgwzPIzzgDAYoQrMm0EdrjRUBkTqKYppBueQtXaqoE=
 github.com/vishvananda/netns v0.0.0-20191106174202-0a2b9b5464df/go.mod h1:JP3t17pCcGlemwknint6hfoeCVQrEMVwxRLRjXpq+BU=
 github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
@@ -600,8 +626,11 @@ golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210906170528-6f6e22806c34/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211103235746-7861aae1554b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211116061358-0a5406a5449c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220405210540-1e041c57c461 h1:kHVeDEnfKn3T238CvrUcz6KeEsFHVaKh4kMTt6Wsysg=
@@ -781,6 +810,8 @@ gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo=
diff --git a/persistence/debug.go b/persistence/debug.go
index 9529720d9..64e36a241 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -1,11 +1,13 @@
 package persistence
 
 import (
+	"crypto/sha256"
 	"fmt"
 	"log"
 	"os"
 	"strings"
 
+	"github.com/celestiaorg/smt"
 	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/debug"
@@ -111,12 +113,18 @@ func (m *persistenceModule) clearState(_ *debug.DebugMessage) error {
 	}
 
 	for treeType := merkleTree(0); treeType < numMerkleTrees; treeType++ {
-		if err := m.stateTrees.valueStores[treeType].ClearAll(); err != nil {
+		valueStore := m.stateTrees.valueStores[treeType]
+		nodeStore := m.stateTrees.nodeStores[treeType]
+
+		if err := valueStore.ClearAll(); err != nil {
+			return err
+		}
+		if err := nodeStore.ClearAll(); err != nil {
 			return err
 		}
-		// if err := m.stateTrees.nodeStores[treeType].ClearAll(); err != nil {
-		// 	return err
-		// }
+
+		// Needed in order to make sure the root is re-set correctly after clearing
+		m.stateTrees.merkleTrees[treeType] = smt.NewSparseMerkleTree(valueStore, nodeStore, sha256.New())
 	}
 
 	log.Println("Cleared all the state")
diff --git a/persistence/docs/PROTOCOL_STATE_HASH.md b/persistence/docs/PROTOCOL_STATE_HASH.md
new file mode 100644
index 000000000..fc5fabb46
--- /dev/null
+++ b/persistence/docs/PROTOCOL_STATE_HASH.md
@@ -0,0 +1,51 @@
+# AppHash <!-- omit in toc -->
+
+This document describes the persistence module internal implementation of how the state hash is updated. Specifically, what happens once the `UpdateStateHash` function in [persistence module interface](../../shared/modules/persistence_module.go) is called.
+
+## Update State Hash
+
+This flow shows the interaction between the PostgresDB and MerkleTrees to compute the state hash.
+
+```mermaid
+sequenceDiagram
+    participant P as Persistence Module
+    participant PP as Persistence (SQLDatabase)
+    participant PM as Persistence (MerkleTree)
+
+    loop for each protocol actor type
+        P->>+PP: GetActorsUpdated(height)
+        PP->>-P: actors
+        loop for each state tree
+            P->>+PM: Update(addr, serialized(actor))
+            PM->>-P: result, err_code
+        end
+        P->>+PM: GetRoot()
+        PM->>-P: rootHash
+    end
+
+    P->>P: stateHash = hash(aggregated(rootHashes))
+    activate P
+    deactivate P
+```
+
+## Store Block
+
+This flow shows the interaction between the PostgresDB and Key-Value Store to compute the state hash.
+
+```mermaid
+sequenceDiagram
+    %% autonumber
+    participant P as Persistence
+    participant PP as Persistence (PostgresDB)
+    participant PK as Persistence (Key-Value Store)
+
+    activate P
+    P->>P: reap stored transactions
+    P->>P: prepare, serialize <br> & store block
+    deactivate P
+
+    P->>+PP: insertBlock(height, serialized(block))
+    PP->>-P: result, err_code
+    P->>+PK: Put(height, serialized(block))
+    PK->>-P: result, err_code
+```
diff --git a/persistence/state.go b/persistence/state.go
index 36d04c563..aacca49c1 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -310,6 +310,7 @@ func (p *PostgresContext) updatePoolTrees(height int64) error {
 			return err
 		}
 
+		fmt.Println(pool)
 		if _, err := p.stateTrees.merkleTrees[poolMerkleTree].Update(bzAddr, accBz); err != nil {
 			return err
 		}
diff --git a/persistence/test/benchmark_state_test.go b/persistence/test/benchmark_state_test.go
index 057dc4912..3aadbdc93 100644
--- a/persistence/test/benchmark_state_test.go
+++ b/persistence/test/benchmark_state_test.go
@@ -1,6 +1,7 @@
 package test
 
 import (
+	"encoding/hex"
 	"fmt"
 	"io/ioutil"
 	"log"
@@ -8,6 +9,7 @@ import (
 	"os"
 	"reflect"
 	"regexp"
+	"strconv"
 	"testing"
 
 	"github.com/pokt-network/pocket/persistence"
@@ -16,7 +18,8 @@ import (
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
-var re = regexp.MustCompile(`^[Insert|Update|Set|Add|Subtract]`)
+// var isModifierRe = regexp.MustCompile(`^(Insert|Update|Set|Add|Subtract)`)
+var isModifierRe = regexp.MustCompile(`^(Insert|Set|Add|Subtract)`)
 
 func BenchmarkStateHash(b *testing.B) {
 	log.SetOutput(ioutil.Discard)
@@ -32,6 +35,7 @@ func BenchmarkStateHash(b *testing.B) {
 		}); err != nil {
 			log.Fatalf("Error clearing state: %v\n", err)
 		}
+
 	})
 
 	// Rather than using `b.N` and the `-benchtime` flag, we use a fixed number of iterations
@@ -56,7 +60,7 @@ func BenchmarkStateHash(b *testing.B) {
 			for h := int64(0); h < numHeights; h++ {
 				db := NewTestPostgresContext(b, h)
 				for i := int64(0); i < numTxPerHeight; i++ {
-					callRandomModifierFunc(db, h)
+					callRandomDatabaseModifierFunc(db, h, false)
 					db.StoreTransaction(modules.TxResult(getRandomTxResult(h)))
 				}
 				db.UpdateAppHash()
@@ -66,25 +70,36 @@ func BenchmarkStateHash(b *testing.B) {
 	}
 }
 
-func callRandomModifierFunc(p *persistence.PostgresContext, height int64) error {
+// Calls a random database modifier function on the given persistence context
+func callRandomDatabaseModifierFunc(
+	p *persistence.PostgresContext,
+	height int64,
+	mustSucceed bool,
+) (string, []reflect.Value, error) {
 	t := reflect.TypeOf(modules.PersistenceWriteContext(p))
+	numMethods := t.NumMethod()
 
+	// Select a random method and loops until a successful invocation takes place
 MethodLoop:
-	for m := 0; m < t.NumMethod(); m++ {
-		method := t.Method(m)
+	for {
+		method := t.Method(rand.Intn(numMethods))
 		methodName := method.Name
+		numArgs := method.Type.NumIn()
 
-		if !re.MatchString(methodName) {
+		// Preliminary filter to determine which functions we're interested in trying to call
+		if !isModifierRe.MatchString(methodName) {
 			continue
 		}
 
+		// Build a random set of arguments to pass to the function being called
 		var callArgs []reflect.Value
-		for i := 1; i < method.Type.NumIn(); i++ {
+		for i := 1; i < numArgs; i++ {
 			var v reflect.Value
 			arg := method.Type.In(i)
 			switch arg.Kind() {
 			case reflect.String:
-				v = reflect.ValueOf(getRandomString(50))
+				// String values in modifier functions are usually amounts
+				v = reflect.ValueOf(getRandomIntString(1000000))
 			case reflect.Slice:
 				switch arg.Elem().Kind() {
 				case reflect.Uint8:
@@ -92,7 +107,7 @@ MethodLoop:
 				case reflect.String:
 					v = reflect.ValueOf([]string{"abc"})
 				default:
-					continue MethodLoop
+					continue MethodLoop // IMPROVE: Slices of other types not supported yet
 				}
 			case reflect.Bool:
 				v = reflect.ValueOf(rand.Intn(2) == 1)
@@ -107,15 +122,21 @@ MethodLoop:
 			case reflect.Pointer:
 				fallthrough
 			default:
-				continue MethodLoop
+				continue MethodLoop // IMPROVE: Other types not supported yet
 			}
 			callArgs = append(callArgs, v)
 		}
-		// fmt.Println(methodName, "~~~", method.Type.NumIn(), callArgs)
-		// return reflect.ValueOf(p).MethodByName(method.Name).Call(callArgs)
-		reflect.ValueOf(p).MethodByName(method.Name).Call(callArgs)
+		res := reflect.ValueOf(p).MethodByName(method.Name).Call(callArgs)
+		var err error
+		if v := res[0].Interface(); v != nil {
+			if mustSucceed {
+				fmt.Println("OLSH SKIP")
+				continue MethodLoop
+			}
+			err = v.(error)
+		}
+		return methodName, callArgs, err
 	}
-	return nil
 }
 
 func getRandomTxResult(height int64) *indexer.TxRes {
@@ -131,6 +152,10 @@ func getRandomTxResult(height int64) *indexer.TxRes {
 	}
 }
 
+func getRandomIntString(n int) string {
+	return strconv.Itoa(rand.Intn(n))
+}
+
 func getRandomString(numChars int64) string {
 	return string(getRandomBytes(numChars))
 }
@@ -138,5 +163,5 @@ func getRandomString(numChars int64) string {
 func getRandomBytes(numBytes int64) []byte {
 	bz := make([]byte, numBytes)
 	rand.Read(bz)
-	return bz
+	return []byte(hex.EncodeToString(bz))
 }
diff --git a/persistence/test/setup_test.go b/persistence/test/setup_test.go
index 5db7f067c..d1ffc6e46 100644
--- a/persistence/test/setup_test.go
+++ b/persistence/test/setup_test.go
@@ -70,18 +70,17 @@ func NewTestPostgresContext(t testing.TB, height int64) *persistence.PostgresCon
 		log.Fatalf("Error casting RW context to Postgres context")
 	}
 
-	t.Cleanup(func() {
-		if err := testPersistenceMod.ReleaseWriteContext(); err != nil {
-			log.Fatalf("Error releasing write context: %v\n", err)
-		}
-		if err := testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
-			// Action: debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
-			Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_RESET_TO_GENESIS,
-			Message: nil,
-		}); err != nil {
-			log.Fatalf("Error clearing state: %v\n", err)
-		}
-	})
+	// t.Cleanup(func() {
+	if err := testPersistenceMod.ReleaseWriteContext(); err != nil {
+		log.Fatalf("Error releasing write context: %v\n", err)
+	}
+	if err := testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
+		Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_RESET_TO_GENESIS,
+		Message: nil,
+	}); err != nil {
+		log.Fatalf("Error clearing state: %v\n", err)
+	}
+	// })
 
 	return db
 }
@@ -327,3 +326,27 @@ func getRandomBigIntString() string {
 func setRandomSeed() {
 	rand.Seed(time.Now().UnixNano())
 }
+
+func resetToGenesis() {
+	if err := testPersistenceMod.ReleaseWriteContext(); err != nil {
+		log.Fatalf("Error releasing write context: %v\n", err)
+	}
+	if err := testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
+		Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_RESET_TO_GENESIS,
+		Message: nil,
+	}); err != nil {
+		log.Fatalf("Error clearing state: %v\n", err)
+	}
+}
+
+func clearAllState() {
+	if err := testPersistenceMod.ReleaseWriteContext(); err != nil {
+		log.Fatalf("Error releasing write context: %v\n", err)
+	}
+	if err := testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
+		Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
+		Message: nil,
+	}); err != nil {
+		log.Fatalf("Error clearing state: %v\n", err)
+	}
+}
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index 466cc8947..62d20d15c 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -3,12 +3,16 @@ package test
 import (
 	"encoding/binary"
 	"encoding/hex"
+	"fmt"
+	"log"
+	"reflect"
 	"strconv"
 	"testing"
 
 	"github.com/pokt-network/pocket/persistence/indexer"
 	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/codec"
+	"github.com/pokt-network/pocket/shared/debug"
 	"github.com/pokt-network/pocket/shared/modules"
 	"github.com/stretchr/testify/require"
 )
@@ -105,6 +109,114 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 	}
 }
 
+type TestReplayableOperation struct {
+	methodName string
+	args       []reflect.Value
+}
+type TestReplayableTransaction struct {
+	operations []*TestReplayableOperation
+	txResult   modules.TxResult
+}
+
+type TestReplayableBlock struct {
+	height int64
+	txs    []*TestReplayableTransaction
+	hash   []byte
+}
+
+func TestStateHash_RandomButDeterministic(t *testing.T) {
+
+	// t.Cleanup(func() {
+	// 	if err := testPersistenceMod.ReleaseWriteContext(); err != nil {
+	// 		log.Fatalf("Error releasing write context: %v\n", err)
+	// 	}
+	// 	if err := testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
+	// 		Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
+	// 		Message: nil,
+	// 	}); err != nil {
+	// 		log.Fatalf("Error clearing state: %v\n", err)
+	// 	}
+	// })
+
+	if err := testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
+		Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
+		Message: nil,
+	}); err != nil {
+		log.Fatalf("Error clearing state: %v\n", err)
+	}
+	testPersistenceMod.ReleaseWriteContext()
+
+	numHeights := 10
+	numTxsPerHeight := 1
+	numOpsPerTx := 1
+
+	replayableBlocks := make([]*TestReplayableBlock, numHeights)
+	for height := int64(0); height < int64(numHeights); height++ {
+		db := NewTestPostgresContext(t, height)
+		replayableTxs := make([]*TestReplayableTransaction, numTxsPerHeight)
+		for txIdx := 0; txIdx < numTxsPerHeight; txIdx++ {
+			replayableOps := make([]*TestReplayableOperation, numOpsPerTx)
+			for opIdx := 0; opIdx < numOpsPerTx; opIdx++ {
+				methodName, args, err := callRandomDatabaseModifierFunc(db, height, true)
+				require.NoError(t, err)
+				replayableOps[opIdx] = &TestReplayableOperation{
+					methodName: methodName,
+					args:       args,
+				}
+				fmt.Println("OLSH", methodName, args)
+			}
+			txResult := modules.TxResult(getRandomTxResult(height))
+			err := db.StoreTransaction(txResult)
+			require.NoError(t, err)
+
+			replayableTxs[txIdx] = &TestReplayableTransaction{
+				operations: replayableOps,
+				txResult:   txResult,
+			}
+		}
+		appHash, err := db.UpdateAppHash()
+		require.NoError(t, err)
+
+		err = db.Commit([]byte("TODOproposer"), []byte("TODOquorumCert"))
+		require.NoError(t, err)
+
+		replayableBlocks[height] = &TestReplayableBlock{
+			height: height,
+			txs:    replayableTxs,
+			hash:   appHash,
+		}
+	}
+
+	verifyReplayableBlocks(t, replayableBlocks)
+}
+
+func verifyReplayableBlocks(t *testing.T, replayableBlocks []*TestReplayableBlock) {
+	if err := testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
+		Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
+		Message: nil,
+	}); err != nil {
+		log.Fatalf("Error clearing state: %v\n", err)
+	}
+	testPersistenceMod.ReleaseWriteContext()
+
+	for _, block := range replayableBlocks {
+		db := NewTestPostgresContext(t, block.height)
+		for _, tx := range block.txs {
+			for _, op := range tx.operations {
+				require.Nil(t, reflect.ValueOf(db).MethodByName(op.methodName).Call(op.args)[0].Interface())
+				fmt.Println("OLSH", op.methodName, op.args)
+			}
+			require.NoError(t, db.StoreTransaction(tx.txResult))
+		}
+		appHash, err := db.UpdateAppHash()
+		require.NoError(t, err)
+		require.Equal(t, block.hash, appHash)
+
+		err = db.Commit([]byte("TODOproposer"), []byte("TODOquorumCert"))
+		require.NoError(t, err)
+	}
+}
+
 func heightToBytes(height int64) []byte {
 	heightBytes := make([]byte, 8)
 	binary.LittleEndian.PutUint64(heightBytes, uint64(height))

From 3d86e23e641ee71c0f946a5aa280089efa8269e4 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky@pokt.network>
Date: Mon, 7 Nov 2022 16:25:40 -0800
Subject: [PATCH 129/227] Update persistence/module.go

Co-authored-by: Andrew Nguyen <amnguyen1@mail.usf.edu>
---
 persistence/module.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/persistence/module.go b/persistence/module.go
index fa8db1744..ac851233a 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -214,7 +214,7 @@ func (m *persistenceModule) shouldHydrateGenesisDb() (bool, error) {
 	}
 	defer checkContext.Close()
 
-	_, err = checkContext.GetLatestBlockHeight()
+	if _, err = checkContext.GetLatestBlockHeight(); err != nil {
 	if err != nil {
 		return true, nil
 	}

From 878501c553f1d2aa17445e5a3a72e363bf0d075e Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky@pokt.network>
Date: Mon, 7 Nov 2022 16:28:14 -0800
Subject: [PATCH 130/227] Update persistence/module.go

Co-authored-by: Andrew Nguyen <amnguyen1@mail.usf.edu>
---
 persistence/module.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/persistence/module.go b/persistence/module.go
index ac851233a..3c30fc366 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -215,7 +215,6 @@ func (m *persistenceModule) shouldHydrateGenesisDb() (bool, error) {
 	defer checkContext.Close()
 
 	if _, err = checkContext.GetLatestBlockHeight(); err != nil {
-	if err != nil {
 		return true, nil
 	}
 	return false, nil

From 03c4bc7d7914b2343424911549aefc419785e0e4 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 7 Nov 2022 20:37:47 -0800
Subject: [PATCH 131/227] Minor release fixes

---
 consensus/block.go | 10 +++++-----
 utility/context.go | 15 ++++++++++++---
 2 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/consensus/block.go b/consensus/block.go
index b7c338b54..3ad4f327e 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -8,15 +8,15 @@ import (
 )
 
 func (m *consensusModule) commitBlock(block *typesCons.Block) error {
-	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
-
-	// Commit and release the context
+	// Commit the context
 	if err := m.utilityContext.Commit(block.BlockHeader.QuorumCertificate); err != nil {
 		return err
 	}
+	m.nodeLog(typesCons.CommittingBlock(m.Height, len(block.Transactions)))
 
+	// Release the context
 	if err := m.utilityContext.Release(); err != nil {
-		return err
+		log.Println("[WARN] Error releasing utility context: ", err)
 	}
 	m.utilityContext = nil
 
@@ -58,7 +58,7 @@ func (m *consensusModule) refreshUtilityContext() error {
 	if m.utilityContext != nil {
 		m.nodeLog(typesCons.NilUtilityContextWarning)
 		if err := m.utilityContext.Release(); err != nil {
-			log.Printf("[ERROR] Error releasing utility context: %v\n", err)
+			log.Printf("[WARN] Error releasing utility context: %v\n", err)
 		}
 		m.utilityContext = nil
 	}
diff --git a/utility/context.go b/utility/context.go
index b0dfb47c2..c1dc7c39d 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -45,13 +45,22 @@ func (u *UtilityContext) GetPersistenceContext() modules.PersistenceRWContext {
 }
 
 func (u *UtilityContext) Commit(quorumCert []byte) error {
-	return u.Context.PersistenceRWContext.Commit(quorumCert)
+	if err := u.Context.PersistenceRWContext.Commit(quorumCert); err != nil {
+		return err
+	}
+	u.Context = nil
+	return nil
 }
 
 func (u *UtilityContext) Release() error {
-	err := u.Context.Release()
+	if u.Context == nil {
+		return nil
+	}
+	if err := u.Context.Release(); err != nil {
+		return err
+	}
 	u.Context = nil
-	return err
+	return nil
 }
 
 func (u *UtilityContext) GetLatestBlockHeight() (int64, typesUtil.Error) {

From 27f803d7a28b6af783973cf253d0cec4b8dd57bc Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 7 Nov 2022 20:52:41 -0800
Subject: [PATCH 132/227] Finally got TestStateHash_RandomButDeterministic to
 pass

---
 persistence/debug.go                     |  3 +-
 persistence/state.go                     |  1 -
 persistence/test/benchmark_state_test.go | 15 +-----
 persistence/test/module_test.go          | 18 ++-----
 persistence/test/setup_test.go           | 24 ++-------
 persistence/test/state_test.go           | 69 +++++++++---------------
 6 files changed, 36 insertions(+), 94 deletions(-)

diff --git a/persistence/debug.go b/persistence/debug.go
index 64e36a241..1f878687c 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -2,7 +2,6 @@ package persistence
 
 import (
 	"crypto/sha256"
-	"fmt"
 	"log"
 	"os"
 	"strings"
@@ -86,7 +85,7 @@ func (m *persistenceModule) exportTrees(_ *debug.DebugMessage) error {
 		f.Write([]byte(sb.String()))
 		f.Close()
 	}
-	fmt.Println("Wrote trees to /tmp/trees/")
+	log.Println("Trees exported to /tmp/trees/")
 	return nil
 }
 
diff --git a/persistence/state.go b/persistence/state.go
index aacca49c1..36d04c563 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -310,7 +310,6 @@ func (p *PostgresContext) updatePoolTrees(height int64) error {
 			return err
 		}
 
-		fmt.Println(pool)
 		if _, err := p.stateTrees.merkleTrees[poolMerkleTree].Update(bzAddr, accBz); err != nil {
 			return err
 		}
diff --git a/persistence/test/benchmark_state_test.go b/persistence/test/benchmark_state_test.go
index 3aadbdc93..3f6911f65 100644
--- a/persistence/test/benchmark_state_test.go
+++ b/persistence/test/benchmark_state_test.go
@@ -14,7 +14,6 @@ import (
 
 	"github.com/pokt-network/pocket/persistence"
 	"github.com/pokt-network/pocket/persistence/indexer"
-	"github.com/pokt-network/pocket/shared/debug"
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
@@ -25,18 +24,7 @@ func BenchmarkStateHash(b *testing.B) {
 	log.SetOutput(ioutil.Discard)
 	defer log.SetOutput(os.Stderr)
 
-	b.Cleanup(func() {
-		if err := testPersistenceMod.ReleaseWriteContext(); err != nil {
-			log.Fatalf("Error releasing write context: %v\n", err)
-		}
-		if err := testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
-			Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
-			Message: nil,
-		}); err != nil {
-			log.Fatalf("Error clearing state: %v\n", err)
-		}
-
-	})
+	b.Cleanup(clearAllState)
 
 	// Rather than using `b.N` and the `-benchtime` flag, we use a fixed number of iterations
 	testCases := []struct {
@@ -130,7 +118,6 @@ MethodLoop:
 		var err error
 		if v := res[0].Interface(); v != nil {
 			if mustSucceed {
-				fmt.Println("OLSH SKIP")
 				continue MethodLoop
 			}
 			err = v.(error)
diff --git a/persistence/test/module_test.go b/persistence/test/module_test.go
index 02354cf78..f5f0916dd 100644
--- a/persistence/test/module_test.go
+++ b/persistence/test/module_test.go
@@ -3,7 +3,6 @@ package test
 import (
 	"testing"
 
-	"github.com/pokt-network/pocket/shared/debug"
 	"github.com/stretchr/testify/require"
 )
 
@@ -113,18 +112,7 @@ func TestPersistenceContextMultipleParallelReads(t *testing.T) {
 
 func prepareAndCleanContext(t *testing.T) {
 	// Cleanup context after the test
-	t.Cleanup(func() {
-		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
-		require.NoError(t, testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
-			Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
-			Message: nil,
-		}))
-	})
-
-	// Make sure the db is empty at the start of these tests
-	require.NoError(t, testPersistenceMod.ReleaseWriteContext())
-	require.NoError(t, testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
-		Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
-		Message: nil,
-	}))
+	t.Cleanup(clearAllState)
+
+	clearAllState()
 }
diff --git a/persistence/test/setup_test.go b/persistence/test/setup_test.go
index d1ffc6e46..4ff143d1a 100644
--- a/persistence/test/setup_test.go
+++ b/persistence/test/setup_test.go
@@ -70,17 +70,9 @@ func NewTestPostgresContext(t testing.TB, height int64) *persistence.PostgresCon
 		log.Fatalf("Error casting RW context to Postgres context")
 	}
 
-	// t.Cleanup(func() {
-	if err := testPersistenceMod.ReleaseWriteContext(); err != nil {
-		log.Fatalf("Error releasing write context: %v\n", err)
-	}
-	if err := testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
-		Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_RESET_TO_GENESIS,
-		Message: nil,
-	}); err != nil {
-		log.Fatalf("Error clearing state: %v\n", err)
-	}
-	// })
+	// TODO_IN_THIS_COMMIT: This should not be part of `NewTestPostgresContext`. It causes unnecessary resets
+	// if we call `NewTestPostgresContext` more than once in a single test.
+	t.Cleanup(resetStateToGenesis)
 
 	return db
 }
@@ -116,13 +108,7 @@ func fuzzSingleProtocolActor(
 	protocolActorSchema types.ProtocolActorSchema,
 ) {
 	// Clear the genesis state.
-	if err := testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
-		Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
-		Message: nil,
-	}); err != nil {
-		log.Fatalf("Error clearing state: %v\n", err)
-	}
-
+	clearAllState()
 	db := NewTestPostgresContext(f, 0)
 
 	actor, err := newTestActor()
@@ -327,7 +313,7 @@ func setRandomSeed() {
 	rand.Seed(time.Now().UnixNano())
 }
 
-func resetToGenesis() {
+func resetStateToGenesis() {
 	if err := testPersistenceMod.ReleaseWriteContext(); err != nil {
 		log.Fatalf("Error releasing write context: %v\n", err)
 	}
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index 62d20d15c..56cd2b8ce 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -3,8 +3,6 @@ package test
 import (
 	"encoding/binary"
 	"encoding/hex"
-	"fmt"
-	"log"
 	"reflect"
 	"strconv"
 	"testing"
@@ -12,7 +10,6 @@ import (
 	"github.com/pokt-network/pocket/persistence/indexer"
 	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/codec"
-	"github.com/pokt-network/pocket/shared/debug"
 	"github.com/pokt-network/pocket/shared/modules"
 	"github.com/stretchr/testify/require"
 )
@@ -119,36 +116,21 @@ type TestReplayableTransaction struct {
 }
 
 type TestReplayableBlock struct {
-	height int64
-	txs    []*TestReplayableTransaction
-	hash   []byte
+	height     int64
+	txs        []*TestReplayableTransaction
+	hash       []byte
+	proposer   []byte
+	quorumCert []byte
 }
 
 func TestStateHash_RandomButDeterministic(t *testing.T) {
-
-	// t.Cleanup(func() {
-	// 	if err := testPersistenceMod.ReleaseWriteContext(); err != nil {
-	// 		log.Fatalf("Error releasing write context: %v\n", err)
-	// 	}
-	// 	if err := testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
-	// 		Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
-	// 		Message: nil,
-	// 	}); err != nil {
-	// 		log.Fatalf("Error clearing state: %v\n", err)
-	// 	}
-	// })
-
-	if err := testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
-		Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
-		Message: nil,
-	}); err != nil {
-		log.Fatalf("Error clearing state: %v\n", err)
-	}
-	testPersistenceMod.ReleaseWriteContext()
+	t.Cleanup(clearAllState)
+	clearAllState()
 
 	numHeights := 10
-	numTxsPerHeight := 1
-	numOpsPerTx := 1
+	numTxsPerHeight := 2
+	numOpsPerTx := 5
+	numReplays := 5
 
 	replayableBlocks := make([]*TestReplayableBlock, numHeights)
 	for height := int64(0); height < int64(numHeights); height++ {
@@ -163,7 +145,6 @@ func TestStateHash_RandomButDeterministic(t *testing.T) {
 					methodName: methodName,
 					args:       args,
 				}
-				fmt.Println("OLSH", methodName, args)
 			}
 			txResult := modules.TxResult(getRandomTxResult(height))
 			err := db.StoreTransaction(txResult)
@@ -177,34 +158,36 @@ func TestStateHash_RandomButDeterministic(t *testing.T) {
 		appHash, err := db.UpdateAppHash()
 		require.NoError(t, err)
 
-		err = db.Commit([]byte("TODOproposer"), []byte("TODOquorumCert"))
+		proposer := getRandomBytes(10)
+		quorumCert := getRandomBytes(10)
+		err = db.Commit(proposer, quorumCert)
 		require.NoError(t, err)
 
 		replayableBlocks[height] = &TestReplayableBlock{
-			height: height,
-			txs:    replayableTxs,
-			hash:   appHash,
+			height:     height,
+			txs:        replayableTxs,
+			hash:       appHash,
+			proposer:   proposer,
+			quorumCert: quorumCert,
 		}
 	}
 
-	verifyReplayableBlocks(t, replayableBlocks)
+	for i := 0; i < numReplays; i++ {
+		t.Run("verify block", func(t *testing.T) {
+			verifyReplayableBlocks(t, replayableBlocks)
+		})
+	}
 }
 
 func verifyReplayableBlocks(t *testing.T, replayableBlocks []*TestReplayableBlock) {
-	if err := testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{
-		Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
-		Message: nil,
-	}); err != nil {
-		log.Fatalf("Error clearing state: %v\n", err)
-	}
-	testPersistenceMod.ReleaseWriteContext()
+	t.Cleanup(clearAllState)
+	clearAllState()
 
 	for _, block := range replayableBlocks {
 		db := NewTestPostgresContext(t, block.height)
 		for _, tx := range block.txs {
 			for _, op := range tx.operations {
 				require.Nil(t, reflect.ValueOf(db).MethodByName(op.methodName).Call(op.args)[0].Interface())
-				fmt.Println("OLSH", op.methodName, op.args)
 			}
 			require.NoError(t, db.StoreTransaction(tx.txResult))
 		}
@@ -212,7 +195,7 @@ func verifyReplayableBlocks(t *testing.T, replayableBlocks []*TestReplayableBloc
 		require.NoError(t, err)
 		require.Equal(t, block.hash, appHash)
 
-		err = db.Commit([]byte("TODOproposer"), []byte("TODOquorumCert"))
+		err = db.Commit(block.proposer, block.quorumCert)
 		require.NoError(t, err)
 	}
 }

From ccf240e02abce7da064ef19fd8e75e769442fac4 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 8 Nov 2022 15:33:22 -0800
Subject: [PATCH 133/227] Minor code cleanup - about to remove
 SetLatestTxResults

---
 Makefile                                 | 10 ++---
 app/client/cli/debug.go                  |  2 +-
 app/client/main.go                       |  3 +-
 consensus/block.go                       |  7 +---
 persistence/block.go                     | 51 ++++++++++++++----------
 persistence/test/benchmark_state_test.go |  2 +
 persistence/test/state_test.go           |  6 +--
 utility/block.go                         |  2 +-
 8 files changed, 45 insertions(+), 38 deletions(-)

diff --git a/Makefile b/Makefile
index d961ae8f7..9c4ce32fb 100644
--- a/Makefile
+++ b/Makefile
@@ -178,7 +178,7 @@ db_bench: docker_check
 	docker exec -it pocket-db bash -c "pgbench -U postgres -d postgres"
 
 .PHONY: db_show_schemas
-## Show all the node schemas in the local DB
+## Show all the node schemas in the local SQL DB
 db_show_schemas: docker_check
 	docker exec -it pocket-db bash -c "psql -U postgres -d postgres -a -f /tmp/scripts/show_all_schemas.sql"
 
@@ -187,9 +187,9 @@ db_show_schemas: docker_check
 db_admin:
 	echo "Open http://0.0.0.0:5050 and login with 'pgadmin4@pgadmin.org' and 'pgadmin4'.\n The password is 'postgres'"
 
-# IMPROVE: Make this part of the CLI
+# TODO_IN_THIS_COMMIT: Move this out into a separate task
 .PHONY: db_export_trees
-## Assuming `ExportTrees` was from the client, this will copy those json files locally from node1 to local
+## Copy the trees in `node1` from docker to the host machine - assumes `ExportTrees` was executed from the debug client
 db_export_trees:
 	echo "Copying trees from node1.consensus to /tmp/node1_trees"
 	docker cp node1.consensus:/tmp/trees /tmp/node1_trees
@@ -379,10 +379,10 @@ test_p2p_raintree:
 test_p2p_raintree_addrbook:
 	go test ${VERBOSE_TEST} -run RainTreeAddrBook -count=1 ./p2p/...
 
-# For benchmarks, consider appending `-run=^#` to avoid running unit tests in the same package
+# TIP: For benchmarks, consider appending `-run=^#` to avoid running unit tests in the same package
 
 .PHONY: benchmark_persistence_state_hash
-## Benchmark the State Hash
+## Benchmark the state hash computation
 benchmark_persistence_state_hash:
 	go test ${VERBOSE_TEST} -bench=. -run BenchmarkStateHash -count=1 ./persistence/...
 
diff --git a/app/client/cli/debug.go b/app/client/cli/debug.go
index 699a7c360..b1a1b918c 100644
--- a/app/client/cli/debug.go
+++ b/app/client/cli/debug.go
@@ -21,7 +21,7 @@ import (
 	"google.golang.org/protobuf/types/known/anypb"
 )
 
-// TODO(olshansky): Lowercase variables / constants that do not need to be exported.
+// TECHDEBT: Lowercase variables / constants that do not need to be exported.
 const (
 	PromptResetToGenesis         string = "ResetToGenesis (broadcast)"
 	PromptPrintNodeState         string = "PrintNodeState (broadcast)"
diff --git a/app/client/main.go b/app/client/main.go
index f67f61246..bad39ccab 100644
--- a/app/client/main.go
+++ b/app/client/main.go
@@ -2,11 +2,12 @@ package main
 
 import (
 	"context"
-	"github.com/pokt-network/pocket/app/client/cli"
 	"log"
 	"os"
 	"os/signal"
 	"syscall"
+
+	"github.com/pokt-network/pocket/app/client/cli"
 )
 
 func main() {
diff --git a/consensus/block.go b/consensus/block.go
index 5afc3583e..2008308a1 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -57,14 +57,11 @@ func (m *consensusModule) refreshUtilityContext() error {
 	// Ideally, this should not be called.
 	if m.utilityContext != nil {
 		m.nodeLog(typesCons.NilUtilityContextWarning)
-		var err error
-		if err := m.utilityContext.Release(); err != nil {
+		err := m.utilityContext.Release()
+		if err != nil {
 			log.Printf("[WARN] Error releasing utility context: %v\n", err)
 		}
 		m.utilityContext = nil
-		if err != nil {
-			return err
-		}
 	}
 
 	utilityContext, err := m.GetBus().GetUtilityModule().NewContext(int64(m.Height))
diff --git a/persistence/block.go b/persistence/block.go
index 6539fdb8e..c34ecc7c0 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -104,36 +104,25 @@ func (p *PostgresContext) prepareBlock(quorumCert []byte) (*types.Block, error)
 	if p.Height == 0 {
 		prevHash = []byte("")
 	} else {
-		prevHash = []byte("11")
-		// var err error
-		// prevHash, err = p.GetBlockHash(p.Height - 1)
-		// if err != nil {
-		// 	return nil, err
-		// }
+		var err error
+		prevHash, err = p.GetBlockHash(p.Height - 1)
+		if err != nil {
+			return nil, err
+		}
 	}
 
-	// The order (descending) is important here since it is used to comprise the hash in the block
-	txResults, err := p.txIndexer.GetByHeight(p.Height, false)
+	txsHash, err := p.getTxsHash(p.Height)
 	if err != nil {
 		return nil, err
 	}
 
-	txs := make([]byte, 0)
-	for _, txResult := range txResults {
-		txHash, err := txResult.Hash()
-		if err != nil {
-			return nil, err
-		}
-		txs = append(txs, txHash...)
-	}
-
 	block := &types.Block{
 		Height:            uint64(p.Height),
-		Hash:              "aaa", //hex.EncodeToString(p.currentStateHash),
+		Hash:              hex.EncodeToString(p.currentStateHash),
 		PrevHash:          hex.EncodeToString(prevHash),
-		ProposerAddress:   []byte("abc"),        //p.proposerAddr,
-		QuorumCertificate: []byte("qc"),         //quorumCert,
-		TransactionsHash:  crypto.SHA3Hash(txs), // TODO: Externalize this elsewhere?
+		ProposerAddress:   p.proposerAddr,
+		QuorumCertificate: quorumCert,
+		TransactionsHash:  txsHash,
 	}
 
 	return block, nil
@@ -142,7 +131,6 @@ func (p *PostgresContext) prepareBlock(quorumCert []byte) (*types.Block, error)
 // Inserts the block into the postgres database
 func (p *PostgresContext) insertBlock(block *types.Block) error {
 	ctx, tx, err := p.GetCtxAndTx()
-	fmt.Println("OLSH", block.Height, block.Hash, block.ProposerAddress, block.QuorumCertificate, tx)
 	if err != nil {
 		return err
 	}
@@ -160,6 +148,25 @@ func (p PostgresContext) storeBlock(block *types.Block) error {
 	return p.blockStore.Set(heightToBytes(p.Height), blockBz)
 }
 
+func (p PostgresContext) getTxsHash(height int64) ([]byte, error) {
+	// The order (descending) is important here since it is used to comprise the hash in the block
+	txResults, err := p.txIndexer.GetByHeight(p.Height, false)
+	if err != nil {
+		return nil, err
+	}
+
+	txs := make([]byte, 0)
+	for _, txResult := range txResults {
+		txHash, err := txResult.Hash()
+		if err != nil {
+			return nil, err
+		}
+		txs = append(txs, txHash...)
+	}
+
+	return crypto.SHA3Hash(txs), nil
+}
+
 func heightToBytes(height int64) []byte {
 	heightBytes := make([]byte, 8)
 	binary.LittleEndian.PutUint64(heightBytes, uint64(height))
diff --git a/persistence/test/benchmark_state_test.go b/persistence/test/benchmark_state_test.go
index 2db1f7600..0e3020954 100644
--- a/persistence/test/benchmark_state_test.go
+++ b/persistence/test/benchmark_state_test.go
@@ -20,6 +20,8 @@ import (
 // var isModifierRe = regexp.MustCompile(`^(Insert|Update|Set|Add|Subtract)`)
 var isModifierRe = regexp.MustCompile(`^(Insert|Set|Add|Subtract)`)
 
+// INVESTIGATE: This benchmark can be used to experiment with different Merkle Tree implementations
+// and key-value stores.
 func BenchmarkStateHash(b *testing.B) {
 	log.SetOutput(ioutil.Discard)
 	defer log.SetOutput(os.Stderr)
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index afb73e96b..5265e20e6 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -126,10 +126,10 @@ func TestStateHash_RandomButDeterministic(t *testing.T) {
 	t.Cleanup(clearAllState)
 	clearAllState()
 
-	numHeights := 10
+	numHeights := 1 //10
 	numTxsPerHeight := 2
-	numOpsPerTx := 5
-	numReplays := 5
+	numOpsPerTx := 1 //5
+	numReplays := 1  //5
 
 	replayableBlocks := make([]*TestReplayableBlock, numHeights)
 	for height := int64(0); height < int64(numHeights); height++ {
diff --git a/utility/block.go b/utility/block.go
index 107295305..2252f6380 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -111,7 +111,7 @@ func (u *UtilityContext) ApplyBlock() (appHash []byte, err error) {
 		txResults = append(txResults, txResult)
 
 		// DISCUSS: What if the context is rolled back or cancelled. Do we add it back to the mempool?
-		// TODO: if found, remove transaction from mempool
+		// TODO: if found, remove transaction from mempool.
 		// if err := u.Mempool.DeleteTransaction(transaction); err != nil {
 		// 	return nil, err
 		// }

From 432d55bf8ee19cc98037cc9d6d8779bcb0d75fb3 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 8 Nov 2022 15:52:19 -0800
Subject: [PATCH 134/227] Added comments

---
 persistence/db.go                    |  4 ----
 runtime/test_artifacts/generator.go  |  2 ++
 runtime/test_artifacts/util.go       |  2 +-
 shared/modules/persistence_module.go |  2 --
 utility/block.go                     | 23 ++++++++---------------
 utility/context.go                   |  9 +++------
 6 files changed, 14 insertions(+), 28 deletions(-)

diff --git a/persistence/db.go b/persistence/db.go
index 13c740f37..a599a2576 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -99,10 +99,6 @@ func (p PostgresContext) GetLatestTxResults() []modules.TxResult {
 	return p.txResults
 }
 
-func (p *PostgresContext) SetLatestTxResults(txResults []modules.TxResult) {
-	p.txResults = txResults
-}
-
 // TECHDEBT: Implement proper connection pooling
 func connectToDatabase(postgresUrl string, schema string) (*pgx.Conn, error) {
 	ctx := context.TODO()
diff --git a/runtime/test_artifacts/generator.go b/runtime/test_artifacts/generator.go
index 08deb5c2a..43d544b20 100644
--- a/runtime/test_artifacts/generator.go
+++ b/runtime/test_artifacts/generator.go
@@ -192,6 +192,8 @@ func NewDefaultActor(actorType int32, genericParam string) (actor modules.Actor,
 	}, privKey
 }
 
+// TECHDEBT: This function has the side effect of incrementing the global variable `privateKeySeed`
+// in order to guarantee unique keys, but that are still deterministic for testing purposes.
 func generateNewKeysStrings() (privateKey, publicKey, address string) {
 	privateKeySeed += 1 // Different on every call but deterministic
 	cryptoSeed := make([]byte, crypto.SeedSize)
diff --git a/runtime/test_artifacts/util.go b/runtime/test_artifacts/util.go
index fff674db6..802035df5 100644
--- a/runtime/test_artifacts/util.go
+++ b/runtime/test_artifacts/util.go
@@ -95,6 +95,6 @@ func CleanupPostgresDocker(_ *testing.M, pool *dockertest.Pool, resource *docker
 	}
 }
 
-// TODO(olshansky): Remove this since it's no longer used or necessary.
 func CleanupTest(u utility.UtilityContext) {
+	// TODO(olshansky): Remove this since it's no longer used or necessary.
 }
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index ae3d6b534..a7344df69 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -58,8 +58,6 @@ type PersistenceWriteContext interface {
 	// Indexer Operations
 
 	// Block Operations
-	// DISCUSS_IN_THIS_COMMIT: Can this function be removed ? If so, could we remove `TxResult` from the public facing interface given that we set transactions in `SetProposalBlock`?
-	SetLatestTxResults(txResults []TxResult)
 	SetProposalBlock(blockHash string, proposerAddr []byte, transactions [][]byte) error
 	// Store the block into persistence
 	UpdateAppHash() ([]byte, error)
diff --git a/utility/block.go b/utility/block.go
index 2252f6380..770c22602 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -50,7 +50,7 @@ func (u *UtilityContext) CreateAndApplyProposalBlock(proposer []byte, maxTransac
 			if err != nil {
 				return nil, nil, err
 			}
-			txTxsSizeInBytes -= txTxsSizeInBytes
+			totalTxsSizeInBytes -= txTxsSizeInBytes
 			break // we've reached our max
 		}
 		txResult, err := u.ApplyTransaction(txIndex, transaction)
@@ -69,23 +69,23 @@ func (u *UtilityContext) CreateAndApplyProposalBlock(proposer []byte, maxTransac
 	if err := u.EndBlock(proposer); err != nil {
 		return nil, nil, err
 	}
-	u.GetPersistenceContext().SetLatestTxResults(txResults)
 	// return the app hash (consensus module will get the validator set directly)
-	appHash, err := u.GetAppHash()
+	appHash, err := u.getAppHash()
 	return appHash, transactions, err
 }
 
 // CLEANUP: code re-use ApplyBlock() for CreateAndApplyBlock()
 func (u *UtilityContext) ApplyBlock() (appHash []byte, err error) {
-	var txResults []modules.TxResult
 	lastByzantineValidators, err := u.GetLastBlockByzantineValidators()
 	if err != nil {
 		return nil, err
 	}
+
 	// begin block lifecycle phase
 	if err := u.BeginBlock(lastByzantineValidators); err != nil {
 		return nil, err
 	}
+
 	// deliver txs lifecycle phase
 	for index, transactionProtoBytes := range u.GetPersistenceContext().GetLatestBlockTxs() {
 		tx, err := typesUtil.TransactionFromBytes(transactionProtoBytes)
@@ -98,20 +98,15 @@ func (u *UtilityContext) ApplyBlock() (appHash []byte, err error) {
 		// DISCUSS(#315): Currently, the pattern is allowing nil err with an error transaction...
 		//                Should we terminate applyBlock immediately if there's an invalid transaction?
 		//                Or wait until the entire lifecycle is over to evaluate an 'invalid' block
+
 		// Validate and apply the transaction to the Postgres database
-		txResult, err := u.ApplyTransaction(index, tx)
+		_, err = u.ApplyTransaction(index, tx)
 		if err != nil {
 			return nil, err
 		}
-		// if err := u.Store().StoreTransaction(txResult); err != nil {
-		// 	return nil, nil, err
-		// }
 
-		// Add the transaction result to the array
-		txResults = append(txResults, txResult)
-
-		// DISCUSS: What if the context is rolled back or cancelled. Do we add it back to the mempool?
 		// TODO: if found, remove transaction from mempool.
+		// DISCUSS: What if the context is rolled back or cancelled. Do we add it back to the mempool?
 		// if err := u.Mempool.DeleteTransaction(transaction); err != nil {
 		// 	return nil, err
 		// }
@@ -122,7 +117,6 @@ func (u *UtilityContext) ApplyBlock() (appHash []byte, err error) {
 		return nil, err
 	}
 
-	u.GetPersistenceContext().SetLatestTxResults(txResults)
 	// return the app hash (consensus module will get the validator set directly)
 	appHash, err = u.Context.UpdateAppHash()
 	if err != nil {
@@ -157,8 +151,7 @@ func (u *UtilityContext) EndBlock(proposer []byte) typesUtil.Error {
 	return nil
 }
 
-func (u *UtilityContext) GetAppHash() ([]byte, typesUtil.Error) {
-	// DISCUSS_IN_THIS_COMMIT: Can we remove this function from the utility context?
+func (u *UtilityContext) getAppHash() ([]byte, typesUtil.Error) {
 	appHash, er := u.Context.UpdateAppHash()
 	if er != nil {
 		return nil, typesUtil.ErrAppHash(er)
diff --git a/utility/context.go b/utility/context.go
index 812f1d084..c213661d8 100644
--- a/utility/context.go
+++ b/utility/context.go
@@ -9,12 +9,9 @@ import (
 )
 
 type UtilityContext struct {
-	// TODO(#315): Should be removed by #315 before this is even done.
-	LatestHeight    int64
-	currentProposer []byte
-
-	Mempool typesUtil.Mempool
-	Context *Context // IMPROVE: Rename to `persistenceContext` or `storeContext` or `reversibleContext`?
+	LatestHeight int64
+	Mempool      typesUtil.Mempool
+	Context      *Context // IMPROVE: Rename to `persistenceContext` or `storeContext` or `reversibleContext`?
 }
 
 // IMPROVE: Consider renaming to `persistenceContext` or `storeContext`?

From e166e3bb02e33a4d892e1bd282930dfeb303788e Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 8 Nov 2022 16:00:32 -0800
Subject: [PATCH 135/227] Propogating proper QC in consensus

---
 Makefile                     |  3 ++-
 consensus/hotstuff_leader.go | 20 +++++++++++++-------
 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/Makefile b/Makefile
index 9c4ce32fb..0eed8e41c 100644
--- a/Makefile
+++ b/Makefile
@@ -408,10 +408,11 @@ benchmark_p2p_addrbook:
 # REFACTOR      - Similar to TECHDEBT, but will require a substantial rewrite and change across the codebase
 # CONSIDERATION - A comment that involves extra work but was thoughts / considered as part of some implementation
 # CONSOLIDATE   - We likely have similar implementations/types of the same thing, and we should consolidate them.
+# ADDTEST       - Add more tests for a specific code section
 # DEPRECATE     - Code that should be removed in the future
 # DISCUSS_IN_THIS_COMMIT - SHOULD NEVER BE COMMITTED TO MASTER. It is a way for the reviewer of a PR to start / reply to a discussion.
 # TODO_IN_THIS_COMMIT    - SHOULD NEVER BE COMMITTED TO MASTER. It is a way to start the review process while non-critical changes are still in progress
-TODO_KEYWORDS = -e "TODO" -e "TECHDEBT" -e "IMPROVE" -e "DISCUSS" -e "INCOMPLETE" -e "INVESTIGATE" -e "CLEANUP" -e "HACK" -e "REFACTOR" -e "CONSIDERATION" -e "TODO_IN_THIS_COMMIT" -e "DISCUSS_IN_THIS_COMMIT" -e "CONSOLIDATE" -e "DEPRECATE"
+TODO_KEYWORDS = -e "TODO" -e "TECHDEBT" -e "IMPROVE" -e "DISCUSS" -e "INCOMPLETE" -e "INVESTIGATE" -e "CLEANUP" -e "HACK" -e "REFACTOR" -e "CONSIDERATION" -e "TODO_IN_THIS_COMMIT" -e "DISCUSS_IN_THIS_COMMIT" -e "CONSOLIDATE" -e "DEPRECATE" -e "ADDTEST"
 
 # How do I use TODOs?
 # 1. <KEYWORD>: <Description of follow up work>;
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 784289ad2..73ce91512 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -6,6 +6,7 @@ import (
 
 	consensusTelemetry "github.com/pokt-network/pocket/consensus/telemetry"
 	typesCons "github.com/pokt-network/pocket/consensus/types"
+	"github.com/pokt-network/pocket/shared/codec"
 )
 
 type HotstuffLeaderMessageHandler struct{}
@@ -50,10 +51,8 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *consensusM
 	// TECHDEBT: How do we properly validate `highPrepareQC` here?
 	highPrepareQC := m.findHighQC(m.messagePool[NewRound])
 
-	// TODO: Add more unit tests for these checks...
 	if m.shouldPrepareNewBlock(highPrepareQC) {
-		// Leader prepares a new block if `highPrepareQC` is not applicable
-		block, err := m.prepareAndApplyBlock()
+		block, err := m.prepareAndApplyBlock(highPrepareQC)
 		if err != nil {
 			m.nodeLogError(typesCons.ErrPrepareBlock.Error(), err)
 			m.paceMaker.InterruptRound()
@@ -333,7 +332,7 @@ func (m *consensusModule) tempIndexHotstuffMessage(msg *typesCons.HotstuffMessag
 
 // This is a helper function intended to be called by a leader/validator during a view change
 // to prepare a new block that is applied to the new underlying context.
-func (m *consensusModule) prepareAndApplyBlock() (*typesCons.Block, error) {
+func (m *consensusModule) prepareAndApplyBlock(qc *typesCons.QuorumCertificate) (*typesCons.Block, error) {
 	if m.isReplica() {
 		return nil, typesCons.ErrReplicaPrepareBlock
 	}
@@ -349,19 +348,25 @@ func (m *consensusModule) prepareAndApplyBlock() (*typesCons.Block, error) {
 
 	persistenceContext := m.utilityContext.GetPersistenceContext()
 
+	// CONSOLIDATE: Last/Prev & AppHash/StateHash
 	prevAppHash, err := persistenceContext.GetPrevAppHash()
 	if err != nil {
 		return nil, err
 	}
 
+	qcBytes, err := codec.GetCodec().Marshal(qc)
+	if err != nil {
+		return nil, err
+	}
+
 	// Construct the block
 	blockHeader := &typesCons.BlockHeader{
 		Height:            int64(m.Height),
 		Hash:              hex.EncodeToString(appHash),
 		NumTxs:            uint32(len(txs)),
-		LastBlockHash:     prevAppHash, // IMRPROVE: this should be a block hash not the appHash
+		LastBlockHash:     prevAppHash,
 		ProposerAddress:   m.privateKey.Address().Bytes(),
-		QuorumCertificate: []byte("HACK: Temporary placeholder"),
+		QuorumCertificate: qcBytes,
 	}
 	block := &typesCons.Block{
 		BlockHeader:  blockHeader,
@@ -376,7 +381,8 @@ func (m *consensusModule) prepareAndApplyBlock() (*typesCons.Block, error) {
 	return block, nil
 }
 
-// Return true if this node, the leader, should prepare a new block
+// Return true if this node, the leader, should prepare a new block.
+// ADDTEST: Add more tests for all the different scenarios here
 func (m *consensusModule) shouldPrepareNewBlock(highPrepareQC *typesCons.QuorumCertificate) bool {
 	if highPrepareQC == nil {
 		m.nodeLog("Preparing a new block - no highPrepareQC found")

From cab5e6360643ca2a389d5aee24e7646ec9074c3f Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 8 Nov 2022 16:11:37 -0800
Subject: [PATCH 136/227] Added QC back to SetProposalBlock

---
 consensus/consensus_tests/utils_test.go | 2 +-
 consensus/hotstuff_leader.go            | 2 +-
 consensus/hotstuff_replica.go           | 7 ++++---
 shared/modules/persistence_module.go    | 2 +-
 utility/test/block_test.go              | 6 +++---
 5 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 608f7ed32..fe3d4a215 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -359,7 +359,7 @@ func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 	ctrl := gomock.NewController(t)
 	utilityContextMock := modulesMock.NewMockUtilityContext(ctrl)
 	persistenceContextMock := modulesMock.NewMockPersistenceRWContext(ctrl)
-	persistenceContextMock.EXPECT().SetProposalBlock(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+	persistenceContextMock.EXPECT().SetProposalBlock(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
 	persistenceContextMock.EXPECT().GetPrevAppHash().Return("", nil).AnyTimes()
 
 	utilityContextMock.EXPECT().
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 73ce91512..fec36d652 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -374,7 +374,7 @@ func (m *consensusModule) prepareAndApplyBlock(qc *typesCons.QuorumCertificate)
 	}
 
 	// Set the proposal block in the persistence context
-	if err = persistenceContext.SetProposalBlock(blockHeader.Hash, blockHeader.ProposerAddress, block.Transactions); err != nil {
+	if err = persistenceContext.SetProposalBlock(blockHeader.Hash, blockHeader.ProposerAddress, blockHeader.QuorumCertificate, block.Transactions); err != nil {
 		return nil, err
 	}
 
diff --git a/consensus/hotstuff_replica.go b/consensus/hotstuff_replica.go
index 420fbbc9d..eacab71f5 100644
--- a/consensus/hotstuff_replica.go
+++ b/consensus/hotstuff_replica.go
@@ -227,8 +227,9 @@ func (m *consensusModule) validateProposal(msg *typesCons.HotstuffMessage) error
 // This helper applies the block metadata to the utility & persistence layers
 func (m *consensusModule) applyBlock(block *typesCons.Block) error {
 	persistenceContext := m.utilityContext.GetPersistenceContext()
+	blockHeader := block.BlockHeader
 	// Set the proposal block in the persistence context
-	if err := persistenceContext.SetProposalBlock(block.BlockHeader.Hash, block.BlockHeader.ProposerAddress, block.Transactions); err != nil {
+	if err := persistenceContext.SetProposalBlock(blockHeader.Hash, blockHeader.ProposerAddress, blockHeader.QuorumCertificate, block.Transactions); err != nil {
 		return err
 	}
 
@@ -239,8 +240,8 @@ func (m *consensusModule) applyBlock(block *typesCons.Block) error {
 	}
 
 	// CONSOLIDATE: Terminology of `appHash` and `stateHash`
-	if block.BlockHeader.Hash != hex.EncodeToString(appHash) {
-		return typesCons.ErrInvalidAppHash(block.BlockHeader.Hash, hex.EncodeToString(appHash))
+	if blockHeader.Hash != hex.EncodeToString(appHash) {
+		return typesCons.ErrInvalidAppHash(blockHeader.Hash, hex.EncodeToString(appHash))
 	}
 
 	return nil
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index a7344df69..ffd206753 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -58,7 +58,7 @@ type PersistenceWriteContext interface {
 	// Indexer Operations
 
 	// Block Operations
-	SetProposalBlock(blockHash string, proposerAddr []byte, transactions [][]byte) error
+	SetProposalBlock(blockHash string, proposerAddr []byte, quorumCert []byte, transactions [][]byte) error
 	// Store the block into persistence
 	UpdateAppHash() ([]byte, error)
 
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index 79c2a9f11..d4d007f92 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -25,7 +25,7 @@ func TestUtilityContext_ApplyBlock(t *testing.T) {
 	require.NoError(t, er)
 	proposerBeforeBalance, err := ctx.GetAccountAmount(addrBz)
 	require.NoError(t, err)
-	er = ctx.GetPersistenceContext().SetProposalBlock("", addrBz, [][]byte{txBz})
+	er = ctx.GetPersistenceContext().SetProposalBlock("", addrBz, nil, [][]byte{txBz})
 	require.NoError(t, er)
 	// apply block
 	_, er = ctx.ApplyBlock()
@@ -73,7 +73,7 @@ func TestUtilityContext_BeginBlock(t *testing.T) {
 	require.NoError(t, err)
 	addrBz, er := hex.DecodeString(proposer.GetAddress())
 	require.NoError(t, er)
-	er = ctx.GetPersistenceContext().SetProposalBlock("", nil, addrBz, [][]byte{txBz})
+	er = ctx.GetPersistenceContext().SetProposalBlock("", nil, addrBz, [nil, ][]byte{txBz})
 	require.NoError(t, er)
 	// apply block
 	_, er = ctx.ApplyBlock()
@@ -136,7 +136,7 @@ func TestUtilityContext_EndBlock(t *testing.T) {
 	require.NoError(t, er)
 	proposerBeforeBalance, err := ctx.GetAccountAmount(addrBz)
 	require.NoError(t, err)
-	er = ctx.GetPersistenceContext().SetProposalBlock("", nil, addrBz, [][]byte{txBz})
+	er = ctx.GetPersistenceContext().SetProposalBlock("", nil, addrBz, nil, [][]byte{txBz})
 	require.NoError(t, er)
 	// apply block
 	_, er = ctx.ApplyBlock()

From a588240253246df007780b9ef7e8ac8bb59c337b Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 8 Nov 2022 19:09:40 -0800
Subject: [PATCH 137/227] StateHash test passing

---
 persistence/block.go                      | 20 ++--------
 persistence/context.go                    | 48 ++++++++++-------------
 persistence/db.go                         | 16 ++------
 persistence/debug.go                      |  4 --
 persistence/genesis.go                    | 12 +++++-
 persistence/kvstore/kvstore.go            |  5 ---
 persistence/module.go                     | 22 ++++++-----
 persistence/proto/block_persistence.proto |  6 ---
 persistence/state.go                      | 15 ++++---
 persistence/test/benchmark_state_test.go  |  4 +-
 persistence/test/state_test.go            | 40 +++++++++++--------
 shared/modules/persistence_module.go      | 26 ++++++------
 utility/block.go                          |  4 +-
 13 files changed, 94 insertions(+), 128 deletions(-)

diff --git a/persistence/block.go b/persistence/block.go
index c34ecc7c0..bab29d7b4 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -9,7 +9,6 @@ import (
 	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/crypto"
-	"github.com/pokt-network/pocket/shared/modules"
 )
 
 // OPTIMIZE(team): get from blockstore or keep in memory
@@ -58,10 +57,6 @@ func (p PostgresContext) GetPrevAppHash() (string, error) {
 	return hex.EncodeToString(block), nil // TODO(#284): Return `block.Hash` instead of the hex encoded representation of the blockBz
 }
 
-func (p PostgresContext) GetTxResults() []modules.TxResult {
-	return p.txResults
-}
-
 func (p PostgresContext) TransactionExists(transactionHash string) (bool, error) {
 	hash, err := hex.DecodeString(transactionHash)
 	if err != nil {
@@ -78,21 +73,12 @@ func (p PostgresContext) TransactionExists(transactionHash string) (bool, error)
 	return true, err
 }
 
-func (p PostgresContext) indexTransactions() error {
-	// TODO: store in batch
-	for _, txResult := range p.GetLatestTxResults() {
-		if err := p.txIndexer.Index(txResult); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
 // DISCUSS: this might be retrieved from the block store - temporarily we will access it directly from the module
 //       following the pattern of the Consensus Module prior to pocket/issue-#315
 // TODO(#284): Remove blockProtoBytes from the interface
-func (p *PostgresContext) SetProposalBlock(blockHash string, proposerAddr []byte, transactions [][]byte) error {
+func (p *PostgresContext) SetProposalBlock(blockHash string, proposerAddr, quorumCert []byte, transactions [][]byte) error {
 	p.blockHash = blockHash
+	p.quorumCert = quorumCert
 	p.proposerAddr = proposerAddr
 	p.blockTxs = transactions
 	return nil
@@ -118,7 +104,7 @@ func (p *PostgresContext) prepareBlock(quorumCert []byte) (*types.Block, error)
 
 	block := &types.Block{
 		Height:            uint64(p.Height),
-		Hash:              hex.EncodeToString(p.currentStateHash),
+		Hash:              hex.EncodeToString([]byte(p.blockHash)),
 		PrevHash:          hex.EncodeToString(prevHash),
 		ProposerAddress:   p.proposerAddr,
 		QuorumCertificate: quorumCert,
diff --git a/persistence/context.go b/persistence/context.go
index 06e91e2dd..809916511 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -5,6 +5,8 @@ package persistence
 import (
 	"context"
 	"log"
+
+	"github.com/pokt-network/pocket/shared/modules"
 )
 
 func (p PostgresContext) NewSavePoint(bytes []byte) error {
@@ -19,28 +21,16 @@ func (p PostgresContext) RollbackToSavePoint(bytes []byte) error {
 	return p.GetTx().Rollback(context.TODO())
 }
 
-func (p *PostgresContext) UpdateAppHash() ([]byte, error) {
-	if err := p.updateStateHash(); err != nil {
-		return nil, err
-	}
-	return p.currentStateHash, nil
-}
-
-func (p *PostgresContext) Reset() error {
-	p.txResults = nil
-	p.blockHash = ""
-	p.proposerAddr = nil
-	p.blockTxs = nil
-	return nil
+func (p *PostgresContext) ComputeAppHash() ([]byte, error) {
+	// DISCUSS_IN_THIS_COMMIT: Should we compare the `appHash` returned from `updateMerkleTrees`
+	// to the one set in `SetProposalBlock`. What if they are different?
+	return p.updateMerkleTrees()
 }
 
 func (p PostgresContext) Commit(quorumCert []byte) error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
-	// TODO_IN_THIS_COMMIT: Store transactions in indexer - should this be called on `SetProposalBlock`?`
-	if err := p.indexTransactions(); err != nil {
-		return err
-	}
+
 
 	// Create a persistence block proto
 	block, err := p.prepareBlock(quorumCert)
@@ -65,9 +55,6 @@ func (p PostgresContext) Commit(quorumCert []byte) error {
 	if err := p.conn.Close(ctx); err != nil {
 		log.Println("[TODO][ERROR] Implement connection pooling. Error when closing DB connecting...", err)
 	}
-	if err := p.Reset(); err != nil {
-		return err
-	}
 
 	return nil
 }
@@ -81,9 +68,6 @@ func (p PostgresContext) Release() error {
 	if err := p.resetContext(); err != nil {
 		return err
 	}
-	if err := p.Reset(); err != nil {
-		return err
-	}
 	return nil
 }
 
@@ -92,12 +76,16 @@ func (p PostgresContext) Close() error {
 	return p.conn.Close(context.TODO())
 }
 
-func (pg *PostgresContext) resetContext() (err error) {
-	if pg == nil {
+func (p PostgresContext) IndexTransaction(txResult modules.TxResult) error {
+	return p.txIndexer.Index(txResult)
+}
+
+func (p *PostgresContext) resetContext() (err error) {
+	if p == nil {
 		return nil
 	}
 
-	tx := pg.GetTx()
+	tx := p.GetTx()
 	if tx == nil {
 		return nil
 	}
@@ -113,8 +101,12 @@ func (pg *PostgresContext) resetContext() (err error) {
 		}
 	}
 
-	pg.conn = nil
-	pg.tx = nil
+	p.conn = nil
+	p.tx = nil
+	p.blockHash = ""
+	p.quorumCert = nil
+	p.proposerAddr = nil
+	p.blockTxs = nil
 
 	return err
 }
diff --git a/persistence/db.go b/persistence/db.go
index a599a2576..54812fc7e 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -51,20 +51,18 @@ type PostgresContext struct {
 	conn   *pgx.Conn
 	tx     pgx.Tx
 
-	// TODO(#315): Should be
-	currentStateHash []byte
-
 	// REFACTOR_IN_THIS_COMMIT: Access `blockStore` and `merkleTree` from the persistence module via bus.
 	blockStore kvstore.KVStore
 	txIndexer  indexer.TxIndexer
 
 	stateTrees *stateTrees
+
 	// DISCUSS(#284): this might be retrieved from the block store - temporarily we will access it directly from the module
 	//                following the pattern of the Consensus Module prior to pocket/issue-#315
 	proposerAddr []byte
-	blockHash    string
+	quorumCert   []byte
+	blockHash    string // CONSOLIDATE: blockHash / appHash / stateHash
 	blockTxs     [][]byte
-	txResults    []modules.TxResult // DISCUSS_IN_THIS_COMMIT: Can this be removed and retrieved from `txIndexer` using `height`?
 }
 
 func (pg *PostgresContext) GetCtxAndTx() (context.Context, pgx.Tx, error) {
@@ -87,18 +85,10 @@ func (p PostgresContext) GetLatestProposerAddr() []byte {
 	return p.proposerAddr
 }
 
-func (p PostgresContext) GetLatestBlockHash() string {
-	return p.blockHash
-}
-
 func (p PostgresContext) GetLatestBlockTxs() [][]byte {
 	return p.blockTxs
 }
 
-func (p PostgresContext) GetLatestTxResults() []modules.TxResult {
-	return p.txResults
-}
-
 // TECHDEBT: Implement proper connection pooling
 func connectToDatabase(postgresUrl string, schema string) (*pgx.Conn, error) {
 	ctx := context.TODO()
diff --git a/persistence/debug.go b/persistence/debug.go
index 8e2349a66..1f878687c 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -126,10 +126,6 @@ func (m *persistenceModule) clearState(_ *debug.DebugMessage) error {
 		m.stateTrees.merkleTrees[treeType] = smt.NewSparseMerkleTree(valueStore, nodeStore, sha256.New())
 	}
 
-	// if _, err := context.UpdateAppHash(); err != nil {
-	// 	return err
-	// }
-
 	log.Println("Cleared all the state")
 
 	return nil
diff --git a/persistence/genesis.go b/persistence/genesis.go
index e683b152c..8525355dd 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -145,12 +145,20 @@ func (m *persistenceModule) populateGenesisState(state modules.PersistenceGenesi
 	}
 
 	// This populate all the merkle trees
-	if _, err = rwContext.UpdateAppHash(); err != nil {
+	appHash, err := rwContext.ComputeAppHash()
+	if err != nil {
 		log.Fatalf("an error occurred updating the app hash during genesis: %s", err.Error())
 	}
 
+	// TODO: Figure out what these values for genesis should be
+	genesisQuorumCert := []byte("placeholderQuorumCert")
+	genesisProposer := []byte("placeholderProposer")
+	if err := rwContext.SetProposalBlock(hex.EncodeToString(appHash), genesisProposer, genesisQuorumCert, nil); err != nil {
+		log.Fatalf("an error occurred setting the proposal block during genesis: %s", err.Error())
+	}
+
 	// This update the DB, blockstore, and commits the state
-	if err = rwContext.Commit([]byte("placeholderQuorumCert")); err != nil {
+	if err = rwContext.Commit(genesisQuorumCert); err != nil {
 		log.Fatalf("error committing genesis state to DB %s ", err.Error())
 	}
 }
diff --git a/persistence/kvstore/kvstore.go b/persistence/kvstore/kvstore.go
index 40131d444..f0a2d7976 100644
--- a/persistence/kvstore/kvstore.go
+++ b/persistence/kvstore/kvstore.go
@@ -18,13 +18,8 @@ type KVStore interface {
 	// TODO: Add a proper iterator interface
 	// TODO: Add pagination for `GetAll`
 	GetAll(prefixKey []byte, descending bool) (keys [][]byte, values [][]byte, err error)
-
 	Exists(key []byte) (bool, error)
 	ClearAll() error
-
-	// Get(key []byte) ([]byte, error)     // Get gets the value for a key.
-	// Set(key []byte, value []byte) error // Set updates the value for a key.
-	// Delete(key []byte) error            // Delete deletes a key.
 }
 
 const (
diff --git a/persistence/module.go b/persistence/module.go
index b7a13130d..11acbf6a5 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -167,13 +167,15 @@ func (m *persistenceModule) NewRWContext(height int64) (modules.PersistenceRWCon
 		conn:   conn,
 		tx:     tx,
 
-		// TODO(#315): Shouldn't be necessary anymore
-		currentStateHash: make([]byte, 0),
-
 		// TODO_IN_THIS_COMMIT: Can we access these via the bus?
 		blockStore: m.blockStore,
 		txIndexer:  m.txIndexer,
 		stateTrees: m.stateTrees,
+
+		proposerAddr: nil,
+		quorumCert:   nil,
+		blockHash:    "",
+		blockTxs:     make([][]byte, 0),
 	}
 
 	return m.writeContext, nil
@@ -221,6 +223,13 @@ func (m *persistenceModule) NewWriteContext() modules.PersistenceRWContext {
 	return m.writeContext
 }
 
+func initializeBlockStore(blockStorePath string) (kvstore.KVStore, error) {
+	if blockStorePath == "" {
+		return kvstore.NewMemKVStore(), nil
+	}
+	return kvstore.NewKVStore(blockStorePath)
+}
+
 // HACK(olshansky): Simplify and externalize the logic for whether genesis should be populated and
 //                  move the if logic out of this file.
 func (m *persistenceModule) shouldHydrateGenesisDb() (bool, error) {
@@ -235,10 +244,3 @@ func (m *persistenceModule) shouldHydrateGenesisDb() (bool, error) {
 	}
 	return false, nil
 }
-
-func initializeBlockStore(blockStorePath string) (kvstore.KVStore, error) {
-	if blockStorePath == "" {
-		return kvstore.NewMemKVStore(), nil
-	}
-	return kvstore.NewKVStore(blockStorePath)
-}
diff --git a/persistence/proto/block_persistence.proto b/persistence/proto/block_persistence.proto
index 9b2541249..b1a1604bd 100644
--- a/persistence/proto/block_persistence.proto
+++ b/persistence/proto/block_persistence.proto
@@ -10,10 +10,4 @@ message Block {
     bytes proposerAddress = 4;
     bytes quorumCertificate = 5;
     bytes transactionsHash = 6; // The has of all the translactions in the block
-}
-
-// DISUCSS: What else do we need here?
-message Transaction {
-    uint64 height = 1;
-    bytes tx = 2;
 }
\ No newline at end of file
diff --git a/persistence/state.go b/persistence/state.go
index 36d04c563..935228e88 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -147,7 +147,7 @@ func newMemStateTrees() (*stateTrees, error) {
 	return stateTrees, nil
 }
 
-func (p *PostgresContext) updateStateHash() error {
+func (p *PostgresContext) updateMerkleTrees() ([]byte, error) {
 	// Update all the merkle trees
 	for treeType := merkleTree(0); treeType < numMerkleTrees; treeType++ {
 		switch treeType {
@@ -161,20 +161,20 @@ func (p *PostgresContext) updateStateHash() error {
 		case serviceNodeMerkleTree:
 			actorType, ok := merkleTreeToActorTypeName[treeType]
 			if !ok {
-				return fmt.Errorf("no actor type found for merkle tree: %v\n", treeType)
+				return nil, fmt.Errorf("no actor type found for merkle tree: %v\n", treeType)
 			}
 			if err := p.updateActorsTree(actorType, p.Height); err != nil {
-				return err
+				return nil, err
 			}
 
 		// Account Merkle Trees
 		case accountMerkleTree:
 			if err := p.updateAccountTrees(p.Height); err != nil {
-				return err
+				return nil, err
 			}
 		case poolMerkleTree:
 			if err := p.updatePoolTrees(p.Height); err != nil {
-				return err
+				return nil, err
 			}
 
 		// Data Merkle Trees
@@ -182,7 +182,7 @@ func (p *PostgresContext) updateStateHash() error {
 			continue
 		case transactionsMerkleTree:
 			if err := p.updateTransactionsTree(p.Height); err != nil {
-				return err
+				return nil, err
 			}
 
 		case paramsMerkleTree:
@@ -206,8 +206,7 @@ func (p *PostgresContext) updateStateHash() error {
 	rootsConcat := bytes.Join(roots, []byte{})
 	stateHash := sha256.Sum256(rootsConcat)
 
-	p.currentStateHash = stateHash[:]
-	return nil
+	return stateHash[:], nil
 }
 
 // Actor Tree Helpers
diff --git a/persistence/test/benchmark_state_test.go b/persistence/test/benchmark_state_test.go
index 0e3020954..d5873ece1 100644
--- a/persistence/test/benchmark_state_test.go
+++ b/persistence/test/benchmark_state_test.go
@@ -51,10 +51,10 @@ func BenchmarkStateHash(b *testing.B) {
 				db := NewTestPostgresContext(b, h)
 				for i := int64(0); i < numTxPerHeight; i++ {
 					callRandomDatabaseModifierFunc(db, h, false)
-					// db.StoreTransaction(modules.TxResult(getRandomTxResult(h)))
+					db.IndexTransaction(modules.TxResult(getRandomTxResult(h)))
 					// db.SetProposalBlock()
 				}
-				db.UpdateAppHash()
+				db.ComputeAppHash()
 				db.Commit([]byte("TODOquorumCert"))
 			}
 		})
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index 5265e20e6..3ea152e58 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -7,6 +7,7 @@ import (
 	"strconv"
 	"testing"
 
+	"github.com/pokt-network/pocket/persistence/indexer"
 	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/modules"
@@ -64,23 +65,23 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 		err = db.SetAppStakeAmount(addrBz, stakeAmountStr)
 		require.NoError(t, err)
 
-		// txBz := []byte("a tx, i am, which set the app stake amount to " + stakeAmountStr)
-		// txResult := indexer.TxRes{
-		// 	Tx:            txBz,
-		// 	Height:        height,
-		// 	Index:         0,
-		// 	ResultCode:    0,
-		// 	Error:         "TODO",
-		// 	SignerAddr:    "TODO",
-		// 	RecipientAddr: "TODO",
-		// 	MessageType:   "TODO",
-		// }
-
-		// err = db.StoreTransaction(modules.TxResult(&txResult))
-		// require.NoError(t, err)
+		txBz := []byte("a tx, i am, which set the app stake amount to " + stakeAmountStr)
+		txResult := indexer.TxRes{
+			Tx:            txBz,
+			Height:        height,
+			Index:         0,
+			ResultCode:    0,
+			Error:         "TODO",
+			SignerAddr:    "TODO",
+			RecipientAddr: "TODO",
+			MessageType:   "TODO",
+		}
+
+		err = db.IndexTransaction(modules.TxResult(&txResult))
+		require.NoError(t, err)
 
 		// Update the state hash
-		appHash, err := db.UpdateAppHash()
+		appHash, err := db.ComputeAppHash()
 		require.NoError(t, err)
 		require.Equal(t, expectedAppHash, hex.EncodeToString(appHash))
 
@@ -105,6 +106,11 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 	}
 }
 
+func TestStateHash_TreeUpdatesAreIdempotent(t *testing.T) {
+}
+
+// Contintously updating the same value at the same height should not result in a delta
+
 type TestReplayableOperation struct {
 	methodName string
 	args       []reflect.Value
@@ -154,7 +160,7 @@ func TestStateHash_RandomButDeterministic(t *testing.T) {
 				txResult:   txResult,
 			}
 		}
-		appHash, err := db.UpdateAppHash()
+		appHash, err := db.ComputeAppHash()
 		require.NoError(t, err)
 
 		proposer := getRandomBytes(10)
@@ -190,7 +196,7 @@ func verifyReplayableBlocks(t *testing.T, replayableBlocks []*TestReplayableBloc
 			}
 			// require.NoError(t, db.StoreTransaction(tx.txResult))
 		}
-		appHash, err := db.UpdateAppHash()
+		appHash, err := db.ComputeAppHash()
 		require.NoError(t, err)
 		require.Equal(t, block.hash, appHash)
 
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index ffd206753..d076471a4 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -59,8 +59,8 @@ type PersistenceWriteContext interface {
 
 	// Block Operations
 	SetProposalBlock(blockHash string, proposerAddr []byte, quorumCert []byte, transactions [][]byte) error
-	// Store the block into persistence
-	UpdateAppHash() ([]byte, error)
+	ComputeAppHash() ([]byte, error)
+	IndexTransaction(txResult TxResult) error // DISCUSS_IN_THIS_COMMIT: How can we remove `TxResult` from the public interface?
 
 	// Pool Operations
 	AddPoolAmount(name string, amount string) error
@@ -117,19 +117,17 @@ type PersistenceWriteContext interface {
 }
 
 type PersistenceReadContext interface {
-	GetHeight() (int64, error)
-
-	// Closes the read context
-	Close() error
+	// Context Operations
+	GetHeight() (int64, error) // Returns the height of the context
+	Close() error              // Closes the read context
 
 	// Block Queries
-	GetPrevAppHash() (string, error) // app hash from the previous block
-	GetLatestBlockHeight() (uint64, error)
-	GetBlockHash(height int64) ([]byte, error)
-	GetBlocksPerSession(height int64) (int, error)
-	GetLatestProposerAddr() []byte
-	GetLatestBlockHash() string
-	GetLatestBlockTxs() [][]byte
+	GetLatestBlockHeight() (uint64, error)         // Returns the height of the latest block in the persistence layer
+	GetPrevAppHash() (string, error)               // Returns the app hash from the previous block relate to the context height
+	GetBlockHash(height int64) ([]byte, error)     // Returns the app hash corresponding to the height provides
+	GetLatestProposerAddr() []byte                 // Returns the proposer set via `SetProposalBlock`
+	GetLatestBlockTxs() [][]byte                   // Returns the transactions set via `SetProposalBlock`
+	GetBlocksPerSession(height int64) (int, error) // TECHDEBT(#286): Deprecate this method
 
 	// Indexer Queries
 	TransactionExists(transactionHash string) (bool, error)
@@ -164,7 +162,7 @@ type PersistenceReadContext interface {
 	GetServiceNodePauseHeightIfExists(address []byte, height int64) (int64, error)
 	GetServiceNodeOutputAddress(operator []byte, height int64) (output []byte, err error)
 	GetServiceNodeCount(chain string, height int64) (int, error)
-	GetServiceNodesPerSessionAt(height int64) (int, error)
+	GetServiceNodesPerSessionAt(height int64) (int, error) // TECHDEBT(#286): Deprecate this method
 
 	// Fisherman Queries
 	GetAllFishermen(height int64) ([]Actor, error)
diff --git a/utility/block.go b/utility/block.go
index 770c22602..bfeef741b 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -118,7 +118,7 @@ func (u *UtilityContext) ApplyBlock() (appHash []byte, err error) {
 	}
 
 	// return the app hash (consensus module will get the validator set directly)
-	appHash, err = u.Context.UpdateAppHash()
+	appHash, err = u.Context.ComputeAppHash()
 	if err != nil {
 		log.Fatalf("Updating the app hash failed: %v. TODO: Look into roll-backing the entire commit...\n", err)
 		return nil, typesUtil.ErrAppHash(err)
@@ -152,7 +152,7 @@ func (u *UtilityContext) EndBlock(proposer []byte) typesUtil.Error {
 }
 
 func (u *UtilityContext) getAppHash() ([]byte, typesUtil.Error) {
-	appHash, er := u.Context.UpdateAppHash()
+	appHash, er := u.Context.ComputeAppHash()
 	if er != nil {
 		return nil, typesUtil.ErrAppHash(er)
 	}

From 23df0cb3bf1431384987a125c39dea7f85c7cca3 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 8 Nov 2022 19:18:30 -0800
Subject: [PATCH 138/227] Removed export tree related work

---
 Makefile                |  7 -------
 app/client/cli/debug.go |  8 --------
 persistence/debug.go    | 44 -----------------------------------------
 shared/node.go          |  2 --
 4 files changed, 61 deletions(-)

diff --git a/Makefile b/Makefile
index 0eed8e41c..6f876444b 100644
--- a/Makefile
+++ b/Makefile
@@ -187,13 +187,6 @@ db_show_schemas: docker_check
 db_admin:
 	echo "Open http://0.0.0.0:5050 and login with 'pgadmin4@pgadmin.org' and 'pgadmin4'.\n The password is 'postgres'"
 
-# TODO_IN_THIS_COMMIT: Move this out into a separate task
-.PHONY: db_export_trees
-## Copy the trees in `node1` from docker to the host machine - assumes `ExportTrees` was executed from the debug client
-db_export_trees:
-	echo "Copying trees from node1.consensus to /tmp/node1_trees"
-	docker cp node1.consensus:/tmp/trees /tmp/node1_trees
-
 .PHONY: docker_kill_all
 ## Kill all containers started by the docker-compose file
 docker_kill_all: docker_check
diff --git a/app/client/cli/debug.go b/app/client/cli/debug.go
index b1a1b918c..db24cacd8 100644
--- a/app/client/cli/debug.go
+++ b/app/client/cli/debug.go
@@ -28,7 +28,6 @@ const (
 	PromptTriggerNextView        string = "TriggerNextView (broadcast)"
 	PromptTogglePacemakerMode    string = "TogglePacemakerMode (broadcast)"
 	PromptShowLatestBlockInStore string = "ShowLatestBlockInStore (send)"
-	PromptExportTrees            string = "ExportTrees (broadcast)"
 
 	defaultConfigPath  = "build/config/config1.json"
 	defaultGenesisPath = "build/config/genesis.json"
@@ -48,7 +47,6 @@ var (
 		PromptTriggerNextView,
 		PromptTogglePacemakerMode,
 		PromptShowLatestBlockInStore,
-		PromptExportTrees,
 	}
 )
 
@@ -131,12 +129,6 @@ func handleSelect(selection string) {
 			Message: nil,
 		}
 		sendDebugMessage(m)
-	case PromptExportTrees:
-		m := &debug.DebugMessage{
-			Action:  debug.DebugMessageAction_DEBUG_PERSISTENCE_TREE_EXPORT,
-			Message: nil,
-		}
-		broadcastDebugMessage(m)
 	default:
 		log.Println("Selection not yet implemented...", selection)
 	}
diff --git a/persistence/debug.go b/persistence/debug.go
index 1f878687c..00168b883 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -3,16 +3,11 @@ package persistence
 import (
 	"crypto/sha256"
 	"log"
-	"os"
-	"strings"
 
 	"github.com/celestiaorg/smt"
 	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/codec"
 	"github.com/pokt-network/pocket/shared/debug"
-
-	"google.golang.org/protobuf/encoding/protojson"
-	"google.golang.org/protobuf/proto"
 )
 
 func (m *persistenceModule) HandleDebugMessage(debugMessage *debug.DebugMessage) error {
@@ -29,10 +24,6 @@ func (m *persistenceModule) HandleDebugMessage(debugMessage *debug.DebugMessage)
 		}
 		g := m.genesisState.(*types.PersistenceGenesisState)
 		m.populateGenesisState(g) // fatal if there's an error
-	case debug.DebugMessageAction_DEBUG_PERSISTENCE_TREE_EXPORT:
-		if err := m.exportTrees(debugMessage); err != nil {
-			return err
-		}
 	default:
 		log.Printf("Debug message not handled by persistence module: %s \n", debugMessage.Message)
 	}
@@ -54,41 +45,6 @@ func (m *persistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 	log.Printf("Block at height %d: %+v \n", height, block)
 }
 
-// Everyone roles their own key-value export: https://www.reddit.com/r/golang/comments/bw08dt/is_there_any_offline_database_viewer_and_editor
-// docker exec node4.consensus sh -c "cat /tmp/trees/val.json";
-func (m *persistenceModule) exportTrees(_ *debug.DebugMessage) error {
-	if err := os.Mkdir("/tmp/trees", os.ModePerm); err != nil {
-		return err
-	}
-
-	for treeType := merkleTree(0); treeType < numMerkleTrees; treeType++ {
-		smtValues := m.stateTrees.valueStores[treeType]
-		_, values, err := smtValues.GetAll(nil, true)
-		if err != nil {
-			return err
-		}
-
-		var sb strings.Builder
-		for i := 0; i < len(values); i++ {
-			vProto := merkleTreeToProtoSchema[treeType]()
-			// vProto := &types.Actor{}
-			if err := proto.Unmarshal(values[i], vProto.(proto.Message)); err != nil {
-				// if err := proto.Unmarshal(values[i], vProto); err != nil {
-				return err
-			}
-			sb.WriteString(protojson.Format(vProto))
-		}
-		f, err := os.Create("/tmp/trees/" + merkleTreeToString[treeType] + ".json")
-		if err != nil {
-			return err
-		}
-		f.Write([]byte(sb.String()))
-		f.Close()
-	}
-	log.Println("Trees exported to /tmp/trees/")
-	return nil
-}
-
 // TODO: MAke sure this is atomic
 func (m *persistenceModule) clearState(_ *debug.DebugMessage) error {
 	context, err := m.NewRWContext(-1)
diff --git a/shared/node.go b/shared/node.go
index 2e700179e..84520341e 100644
--- a/shared/node.go
+++ b/shared/node.go
@@ -170,8 +170,6 @@ func (node *Node) handleDebugEvent(anyMessage *anypb.Any) error {
 	// Persistence Debug
 	case debug.DebugMessageAction_DEBUG_SHOW_LATEST_BLOCK_IN_STORE:
 		fallthrough
-	case debug.DebugMessageAction_DEBUG_PERSISTENCE_TREE_EXPORT:
-		return node.GetBus().GetPersistenceModule().HandleDebugMessage(&debugMessage)
 	default:
 		log.Printf("Debug message: %s \n", debugMessage.Message)
 	}

From e3785f368a45548baee1f15407e5364696f9c063 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 8 Nov 2022 19:38:04 -0800
Subject: [PATCH 139/227] Moved persistence debug helpers into appropriate file

---
 consensus/hotstuff_leader.go  |  2 +-
 consensus/hotstuff_replica.go |  5 +++--
 persistence/account.go        |  2 ++
 persistence/context.go        | 20 +++++++++--------
 persistence/db.go             | 42 -----------------------------------
 persistence/debug.go          | 40 +++++++++++++++++++++++++++++++++
 persistence/state.go          | 35 ++++++++++++++++-------------
 utility/test/module_test.go   |  3 +++
 8 files changed, 80 insertions(+), 69 deletions(-)

diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index fec36d652..2936a9a58 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -348,7 +348,7 @@ func (m *consensusModule) prepareAndApplyBlock(qc *typesCons.QuorumCertificate)
 
 	persistenceContext := m.utilityContext.GetPersistenceContext()
 
-	// CONSOLIDATE: Last/Prev & AppHash/StateHash
+	// CONSOLIDATE: Last/Prev & AppHash/StateHash/BlockHash
 	prevAppHash, err := persistenceContext.GetPrevAppHash()
 	if err != nil {
 		return nil, err
diff --git a/consensus/hotstuff_replica.go b/consensus/hotstuff_replica.go
index eacab71f5..de80a6998 100644
--- a/consensus/hotstuff_replica.go
+++ b/consensus/hotstuff_replica.go
@@ -240,8 +240,9 @@ func (m *consensusModule) applyBlock(block *typesCons.Block) error {
 	}
 
 	// CONSOLIDATE: Terminology of `appHash` and `stateHash`
-	if blockHeader.Hash != hex.EncodeToString(appHash) {
-		return typesCons.ErrInvalidAppHash(blockHeader.Hash, hex.EncodeToString(appHash))
+	appHashString := hex.EncodeToString(appHash)
+	if blockHeader.Hash != appHashString {
+		return typesCons.ErrInvalidAppHash(blockHeader.Hash, appHashString)
 	}
 
 	return nil
diff --git a/persistence/account.go b/persistence/account.go
index 87594c983..56fbb3bb1 100644
--- a/persistence/account.go
+++ b/persistence/account.go
@@ -68,6 +68,7 @@ func (p PostgresContext) SetAccountAmount(address []byte, amount string) error {
 	return nil
 }
 
+// TODO_IN_THIS_COMMIT: Add unit tests for this
 func (p PostgresContext) getAccountsUpdated(height int64) (accounts []*types.Account, err error) {
 	return p.getPoolOrAccUpdatedInternal(types.GetAccountsUpdatedAtHeightQuery(height))
 }
@@ -146,6 +147,7 @@ func (p *PostgresContext) operationPoolAmount(name string, amount string, op fun
 	return p.operationPoolOrAccAmount(name, amount, op, p.GetPoolAmount, types.InsertPoolAmountQuery)
 }
 
+// TODO_IN_THIS_COMMIT: Add unit tests for this
 func (p PostgresContext) getPoolsUpdated(height int64) ([]*types.Account, error) {
 	return p.getPoolOrAccUpdatedInternal(types.GetPoolsUpdatedAtHeightQuery(height))
 }
diff --git a/persistence/context.go b/persistence/context.go
index 809916511..62818882b 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -1,6 +1,6 @@
 package persistence
 
-// CLEANUP: Figure out why the receivers here aren't pointers?
+// TECHDEBT: Figure out why the receivers here aren't pointers?
 
 import (
 	"context"
@@ -22,32 +22,34 @@ func (p PostgresContext) RollbackToSavePoint(bytes []byte) error {
 }
 
 func (p *PostgresContext) ComputeAppHash() ([]byte, error) {
-	// DISCUSS_IN_THIS_COMMIT: Should we compare the `appHash` returned from `updateMerkleTrees`
-	// to the one set in `SetProposalBlock`. What if they are different?
+	// DISCUSS_IN_THIS_COMMIT:
+	// 1. Should we compare the `appHash` returned from `updateMerkleTrees`?
+	// 2. Should this update the internal state of the context?
+	// Proposal: If the current internal appHash is not set, we update it.
+	//           If the current internal appHash is set, we compare it and return an error if different.
 	return p.updateMerkleTrees()
 }
 
 func (p PostgresContext) Commit(quorumCert []byte) error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
-
-
 	// Create a persistence block proto
 	block, err := p.prepareBlock(quorumCert)
 	if err != nil {
 		return err
 	}
 
-	// Insert the block into the postgres DB
-	if err := p.insertBlock(block); err != nil {
+	// Store block in the KV store
+	if err := p.storeBlock(block); err != nil {
 		return err
 	}
 
-	// Store block in the KV store
-	if err := p.storeBlock(block); err != nil {
+	// Insert the block into the SQL DB
+	if err := p.insertBlock(block); err != nil {
 		return err
 	}
 
+	// Commit the SQL transaction
 	ctx := context.TODO()
 	if err := p.GetTx().Commit(ctx); err != nil {
 		return err
diff --git a/persistence/db.go b/persistence/db.go
index 54812fc7e..51c0ed7a2 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -33,20 +33,9 @@ var protocolActorSchemas = []types.ProtocolActorSchema{
 	types.ValidatorActor,
 }
 
-// A list of functions to clear data from the DB not associated with protocol actors
-var nonActorClearFunctions = []func() string{
-	types.ClearAllAccounts,
-	types.ClearAllPools,
-	types.ClearAllGovParamsQuery,
-	types.ClearAllGovFlagsQuery,
-	types.ClearAllBlocksQuery,
-}
-
 var _ modules.PersistenceRWContext = &PostgresContext{}
 
 type PostgresContext struct {
-	// modules.PersistenceRWContext
-
 	Height int64 // TODO(olshansky): `Height` is only externalized for testing purposes. Replace with helpers...
 	conn   *pgx.Conn
 	tx     pgx.Tx
@@ -195,34 +184,3 @@ func initializeBlockTables(ctx context.Context, db *pgx.Conn) error {
 	}
 	return nil
 }
-
-// Exposed for testing purposes only
-func (p *PostgresContext) DebugClearAll() error {
-	ctx, clearTx, err := p.GetCtxAndTx()
-	if err != nil {
-		return err
-	}
-
-	for _, actor := range protocolActorSchemas {
-		if _, err = clearTx.Exec(ctx, actor.ClearAllQuery()); err != nil {
-			return err
-		}
-		if actor.GetChainsTableName() != "" {
-			if _, err = clearTx.Exec(ctx, actor.ClearAllChainsQuery()); err != nil {
-				return err
-			}
-		}
-	}
-
-	for _, clearFn := range nonActorClearFunctions {
-		if _, err := clearTx.Exec(ctx, clearFn()); err != nil {
-			return err
-		}
-	}
-
-	if err = clearTx.Commit(ctx); err != nil {
-		return err
-	}
-
-	return nil
-}
diff --git a/persistence/debug.go b/persistence/debug.go
index 00168b883..e70c116f1 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -10,6 +10,15 @@ import (
 	"github.com/pokt-network/pocket/shared/debug"
 )
 
+// A list of functions to clear data from the DB not associated with protocol actors
+var nonActorClearFunctions = []func() string{
+	types.ClearAllAccounts,
+	types.ClearAllPools,
+	types.ClearAllGovParamsQuery,
+	types.ClearAllGovFlagsQuery,
+	types.ClearAllBlocksQuery,
+}
+
 func (m *persistenceModule) HandleDebugMessage(debugMessage *debug.DebugMessage) error {
 	switch debugMessage.Action {
 	case debug.DebugMessageAction_DEBUG_SHOW_LATEST_BLOCK_IN_STORE:
@@ -86,3 +95,34 @@ func (m *persistenceModule) clearState(_ *debug.DebugMessage) error {
 
 	return nil
 }
+
+// Exposed for testing purposes only
+func (p *PostgresContext) DebugClearAll() error {
+	ctx, clearTx, err := p.GetCtxAndTx()
+	if err != nil {
+		return err
+	}
+
+	for _, actor := range protocolActorSchemas {
+		if _, err = clearTx.Exec(ctx, actor.ClearAllQuery()); err != nil {
+			return err
+		}
+		if actor.GetChainsTableName() != "" {
+			if _, err = clearTx.Exec(ctx, actor.ClearAllChainsQuery()); err != nil {
+				return err
+			}
+		}
+	}
+
+	for _, clearFn := range nonActorClearFunctions {
+		if _, err := clearTx.Exec(ctx, clearFn()); err != nil {
+			return err
+		}
+	}
+
+	if err = clearTx.Commit(ctx); err != nil {
+		return err
+	}
+
+	return nil
+}
diff --git a/persistence/state.go b/persistence/state.go
index 935228e88..8a358bb17 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -41,9 +41,7 @@ const (
 	poolMerkleTree
 
 	// Data Merkle Trees
-	blocksMerkleTree
 	transactionsMerkleTree
-
 	paramsMerkleTree
 	flagsMerkleTree
 
@@ -60,11 +58,9 @@ var merkleTreeToString = map[merkleTree]string{
 	accountMerkleTree: "account",
 	poolMerkleTree:    "pool",
 
-	blocksMerkleTree:       "blocks",
 	transactionsMerkleTree: "transactions",
-
-	paramsMerkleTree: "params",
-	flagsMerkleTree:  "flags",
+	paramsMerkleTree:       "params",
+	flagsMerkleTree:        "flags",
 }
 
 var actorTypeToMerkleTreeName map[types.ActorType]merkleTree = map[types.ActorType]merkleTree{
@@ -97,11 +93,9 @@ var merkleTreeToProtoSchema = map[merkleTree]func() proto.Message{
 	accountMerkleTree: func() proto.Message { return &types.Account{} },
 	poolMerkleTree:    func() proto.Message { return &types.Account{} },
 
-	blocksMerkleTree:       func() proto.Message { return &types.Block{} },
 	transactionsMerkleTree: func() proto.Message { return &types.Transaction{} },
-
-	paramsMerkleTree: func() proto.Message { return &types.Params{} },
-	flagsMerkleTree:  func() proto.Message { return &types.Params{} },
+	paramsMerkleTree:       func() proto.Message { return &types.Params{} },
+	flagsMerkleTree:        func() proto.Message { return &types.Params{} },
 }
 
 func newStateTrees(treesStoreDir string) (*stateTrees, error) {
@@ -178,17 +172,18 @@ func (p *PostgresContext) updateMerkleTrees() ([]byte, error) {
 			}
 
 		// Data Merkle Trees
-		case blocksMerkleTree:
-			continue
 		case transactionsMerkleTree:
 			if err := p.updateTransactionsTree(p.Height); err != nil {
 				return nil, err
 			}
-
 		case paramsMerkleTree:
-			// TODO: Implement paramsMerkleTree
+			if err := p.updateParamsTree(p.Height); err != nil {
+				return nil, err
+			}
 		case flagsMerkleTree:
-			// TODO: Implement flagsMerkleTree
+			if err := p.updateFlagsTree(p.Height); err != nil {
+				return nil, err
+			}
 
 		// Default
 		default:
@@ -337,3 +332,13 @@ func (p *PostgresContext) updateTransactionsTree(height int64) error {
 
 	return nil
 }
+
+func (p *PostgresContext) updateParamsTree(height int64) error {
+	// TODO_IN_NEXT_COMMIT(olshansky): Implement me
+	return nil
+}
+
+func (p *PostgresContext) updateFlagsTree(height int64) error {
+	// TODO_IN_NEXT_COMMIT(olshansky): Implement me
+	return nil
+}
diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index 3f78114f9..b45904d04 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -62,6 +62,9 @@ func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext
 	persistenceContext, err := testPersistenceMod.NewRWContext(height)
 	require.NoError(t, err)
 
+	// TECHDEBT: Move the internal of cleanup into a separate function and call this in the
+	// beginning of every test. This can be problematic if we call `NewTestingUtilityContext` more
+	// than once in a single test.
 	t.Cleanup(func() {
 		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
 		require.NoError(t, testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{

From 353d4b0e83057b904911269f6cecd81a4480eb0b Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 8 Nov 2022 19:59:58 -0800
Subject: [PATCH 140/227] Halfway through self review

---
 persistence/debug.go                    | 15 +++++----------
 persistence/docs/PROTOCOL_STATE_HASH.md |  2 ++
 persistence/genesis.go                  |  4 ++--
 persistence/kvstore/kvstore.go          |  1 +
 persistence/module.go                   |  2 +-
 persistence/test/setup_test.go          |  6 ++++--
 shared/debug/proto/debug_message.proto  |  1 -
 utility/block.go                        |  1 +
 8 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/persistence/debug.go b/persistence/debug.go
index e70c116f1..f6e65589e 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -24,11 +24,11 @@ func (m *persistenceModule) HandleDebugMessage(debugMessage *debug.DebugMessage)
 	case debug.DebugMessageAction_DEBUG_SHOW_LATEST_BLOCK_IN_STORE:
 		m.showLatestBlockInStore(debugMessage)
 	case debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE:
-		if err := m.clearState(debugMessage); err != nil {
+		if err := m.clearAllState(debugMessage); err != nil {
 			return err
 		}
 	case debug.DebugMessageAction_DEBUG_PERSISTENCE_RESET_TO_GENESIS:
-		if err := m.clearState(debugMessage); err != nil {
+		if err := m.clearAllState(debugMessage); err != nil {
 			return err
 		}
 		g := m.genesisState.(*types.PersistenceGenesisState)
@@ -55,27 +55,24 @@ func (m *persistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 }
 
 // TODO: MAke sure this is atomic
-func (m *persistenceModule) clearState(_ *debug.DebugMessage) error {
+func (m *persistenceModule) clearAllState(_ *debug.DebugMessage) error {
 	context, err := m.NewRWContext(-1)
 	if err != nil {
 		return err
 	}
 
 	// Clear the SQL DB
-	if err := context.(*PostgresContext).DebugClearAll(); err != nil {
+	if err := context.(*PostgresContext).clearAllSQLState(); err != nil {
 		return err
 	}
-
 	if err := m.ReleaseWriteContext(); err != nil {
 		return err
 	}
 
 	// Clear the KV Stores
-
 	if err := m.blockStore.ClearAll(); err != nil {
 		return err
 	}
-
 	for treeType := merkleTree(0); treeType < numMerkleTrees; treeType++ {
 		valueStore := m.stateTrees.valueStores[treeType]
 		nodeStore := m.stateTrees.nodeStores[treeType]
@@ -92,12 +89,10 @@ func (m *persistenceModule) clearState(_ *debug.DebugMessage) error {
 	}
 
 	log.Println("Cleared all the state")
-
 	return nil
 }
 
-// Exposed for testing purposes only
-func (p *PostgresContext) DebugClearAll() error {
+func (p *PostgresContext) clearAllSQLState() error {
 	ctx, clearTx, err := p.GetCtxAndTx()
 	if err != nil {
 		return err
diff --git a/persistence/docs/PROTOCOL_STATE_HASH.md b/persistence/docs/PROTOCOL_STATE_HASH.md
index fc5fabb46..ac0f3dc83 100644
--- a/persistence/docs/PROTOCOL_STATE_HASH.md
+++ b/persistence/docs/PROTOCOL_STATE_HASH.md
@@ -1,3 +1,5 @@
+DO_NOT_REVIEW_THIS_YET
+
 # AppHash <!-- omit in toc -->
 
 This document describes the persistence module internal implementation of how the state hash is updated. Specifically, what happens once the `UpdateStateHash` function in [persistence module interface](../../shared/modules/persistence_module.go) is called.
diff --git a/persistence/genesis.go b/persistence/genesis.go
index 8525355dd..0473d2edb 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -144,13 +144,13 @@ func (m *persistenceModule) populateGenesisState(state modules.PersistenceGenesi
 		log.Fatalf("an error occurred initializing flags: %s", err.Error())
 	}
 
-	// This populate all the merkle trees
+	// Updates all the merkle trees
 	appHash, err := rwContext.ComputeAppHash()
 	if err != nil {
 		log.Fatalf("an error occurred updating the app hash during genesis: %s", err.Error())
 	}
 
-	// TODO: Figure out what these values for genesis should be
+	// TODO_IN_THIS_COMMIT: Figure out what these values for genesis should be
 	genesisQuorumCert := []byte("placeholderQuorumCert")
 	genesisProposer := []byte("placeholderProposer")
 	if err := rwContext.SetProposalBlock(hex.EncodeToString(appHash), genesisProposer, genesisQuorumCert, nil); err != nil {
diff --git a/persistence/kvstore/kvstore.go b/persistence/kvstore/kvstore.go
index f0a2d7976..1d172ef23 100644
--- a/persistence/kvstore/kvstore.go
+++ b/persistence/kvstore/kvstore.go
@@ -87,6 +87,7 @@ func (store *badgerKVStore) Get(key []byte) ([]byte, error) {
 	return value, nil
 }
 
+// TODO_IN_THIS_COMMIT: Add tests for this new function
 func (store *badgerKVStore) Delete(key []byte) error {
 	tx := store.db.NewTransaction(true)
 	defer tx.Discard()
diff --git a/persistence/module.go b/persistence/module.go
index 11acbf6a5..75b3c5d14 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -175,7 +175,7 @@ func (m *persistenceModule) NewRWContext(height int64) (modules.PersistenceRWCon
 		proposerAddr: nil,
 		quorumCert:   nil,
 		blockHash:    "",
-		blockTxs:     make([][]byte, 0),
+		blockTxs:     nil,
 	}
 
 	return m.writeContext, nil
diff --git a/persistence/test/setup_test.go b/persistence/test/setup_test.go
index f08ec7de7..bbbf66782 100644
--- a/persistence/test/setup_test.go
+++ b/persistence/test/setup_test.go
@@ -59,7 +59,7 @@ func TestMain(m *testing.M) {
 	os.Exit(exitCode)
 }
 
-// IMPROVE(olshansky): Look into returning `testPersistenceMod` to avoid exposing underlying abstraction.
+// IMPROVE: Look into returning `testPersistenceMod` to avoid exposing underlying abstraction.
 func NewTestPostgresContext(t testing.TB, height int64) *persistence.PostgresContext {
 	ctx, err := testPersistenceMod.NewRWContext(height)
 	if err != nil {
@@ -71,7 +71,7 @@ func NewTestPostgresContext(t testing.TB, height int64) *persistence.PostgresCon
 		log.Fatalf("Error casting RW context to Postgres context")
 	}
 
-	// TODO_IN_THIS_COMMIT: This should not be part of `NewTestPostgresContext`. It causes unnecessary resets
+	// TECHDEBT: This should not be part of `NewTestPostgresContext`. It causes unnecessary resets
 	// if we call `NewTestPostgresContext` more than once in a single test.
 	t.Cleanup(resetStateToGenesis)
 
@@ -314,6 +314,7 @@ func setRandomSeed() {
 	rand.Seed(time.Now().UnixNano())
 }
 
+// This is necessary for unit tests that are dependant on a baseline genesis state
 func resetStateToGenesis() {
 	if err := testPersistenceMod.ReleaseWriteContext(); err != nil {
 		log.Fatalf("Error releasing write context: %v\n", err)
@@ -326,6 +327,7 @@ func resetStateToGenesis() {
 	}
 }
 
+// This is necessary for unit tests that are dependant on a completely clear state when starting
 func clearAllState() {
 	if err := testPersistenceMod.ReleaseWriteContext(); err != nil {
 		log.Fatalf("Error releasing write context: %v\n", err)
diff --git a/shared/debug/proto/debug_message.proto b/shared/debug/proto/debug_message.proto
index 08867e48d..85941eeb2 100644
--- a/shared/debug/proto/debug_message.proto
+++ b/shared/debug/proto/debug_message.proto
@@ -17,7 +17,6 @@ enum DebugMessageAction {
 
 	DEBUG_PERSISTENCE_CLEAR_STATE = 6;
 	DEBUG_PERSISTENCE_RESET_TO_GENESIS = 7;
-	DEBUG_PERSISTENCE_TREE_EXPORT = 8;
 }
 
 message DebugMessage {
diff --git a/utility/block.go b/utility/block.go
index bfeef741b..e940813f7 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -62,6 +62,7 @@ func (u *UtilityContext) CreateAndApplyProposalBlock(proposer []byte, maxTransac
 			totalTxsSizeInBytes -= txTxsSizeInBytes
 			continue
 		}
+		
 		transactions = append(transactions, txBytes)
 		txResults = append(txResults, txResult)
 		txIndex++

From 0ebbf52a46a1fe32a6a680fbfe0f6fd0d3efe725 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 8 Nov 2022 20:45:57 -0800
Subject: [PATCH 141/227] Reverted unrelated changes

---
 utility/test/actor_test.go | 143 +++++++++++++++++----------------
 utility/test/block_test.go | 157 ++++++++++++++++++++-----------------
 2 files changed, 153 insertions(+), 147 deletions(-)

diff --git a/utility/test/actor_test.go b/utility/test/actor_test.go
index f8064fa1e..b1c24c542 100644
--- a/utility/test/actor_test.go
+++ b/utility/test/actor_test.go
@@ -454,89 +454,86 @@ func TestUtilityContext_UnstakePausedBefore(t *testing.T) {
 
 func TestUtilityContext_UnstakeActorsThatAreReady(t *testing.T) {
 	for _, actorType := range actorTypes {
-		t.Run(fmt.Sprintf("%s.UnstakeActorsThatAreReady", actorType.String()), func(t *testing.T) {
-			ctx := NewTestingUtilityContext(t, 1)
+		ctx := NewTestingUtilityContext(t, 1)
+
+		poolName := ""
+		var err1, err2 error
+		switch actorType {
+		case typesUtil.ActorType_App:
+			err1 = ctx.Context.SetParam(typesUtil.AppUnstakingBlocksParamName, 0)
+			err2 = ctx.Context.SetParam(typesUtil.AppMaxPauseBlocksParamName, 0)
+			poolName = typesUtil.PoolNames_AppStakePool.String()
+		case typesUtil.ActorType_Validator:
+			err1 = ctx.Context.SetParam(typesUtil.ValidatorUnstakingBlocksParamName, 0)
+			err2 = ctx.Context.SetParam(typesUtil.ValidatorMaxPausedBlocksParamName, 0)
+			poolName = typesUtil.PoolNames_ValidatorStakePool.String()
+		case typesUtil.ActorType_Fisherman:
+			err1 = ctx.Context.SetParam(typesUtil.FishermanUnstakingBlocksParamName, 0)
+			err2 = ctx.Context.SetParam(typesUtil.FishermanMaxPauseBlocksParamName, 0)
+			poolName = typesUtil.PoolNames_FishermanStakePool.String()
+		case typesUtil.ActorType_ServiceNode:
+			err1 = ctx.Context.SetParam(typesUtil.ServiceNodeUnstakingBlocksParamName, 0)
+			err2 = ctx.Context.SetParam(typesUtil.ServiceNodeMaxPauseBlocksParamName, 0)
+			poolName = typesUtil.PoolNames_ServiceNodeStakePool.String()
+		default:
+			t.Fatalf("unexpected actor type %s", actorType.String())
+		}
 
-			poolName := ""
-			var err1, err2 error
-			switch actorType {
-			case typesUtil.ActorType_App:
-				err1 = ctx.Context.SetParam(typesUtil.AppUnstakingBlocksParamName, 0)
-				err2 = ctx.Context.SetParam(typesUtil.AppMaxPauseBlocksParamName, 0)
-				poolName = typesUtil.PoolNames_AppStakePool.String()
-			case typesUtil.ActorType_Validator:
-				err1 = ctx.Context.SetParam(typesUtil.ValidatorUnstakingBlocksParamName, 0)
-				err2 = ctx.Context.SetParam(typesUtil.ValidatorMaxPausedBlocksParamName, 0)
-				poolName = typesUtil.PoolNames_ValidatorStakePool.String()
-			case typesUtil.ActorType_Fisherman:
-				err1 = ctx.Context.SetParam(typesUtil.FishermanUnstakingBlocksParamName, 0)
-				err2 = ctx.Context.SetParam(typesUtil.FishermanMaxPauseBlocksParamName, 0)
-				poolName = typesUtil.PoolNames_FishermanStakePool.String()
-			case typesUtil.ActorType_ServiceNode:
-				err1 = ctx.Context.SetParam(typesUtil.ServiceNodeUnstakingBlocksParamName, 0)
-				err2 = ctx.Context.SetParam(typesUtil.ServiceNodeMaxPauseBlocksParamName, 0)
-				poolName = typesUtil.PoolNames_ServiceNodeStakePool.String()
-			default:
-				t.Fatalf("unexpected actor type %s", actorType.String())
-			}
+		err := ctx.SetPoolAmount(poolName, big.NewInt(math.MaxInt64))
+		require.NoError(t, err)
+		require.NoError(t, err1, "error setting unstaking blocks")
+		require.NoError(t, err2, "error setting max pause blocks")
 
-			err := ctx.SetPoolAmount(poolName, big.NewInt(math.MaxInt64))
+		actors := getAllTestingActors(t, ctx, actorType)
+		for _, actor := range actors {
+			addrBz, err := hex.DecodeString(actor.GetAddress())
 			require.NoError(t, err)
-			require.NoError(t, err1, "error setting unstaking blocks")
-			require.NoError(t, err2, "error setting max pause blocks")
-
-			actors := getAllTestingActors(t, ctx, actorType)
-			for _, actor := range actors {
-				addrBz, err := hex.DecodeString(actor.GetAddress())
-				require.NoError(t, err)
-				require.Equal(t, int64(-1), actor.GetUnstakingHeight(), "wrong starting staked status")
-				err = ctx.SetActorPauseHeight(actorType, addrBz, 1)
-				require.NoError(t, err, "error setting actor pause height")
-			}
+			require.Equal(t, int64(-1), actor.GetUnstakingHeight(), "wrong starting staked status")
+			err = ctx.SetActorPauseHeight(actorType, addrBz, 1)
+			require.NoError(t, err, "error setting actor pause height")
+		}
 
-			err = ctx.UnstakeActorPausedBefore(2, actorType)
-			require.NoError(t, err, "error setting actor pause before")
+		err = ctx.UnstakeActorPausedBefore(2, actorType)
+		require.NoError(t, err, "error setting actor pause before")
 
-			accountAmountsBefore := make([]*big.Int, 0)
+		accountAmountsBefore := make([]*big.Int, 0)
 
-			for _, actor := range actors {
-				// get the output address account amount before the 'unstake'
-				outputAddressString := actor.GetOutput()
-				outputAddress, err := hex.DecodeString(outputAddressString)
-				require.NoError(t, err)
-				outputAccountAmount, err := ctx.GetAccountAmount(outputAddress)
-				require.NoError(t, err)
-				// capture the amount before
-				accountAmountsBefore = append(accountAmountsBefore, outputAccountAmount)
-			}
-			// capture the pool amount before
-			poolAmountBefore, err := ctx.GetPoolAmount(poolName)
+		for _, actor := range actors {
+			// get the output address account amount before the 'unstake'
+			outputAddressString := actor.GetOutput()
+			outputAddress, err := hex.DecodeString(outputAddressString)
 			require.NoError(t, err)
-
-			err = ctx.UnstakeActorsThatAreReady()
-			require.NoError(t, err, "error unstaking actors that are ready")
-
-			for i, actor := range actors {
-				// get the output address account amount after the 'unstake'
-				outputAddressString := actor.GetOutput()
-				outputAddress, err := hex.DecodeString(outputAddressString)
-				require.NoError(t, err)
-				outputAccountAmount, err := ctx.GetAccountAmount(outputAddress)
-				require.NoError(t, err)
-				// ensure the stake amount went to the output address
-				outputAccountAmountDelta := new(big.Int).Sub(outputAccountAmount, accountAmountsBefore[i])
-				require.Equal(t, outputAccountAmountDelta, defaults.DefaultStakeAmount)
-			}
-			// ensure the staking pool is `# of readyToUnstake actors * default stake` less than before the unstake
-			poolAmountAfter, err := ctx.GetPoolAmount(poolName)
+			outputAccountAmount, err := ctx.GetAccountAmount(outputAddress)
 			require.NoError(t, err)
+			// capture the amount before
+			accountAmountsBefore = append(accountAmountsBefore, outputAccountAmount)
+		}
+		// capture the pool amount before
+		poolAmountBefore, err := ctx.GetPoolAmount(poolName)
+		require.NoError(t, err)
 
-			actualPoolDelta := new(big.Int).Sub(poolAmountBefore, poolAmountAfter)
-			expectedPoolDelta := new(big.Int).Mul(big.NewInt(int64(len(actors))), defaults.DefaultStakeAmount)
-			require.Equal(t, expectedPoolDelta, actualPoolDelta)
+		err = ctx.UnstakeActorsThatAreReady()
+		require.NoError(t, err, "error unstaking actors that are ready")
 
-			test_artifacts.CleanupTest(ctx)
-		})
+		for i, actor := range actors {
+			// get the output address account amount after the 'unstake'
+			outputAddressString := actor.GetOutput()
+			outputAddress, err := hex.DecodeString(outputAddressString)
+			require.NoError(t, err)
+			outputAccountAmount, err := ctx.GetAccountAmount(outputAddress)
+			require.NoError(t, err)
+			// ensure the stake amount went to the output address
+			outputAccountAmountDelta := new(big.Int).Sub(outputAccountAmount, accountAmountsBefore[i])
+			require.Equal(t, outputAccountAmountDelta, defaults.DefaultStakeAmount)
+		}
+		// ensure the staking pool is `# of readyToUnstake actors * default stake` less than before the unstake
+		poolAmountAfter, err := ctx.GetPoolAmount(poolName)
+		require.NoError(t, err)
+		actualPoolDelta := new(big.Int).Sub(poolAmountBefore, poolAmountAfter)
+		expectedPoolDelta := new(big.Int).Mul(big.NewInt(int64(len(actors))), defaults.DefaultStakeAmount)
+		require.Equal(t, expectedPoolDelta, actualPoolDelta)
+
+		test_artifacts.CleanupTest(ctx)
 	}
 }
 
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index d4d007f92..cf6529f80 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -2,7 +2,6 @@ package test
 
 import (
 	"encoding/hex"
-	"fmt"
 	"math"
 	"math/big"
 	"testing"
@@ -25,7 +24,7 @@ func TestUtilityContext_ApplyBlock(t *testing.T) {
 	require.NoError(t, er)
 	proposerBeforeBalance, err := ctx.GetAccountAmount(addrBz)
 	require.NoError(t, err)
-	er = ctx.GetPersistenceContext().SetProposalBlock("", addrBz, nil, [][]byte{txBz})
+	er = ctx.GetPersistenceContext().SetProposalBlock("", nil, addrBz, nil, [][]byte{txBz})
 	require.NoError(t, er)
 	// apply block
 	_, er = ctx.ApplyBlock()
@@ -73,7 +72,7 @@ func TestUtilityContext_BeginBlock(t *testing.T) {
 	require.NoError(t, err)
 	addrBz, er := hex.DecodeString(proposer.GetAddress())
 	require.NoError(t, er)
-	er = ctx.GetPersistenceContext().SetProposalBlock("", nil, addrBz, [nil, ][]byte{txBz})
+	er = ctx.GetPersistenceContext().SetProposalBlock("", nil, addrBz, nil, [][]byte{txBz})
 	require.NoError(t, er)
 	// apply block
 	_, er = ctx.ApplyBlock()
@@ -90,37 +89,35 @@ func TestUtilityContext_BeginBlock(t *testing.T) {
 
 func TestUtilityContext_BeginUnstakingMaxPausedActors(t *testing.T) {
 	for _, actorType := range actorTypes {
-		t.Run(fmt.Sprintf("%s.BeginUnstakingMaxPausedActors", actorType.String()), func(t *testing.T) {
-			ctx := NewTestingUtilityContext(t, 1)
-			actor := getFirstActor(t, ctx, actorType)
-
-			var err error
-			switch actorType {
-			case typesUtil.ActorType_App:
-				err = ctx.Context.SetParam(typesUtil.AppMaxPauseBlocksParamName, 0)
-			case typesUtil.ActorType_Validator:
-				err = ctx.Context.SetParam(typesUtil.ValidatorMaxPausedBlocksParamName, 0)
-			case typesUtil.ActorType_Fisherman:
-				err = ctx.Context.SetParam(typesUtil.FishermanMaxPauseBlocksParamName, 0)
-			case typesUtil.ActorType_ServiceNode:
-				err = ctx.Context.SetParam(typesUtil.ServiceNodeMaxPauseBlocksParamName, 0)
-			default:
-				t.Fatalf("unexpected actor type %s", actorType.String())
-			}
-			require.NoError(t, err)
-			addrBz, er := hex.DecodeString(actor.GetAddress())
-			require.NoError(t, er)
-			err = ctx.SetActorPauseHeight(actorType, addrBz, 0)
-			require.NoError(t, err)
-
-			err = ctx.BeginUnstakingMaxPaused()
-			require.NoError(t, err)
-
-			status, err := ctx.GetActorStatus(actorType, addrBz)
-			require.Equal(t, int32(typesUtil.StakeStatus_Unstaking), status, "incorrect status")
+		ctx := NewTestingUtilityContext(t, 1)
+		actor := getFirstActor(t, ctx, actorType)
 
-			test_artifacts.CleanupTest(ctx)
-		})
+		var err error
+		switch actorType {
+		case typesUtil.ActorType_App:
+			err = ctx.Context.SetParam(typesUtil.AppMaxPauseBlocksParamName, 0)
+		case typesUtil.ActorType_Validator:
+			err = ctx.Context.SetParam(typesUtil.ValidatorMaxPausedBlocksParamName, 0)
+		case typesUtil.ActorType_Fisherman:
+			err = ctx.Context.SetParam(typesUtil.FishermanMaxPauseBlocksParamName, 0)
+		case typesUtil.ActorType_ServiceNode:
+			err = ctx.Context.SetParam(typesUtil.ServiceNodeMaxPauseBlocksParamName, 0)
+		default:
+			t.Fatalf("unexpected actor type %s", actorType.String())
+		}
+		require.NoError(t, err)
+		addrBz, er := hex.DecodeString(actor.GetAddress())
+		require.NoError(t, er)
+		err = ctx.SetActorPauseHeight(actorType, addrBz, 0)
+		require.NoError(t, err)
+
+		err = ctx.BeginUnstakingMaxPaused()
+		require.NoError(t, err)
+
+		status, err := ctx.GetActorStatus(actorType, addrBz)
+		require.Equal(t, int32(typesUtil.StakeStatus_Unstaking), status, "incorrect status")
+
+		test_artifacts.CleanupTest(ctx)
 	}
 }
 
@@ -161,53 +158,65 @@ func TestUtilityContext_EndBlock(t *testing.T) {
 
 	test_artifacts.CleanupTest(ctx)
 }
-func TestUtilityContext_UnstakeValidatorsActorsThatAreReady(t *testing.T) {
-	for _, actorType := range actorTypes {
-		t.Run(fmt.Sprintf("%s.UnstakeValidatorsActorsThatAreReady", actorType.String()), func(t *testing.T) {
-			ctx := NewTestingUtilityContext(t, 1)
-			var poolName string
-			switch actorType {
-			case typesUtil.ActorType_App:
-				poolName = typesUtil.PoolNames_AppStakePool.String()
-			case typesUtil.ActorType_Validator:
-				poolName = typesUtil.PoolNames_ValidatorStakePool.String()
-			case typesUtil.ActorType_Fisherman:
-				poolName = typesUtil.PoolNames_FishermanStakePool.String()
-			case typesUtil.ActorType_ServiceNode:
-				poolName = typesUtil.PoolNames_ServiceNodeStakePool.String()
-			default:
-				t.Fatalf("unexpected actor type %s", actorType.String())
-			}
-
-			ctx.SetPoolAmount(poolName, big.NewInt(math.MaxInt64))
-			err := ctx.Context.SetParam(typesUtil.AppUnstakingBlocksParamName, 0)
-			require.NoError(t, err)
 
-			err = ctx.Context.SetParam(typesUtil.AppMaxPauseBlocksParamName, 0)
-			require.NoError(t, err)
+func TestUtilityContext_GetAppHash(t *testing.T) {
+	ctx := NewTestingUtilityContext(t, 0)
 
-			actors := getAllTestingActors(t, ctx, actorType)
-			for _, actor := range actors {
-				// require.Equal(t, int32(typesUtil.StakedStatus), actor.GetStatus(), "wrong starting status")
-				addrBz, er := hex.DecodeString(actor.GetAddress())
-				require.NoError(t, er)
-				er = ctx.SetActorPauseHeight(actorType, addrBz, 1)
-				require.NoError(t, er)
-			}
+	appHashTest, err := ctx.GetAppHash()
+	require.NoError(t, err)
+
+	appHashSource, er := ctx.Context.AppHash()
+	require.NoError(t, er)
+	require.Equal(t, appHashTest, appHashSource, "unexpected appHash")
+
+	test_artifacts.CleanupTest(ctx)
+}
+
+func TestUtilityContext_UnstakeValidatorsActorsThatAreReady(t *testing.T) {
+	for _, actorType := range actorTypes {
+		ctx := NewTestingUtilityContext(t, 1)
+		var poolName string
+		switch actorType {
+		case typesUtil.ActorType_App:
+			poolName = typesUtil.PoolNames_AppStakePool.String()
+		case typesUtil.ActorType_Validator:
+			poolName = typesUtil.PoolNames_ValidatorStakePool.String()
+		case typesUtil.ActorType_Fisherman:
+			poolName = typesUtil.PoolNames_FishermanStakePool.String()
+		case typesUtil.ActorType_ServiceNode:
+			poolName = typesUtil.PoolNames_ServiceNodeStakePool.String()
+		default:
+			t.Fatalf("unexpected actor type %s", actorType.String())
+		}
+
+		ctx.SetPoolAmount(poolName, big.NewInt(math.MaxInt64))
+		err := ctx.Context.SetParam(typesUtil.AppUnstakingBlocksParamName, 0)
+		require.NoError(t, err)
+
+		err = ctx.Context.SetParam(typesUtil.AppMaxPauseBlocksParamName, 0)
+		require.NoError(t, err)
+
+		actors := getAllTestingActors(t, ctx, actorType)
+		for _, actor := range actors {
+			// require.Equal(t, int32(typesUtil.StakedStatus), actor.GetStatus(), "wrong starting status")
+			addrBz, er := hex.DecodeString(actor.GetAddress())
+			require.NoError(t, er)
+			er = ctx.SetActorPauseHeight(actorType, addrBz, 1)
+			require.NoError(t, er)
+		}
 
-			err = ctx.UnstakeActorPausedBefore(2, actorType)
-			require.NoError(t, err)
+		err = ctx.UnstakeActorPausedBefore(2, actorType)
+		require.NoError(t, err)
 
-			err = ctx.UnstakeActorsThatAreReady()
-			require.NoError(t, err)
+		err = ctx.UnstakeActorsThatAreReady()
+		require.NoError(t, err)
 
-			actors = getAllTestingActors(t, ctx, actorType)
-			require.NotEqual(t, actors[0].GetUnstakingHeight(), -1, "validators still exists after unstake that are ready() call")
+		actors = getAllTestingActors(t, ctx, actorType)
+		require.NotEqual(t, actors[0].GetUnstakingHeight(), -1, "validators still exists after unstake that are ready() call")
 
-			// TODO: We need to better define what 'deleted' really is in the postgres world.
-			// We might not need to 'unstakeActorsThatAreReady' if we are already filtering by unstakingHeight
+		// TODO: We need to better define what 'deleted' really is in the postgres world.
+		// We might not need to 'unstakeActorsThatAreReady' if we are already filtering by unstakingHeight
 
-			test_artifacts.CleanupTest(ctx)
-		})
+		test_artifacts.CleanupTest(ctx)
 	}
 }

From 7566bceb2243875ef04a59c305a8ca531bfb2841 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 8 Nov 2022 21:03:42 -0800
Subject: [PATCH 142/227] Got
 TestStateHash_ReplayingRandomTransactionsIsDeterministic working

---
 persistence/state.go                     |  26 ++--
 persistence/test/benchmark_state_test.go |  37 +++--
 persistence/test/state_test.go           | 170 +++++++++++++----------
 3 files changed, 131 insertions(+), 102 deletions(-)

diff --git a/persistence/state.go b/persistence/state.go
index 8a358bb17..01fdc1aae 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -84,19 +84,19 @@ var merkleTreeToActorTypeName map[merkleTree]types.ActorType = map[merkleTree]ty
 	serviceNodeMerkleTree: types.ActorType_Node,
 }
 
-var merkleTreeToProtoSchema = map[merkleTree]func() proto.Message{
-	appMerkleTree:         func() proto.Message { return &types.Actor{} },
-	valMerkleTree:         func() proto.Message { return &types.Actor{} },
-	fishMerkleTree:        func() proto.Message { return &types.Actor{} },
-	serviceNodeMerkleTree: func() proto.Message { return &types.Actor{} },
-
-	accountMerkleTree: func() proto.Message { return &types.Account{} },
-	poolMerkleTree:    func() proto.Message { return &types.Account{} },
-
-	transactionsMerkleTree: func() proto.Message { return &types.Transaction{} },
-	paramsMerkleTree:       func() proto.Message { return &types.Params{} },
-	flagsMerkleTree:        func() proto.Message { return &types.Params{} },
-}
+// var merkleTreeToProtoSchema = map[merkleTree]func() proto.Message{
+// 	appMerkleTree:         func() proto.Message { return &types.Actor{} },
+// 	valMerkleTree:         func() proto.Message { return &types.Actor{} },
+// 	fishMerkleTree:        func() proto.Message { return &types.Actor{} },
+// 	serviceNodeMerkleTree: func() proto.Message { return &types.Actor{} },
+
+// 	accountMerkleTree: func() proto.Message { return &types.Account{} },
+// 	poolMerkleTree:    func() proto.Message { return &types.Account{} },
+
+// 	transactionsMerkleTree: func() proto.Message { return &types.Transaction{} },
+// 	paramsMerkleTree:       func() proto.Message { return &types.Params{} },
+// 	flagsMerkleTree:        func() proto.Message { return &types.Params{} },
+// }
 
 func newStateTrees(treesStoreDir string) (*stateTrees, error) {
 	if treesStoreDir == "" {
diff --git a/persistence/test/benchmark_state_test.go b/persistence/test/benchmark_state_test.go
index d5873ece1..03deab898 100644
--- a/persistence/test/benchmark_state_test.go
+++ b/persistence/test/benchmark_state_test.go
@@ -17,8 +17,11 @@ import (
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
-// var isModifierRe = regexp.MustCompile(`^(Insert|Update|Set|Add|Subtract)`)
-var isModifierRe = regexp.MustCompile(`^(Insert|Set|Add|Subtract)`)
+const (
+	maxStringAmount = 1000000000000000000
+)
+
+var isModifierRe = regexp.MustCompile(`^(Insert|Set|Add|Subtract)`) // Add Update?
 
 // INVESTIGATE: This benchmark can be used to experiment with different Merkle Tree implementations
 // and key-value stores.
@@ -28,17 +31,20 @@ func BenchmarkStateHash(b *testing.B) {
 
 	b.Cleanup(clearAllState)
 
-	// Rather than using `b.N` and the `-benchtime` flag, we use a fixed number of iterations
+	// NOTE: THe idiomatic way to run Go benchmarks is to use `b.N` and the `-benchtime` flag,
+	// to specify how long the benchmark should take. However, the code below is non-idiomatic
+	// since our goal is to test a specific we use a fixed number of iterations
 	testCases := []struct {
 		numHeights     int64
-		numTxPerHeight int64
+		numTxPerHeight int
+		numOpsPerTx    int
 	}{
-		// {1, 1},
-		{1, 100},
-		// {100, 1},
-		// {100, 10},
-		// {1000, 1},
-		// {1000, 10},
+		{1, 1, 1},
+		{1, 100, 1},
+		{100, 1, 1},
+		{100, 10, 1},
+		{1000, 1, 1},
+		{1000, 10, 1},
 		// {10000, 10},
 		// {10000, 1000},
 	}
@@ -46,14 +52,17 @@ func BenchmarkStateHash(b *testing.B) {
 	for _, testCase := range testCases {
 		numHeights := testCase.numHeights
 		numTxPerHeight := testCase.numTxPerHeight
-		b.Run(fmt.Sprintf("heights=%d;txPerHeight=%d", numHeights, numTxPerHeight), func(b *testing.B) {
+		numOpsPerTx := testCase.numOpsPerTx
+
+		b.Run(fmt.Sprintf("BenchmarkStateHash(%d;%d,%d)", numHeights, numTxPerHeight, numOpsPerTx), func(b *testing.B) {
 			for h := int64(0); h < numHeights; h++ {
 				db := NewTestPostgresContext(b, h)
-				for i := int64(0); i < numTxPerHeight; i++ {
+
+				for i := 0; i < numTxPerHeight; i++ {
 					callRandomDatabaseModifierFunc(db, h, false)
 					db.IndexTransaction(modules.TxResult(getRandomTxResult(h)))
-					// db.SetProposalBlock()
 				}
+
 				db.ComputeAppHash()
 				db.Commit([]byte("TODOquorumCert"))
 			}
@@ -90,7 +99,7 @@ MethodLoop:
 			switch arg.Kind() {
 			case reflect.String:
 				// String values in modifier functions are usually amounts
-				v = reflect.ValueOf(getRandomIntString(1000000))
+				v = reflect.ValueOf(getRandomIntString(maxStringAmount))
 			case reflect.Slice:
 				switch arg.Elem().Kind() {
 				case reflect.Uint8:
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index 3ea152e58..07c673bbe 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -3,6 +3,7 @@ package test
 import (
 	"encoding/binary"
 	"encoding/hex"
+	"fmt"
 	"reflect"
 	"strconv"
 	"testing"
@@ -18,20 +19,29 @@ const (
 	txBytesRandSeed = "42"
 	txBytesSize     = 42
 
+	proposerBytesSize   = 10
+	quorumCertBytesSize = 10
+
 	// This value is arbitrarily selected, but needs to be a constant to guarantee deterministic tests.
 	initialStakeAmount = 42
 )
 
-// Tests/debug to implement:
-// - Add a tool to easily see what's in the tree (visualize, size, etc...)
-// - Benchmark what happens when we add a shit ton of thins into the trie
-// - Fuzz a test that results in the same final state but uses different ways to get there
-// - Think about:
-//       - Thinking about how it can be synched
-//       - Playing back several blocks
-// - Add TODOs for:
-// 		- Atomicity
-//      - Bad tests
+type TestReplayableOperation struct {
+	methodName string
+	args       []reflect.Value
+}
+type TestReplayableTransaction struct {
+	operations []*TestReplayableOperation
+	txResult   modules.TxResult
+}
+
+type TestReplayableBlock struct {
+	height     int64
+	txs        []*TestReplayableTransaction
+	hash       []byte
+	proposer   []byte
+	quorumCert []byte
+}
 
 func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 	// These hashes were determined manually by running the test, but hardcoded to guarantee
@@ -86,7 +96,7 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 		require.Equal(t, expectedAppHash, hex.EncodeToString(appHash))
 
 		// Commit the transactions above
-		err = db.Commit([]byte("TODOquorumCert"))
+		err = db.Commit(getRandomBytes(quorumCertBytesSize))
 		require.NoError(t, err)
 
 		// Retrieve the block
@@ -106,96 +116,106 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 	}
 }
 
-func TestStateHash_TreeUpdatesAreIdempotent(t *testing.T) {
-}
+func TestStateHash_ReplayingRandomTransactionsIsDeterministic(t *testing.T) {
+	t.Cleanup(clearAllState)
+	clearAllState()
 
-// Contintously updating the same value at the same height should not result in a delta
+	testCases := []struct {
+		numHeights      int64
+		numTxsPerHeight int
+		numOpsPerTx     int
+		numReplays      int
+	}{
+		{1, 2, 1, 3},
+		// {10, 2, 5, 5},
+	}
 
-type TestReplayableOperation struct {
-	methodName string
-	args       []reflect.Value
-}
-type TestReplayableTransaction struct {
-	operations []*TestReplayableOperation
-	txResult   modules.TxResult
-}
+	for _, testCase := range testCases {
+		numHeights := testCase.numHeights
+		numTxsPerHeight := testCase.numTxsPerHeight
+		numOpsPerTx := testCase.numOpsPerTx
+		numReplays := testCase.numReplays
 
-type TestReplayableBlock struct {
-	height     int64
-	txs        []*TestReplayableTransaction
-	hash       []byte
-	proposer   []byte
-	quorumCert []byte
-}
+		t.Run(fmt.Sprintf("ReplayingRandomTransactionsIsDeterministic(%d;%d,%d,%d", numHeights, numTxsPerHeight, numOpsPerTx, numReplays), func(t *testing.T) {
+			replayableBlocks := make([]*TestReplayableBlock, numHeights)
 
-func TestStateHash_RandomButDeterministic(t *testing.T) {
-	t.Cleanup(clearAllState)
-	clearAllState()
+			for height := int64(0); height < int64(numHeights); height++ {
+				db := NewTestPostgresContext(t, height)
+				replayableTxs := make([]*TestReplayableTransaction, numTxsPerHeight)
 
-	numHeights := 1 //10
-	numTxsPerHeight := 2
-	numOpsPerTx := 1 //5
-	numReplays := 1  //5
+				for txIdx := 0; txIdx < numTxsPerHeight; txIdx++ {
+					replayableOps := make([]*TestReplayableOperation, numOpsPerTx)
 
-	replayableBlocks := make([]*TestReplayableBlock, numHeights)
-	for height := int64(0); height < int64(numHeights); height++ {
-		db := NewTestPostgresContext(t, height)
-		replayableTxs := make([]*TestReplayableTransaction, numTxsPerHeight)
-		for txIdx := 0; txIdx < numTxsPerHeight; txIdx++ {
-			replayableOps := make([]*TestReplayableOperation, numOpsPerTx)
-			for opIdx := 0; opIdx < numOpsPerTx; opIdx++ {
-				methodName, args, err := callRandomDatabaseModifierFunc(db, height, true)
-				require.NoError(t, err)
-				replayableOps[opIdx] = &TestReplayableOperation{
-					methodName: methodName,
-					args:       args,
+					for opIdx := 0; opIdx < numOpsPerTx; opIdx++ {
+						methodName, args, err := callRandomDatabaseModifierFunc(db, height, true)
+						require.NoError(t, err)
+
+						replayableOps[opIdx] = &TestReplayableOperation{
+							methodName: methodName,
+							args:       args,
+						}
+					}
+
+					txResult := modules.TxResult(getRandomTxResult(height))
+					err := db.IndexTransaction(txResult)
+					require.NoError(t, err)
+
+					replayableTxs[txIdx] = &TestReplayableTransaction{
+						operations: replayableOps,
+						txResult:   txResult,
+					}
 				}
-			}
-			txResult := modules.TxResult(getRandomTxResult(height))
-			// err := db.StoreTransaction(txResult)
-			// require.NoError(t, err)
 
-			replayableTxs[txIdx] = &TestReplayableTransaction{
-				operations: replayableOps,
-				txResult:   txResult,
-			}
-		}
-		appHash, err := db.ComputeAppHash()
-		require.NoError(t, err)
+				appHash, err := db.ComputeAppHash()
+				require.NoError(t, err)
 
-		proposer := getRandomBytes(10)
-		quorumCert := getRandomBytes(10)
-		err = db.Commit(quorumCert)
-		require.NoError(t, err)
+				proposer := getRandomBytes(proposerBytesSize)
+				quorumCert := getRandomBytes(quorumCertBytesSize)
 
-		replayableBlocks[height] = &TestReplayableBlock{
-			height:     height,
-			txs:        replayableTxs,
-			hash:       appHash,
-			proposer:   proposer,
-			quorumCert: quorumCert,
-		}
-	}
+				err = db.Commit(quorumCert)
+				require.NoError(t, err)
+
+				replayableBlocks[height] = &TestReplayableBlock{
+					height:     height,
+					txs:        replayableTxs,
+					hash:       appHash,
+					proposer:   proposer,
+					quorumCert: quorumCert,
+				}
+			}
 
-	for i := 0; i < numReplays; i++ {
-		t.Run("verify block", func(t *testing.T) {
-			verifyReplayableBlocks(t, replayableBlocks)
+			for i := 0; i < numReplays; i++ {
+				t.Run("verify block", func(t *testing.T) {
+					verifyReplayableBlocks(t, replayableBlocks)
+				})
+			}
 		})
 	}
 }
 
+func TestStateHash_TreeUpdatesAreIdempotent(t *testing.T) {
+	// TODO_IN_THIS_COMMIT: Running the same oepration at the same height should not result in a
+	// a different hash because the final state is still the same.
+}
+
+func TestStateHash_TreeUpdatesNegativeTestCase(t *testing.T) {
+	// TODO_IN_NEXT_COMMIT: Implement me
+}
+
 func verifyReplayableBlocks(t *testing.T, replayableBlocks []*TestReplayableBlock) {
 	t.Cleanup(clearAllState)
 	clearAllState()
 
 	for _, block := range replayableBlocks {
 		db := NewTestPostgresContext(t, block.height)
+
 		for _, tx := range block.txs {
 			for _, op := range tx.operations {
 				require.Nil(t, reflect.ValueOf(db).MethodByName(op.methodName).Call(op.args)[0].Interface())
 			}
-			// require.NoError(t, db.StoreTransaction(tx.txResult))
+			require.NoError(t, db.IndexTransaction(tx.txResult))
 		}
+
 		appHash, err := db.ComputeAppHash()
 		require.NoError(t, err)
 		require.Equal(t, block.hash, appHash)

From 3336af64f345d2091b18114ff391e054202a85cb Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 8 Nov 2022 21:06:07 -0800
Subject: [PATCH 143/227] Removed unnecessary merkleTreeToProtoSchema

---
 persistence/state.go | 14 --------------
 1 file changed, 14 deletions(-)

diff --git a/persistence/state.go b/persistence/state.go
index 01fdc1aae..8b97ef4e1 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -84,20 +84,6 @@ var merkleTreeToActorTypeName map[merkleTree]types.ActorType = map[merkleTree]ty
 	serviceNodeMerkleTree: types.ActorType_Node,
 }
 
-// var merkleTreeToProtoSchema = map[merkleTree]func() proto.Message{
-// 	appMerkleTree:         func() proto.Message { return &types.Actor{} },
-// 	valMerkleTree:         func() proto.Message { return &types.Actor{} },
-// 	fishMerkleTree:        func() proto.Message { return &types.Actor{} },
-// 	serviceNodeMerkleTree: func() proto.Message { return &types.Actor{} },
-
-// 	accountMerkleTree: func() proto.Message { return &types.Account{} },
-// 	poolMerkleTree:    func() proto.Message { return &types.Account{} },
-
-// 	transactionsMerkleTree: func() proto.Message { return &types.Transaction{} },
-// 	paramsMerkleTree:       func() proto.Message { return &types.Params{} },
-// 	flagsMerkleTree:        func() proto.Message { return &types.Params{} },
-// }
-
 func newStateTrees(treesStoreDir string) (*stateTrees, error) {
 	if treesStoreDir == "" {
 		return newMemStateTrees()

From 054b93a10865e08fb24d463be50ca72b0634f66e Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 8 Nov 2022 21:36:08 -0800
Subject: [PATCH 144/227] make test_persistence passes

---
 persistence/block.go                     |  2 +-
 persistence/module.go                    |  1 -
 persistence/test/benchmark_state_test.go |  5 ++++-
 persistence/test/state_test.go           | 15 +++++++++------
 shared/modules/persistence_module.go     |  4 ++--
 utility/block.go                         | 13 +++++++++----
 utility/test/block_test.go               | 19 +++----------------
 7 files changed, 28 insertions(+), 31 deletions(-)

diff --git a/persistence/block.go b/persistence/block.go
index bab29d7b4..7445af4fe 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -104,7 +104,7 @@ func (p *PostgresContext) prepareBlock(quorumCert []byte) (*types.Block, error)
 
 	block := &types.Block{
 		Height:            uint64(p.Height),
-		Hash:              hex.EncodeToString([]byte(p.blockHash)),
+		Hash:              p.blockHash,
 		PrevHash:          hex.EncodeToString(prevHash),
 		ProposerAddress:   p.proposerAddr,
 		QuorumCertificate: quorumCert,
diff --git a/persistence/module.go b/persistence/module.go
index 75b3c5d14..4a6184880 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -175,7 +175,6 @@ func (m *persistenceModule) NewRWContext(height int64) (modules.PersistenceRWCon
 		proposerAddr: nil,
 		quorumCert:   nil,
 		blockHash:    "",
-		blockTxs:     nil,
 	}
 
 	return m.writeContext, nil
diff --git a/persistence/test/benchmark_state_test.go b/persistence/test/benchmark_state_test.go
index 03deab898..669229ca0 100644
--- a/persistence/test/benchmark_state_test.go
+++ b/persistence/test/benchmark_state_test.go
@@ -59,7 +59,10 @@ func BenchmarkStateHash(b *testing.B) {
 				db := NewTestPostgresContext(b, h)
 
 				for i := 0; i < numTxPerHeight; i++ {
-					callRandomDatabaseModifierFunc(db, h, false)
+
+					for op := 0; op < numOpsPerTx; op++ {
+						callRandomDatabaseModifierFunc(db, h, false)
+					}
 					db.IndexTransaction(modules.TxResult(getRandomTxResult(h)))
 				}
 
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index 07c673bbe..bbf9abf27 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -48,9 +48,9 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 	// that the business logic doesn't change and that they remain deterministic. Anytime the business
 	// logic changes, these hashes will need to be updated based on the test output.
 	encodedAppHash := []string{
-		"a68dbbcddb69355f893000f9ba07dee1d9615cfd1c5db2a41296bff331b4e99d",
-		// "1e736e8c94c899f9ac6544744a0f12d2ed29d4e611e7c088f14fc338499fb166",
-		// "ce9bf6328228cd8caf138ddc440a8fd512af6a25542c9863562abeb5c793dd82",
+		"b076081d48f6652d2302c974f20e5371b4728c7950735f6617aac7b6be62f581",
+		"171af2b820d2a65861c4e63f0cdd9c8bdde4798e6ace28c47d0e83467848ab02",
+		"b168dff3a83215f12093e548aa22cdf907fbfdb1e12d217ffbb4a07beca065f1",
 	}
 
 	stakeAmount := initialStakeAmount
@@ -96,7 +96,12 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 		require.Equal(t, expectedAppHash, hex.EncodeToString(appHash))
 
 		// Commit the transactions above
-		err = db.Commit(getRandomBytes(quorumCertBytesSize))
+		proposer := []byte("placeholderProposer")
+		quorumCert := []byte("placeholderQuorumCert")
+
+		db.SetProposalBlock(hex.EncodeToString(appHash), proposer, quorumCert, [][]byte{txBz})
+
+		err = db.Commit(quorumCert)
 		require.NoError(t, err)
 
 		// Retrieve the block
@@ -107,8 +112,6 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 		var block types.Block
 		err = codec.GetCodec().Unmarshal(blockBz, &block)
 		require.NoError(t, err)
-		// require.Len(t, block.Transactions, 1)
-		// require.Equal(t, txResult.GetTx(), block.Transactions[0])
 		require.Equal(t, expectedAppHash, block.Hash) // verify block hash
 		if i > 0 {
 			require.Equal(t, encodedAppHash[i-1], block.PrevHash) // verify chain chain
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index d076471a4..65410c9c7 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -59,7 +59,8 @@ type PersistenceWriteContext interface {
 
 	// Block Operations
 	SetProposalBlock(blockHash string, proposerAddr []byte, quorumCert []byte, transactions [][]byte) error
-	ComputeAppHash() ([]byte, error)
+	GetLatestBlockTxs() [][]byte              // Returns the transactions set by `SetProposalBlock`
+	ComputeAppHash() ([]byte, error)          // Update the merkle trees, computes the new state hash, and returns in
 	IndexTransaction(txResult TxResult) error // DISCUSS_IN_THIS_COMMIT: How can we remove `TxResult` from the public interface?
 
 	// Pool Operations
@@ -126,7 +127,6 @@ type PersistenceReadContext interface {
 	GetPrevAppHash() (string, error)               // Returns the app hash from the previous block relate to the context height
 	GetBlockHash(height int64) ([]byte, error)     // Returns the app hash corresponding to the height provides
 	GetLatestProposerAddr() []byte                 // Returns the proposer set via `SetProposalBlock`
-	GetLatestBlockTxs() [][]byte                   // Returns the transactions set via `SetProposalBlock`
 	GetBlocksPerSession(height int64) (int, error) // TECHDEBT(#286): Deprecate this method
 
 	// Indexer Queries
diff --git a/utility/block.go b/utility/block.go
index e940813f7..055ef458a 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -30,7 +30,6 @@ func (u *UtilityContext) CreateAndApplyProposalBlock(proposer []byte, maxTransac
 		return nil, nil, err
 	}
 	transactions := make([][]byte, 0)
-	txResults := make([]modules.TxResult, 0)
 	totalTxsSizeInBytes := 0
 	txIndex := 0
 	for u.Mempool.Size() != typesUtil.ZeroInt {
@@ -62,9 +61,11 @@ func (u *UtilityContext) CreateAndApplyProposalBlock(proposer []byte, maxTransac
 			totalTxsSizeInBytes -= txTxsSizeInBytes
 			continue
 		}
-		
+		if err := u.Context.IndexTransaction(txResult); err != nil {
+			log.Fatalf("TODO(#327): We can apply the transaction but not index it. Crash the process for now: %v\n", err)
+		}
+
 		transactions = append(transactions, txBytes)
-		txResults = append(txResults, txResult)
 		txIndex++
 	}
 	if err := u.EndBlock(proposer); err != nil {
@@ -101,11 +102,15 @@ func (u *UtilityContext) ApplyBlock() (appHash []byte, err error) {
 		//                Or wait until the entire lifecycle is over to evaluate an 'invalid' block
 
 		// Validate and apply the transaction to the Postgres database
-		_, err = u.ApplyTransaction(index, tx)
+		txResult, err := u.ApplyTransaction(index, tx)
 		if err != nil {
 			return nil, err
 		}
 
+		if err := u.Context.IndexTransaction(txResult); err != nil {
+			log.Fatalf("TODO(#327): We can apply the transaction but not index it. Crash the process for now: %v\n", err)
+		}
+
 		// TODO: if found, remove transaction from mempool.
 		// DISCUSS: What if the context is rolled back or cancelled. Do we add it back to the mempool?
 		// if err := u.Mempool.DeleteTransaction(transaction); err != nil {
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index cf6529f80..d2e6a56c0 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -24,7 +24,7 @@ func TestUtilityContext_ApplyBlock(t *testing.T) {
 	require.NoError(t, er)
 	proposerBeforeBalance, err := ctx.GetAccountAmount(addrBz)
 	require.NoError(t, err)
-	er = ctx.GetPersistenceContext().SetProposalBlock("", nil, addrBz, nil, [][]byte{txBz})
+	er = ctx.GetPersistenceContext().SetProposalBlock("", addrBz, nil, [][]byte{txBz})
 	require.NoError(t, er)
 	// apply block
 	_, er = ctx.ApplyBlock()
@@ -72,7 +72,7 @@ func TestUtilityContext_BeginBlock(t *testing.T) {
 	require.NoError(t, err)
 	addrBz, er := hex.DecodeString(proposer.GetAddress())
 	require.NoError(t, er)
-	er = ctx.GetPersistenceContext().SetProposalBlock("", nil, addrBz, nil, [][]byte{txBz})
+	er = ctx.GetPersistenceContext().SetProposalBlock("", addrBz, nil, [][]byte{txBz})
 	require.NoError(t, er)
 	// apply block
 	_, er = ctx.ApplyBlock()
@@ -133,7 +133,7 @@ func TestUtilityContext_EndBlock(t *testing.T) {
 	require.NoError(t, er)
 	proposerBeforeBalance, err := ctx.GetAccountAmount(addrBz)
 	require.NoError(t, err)
-	er = ctx.GetPersistenceContext().SetProposalBlock("", nil, addrBz, nil, [][]byte{txBz})
+	er = ctx.GetPersistenceContext().SetProposalBlock("", addrBz, nil, [][]byte{txBz})
 	require.NoError(t, er)
 	// apply block
 	_, er = ctx.ApplyBlock()
@@ -159,19 +159,6 @@ func TestUtilityContext_EndBlock(t *testing.T) {
 	test_artifacts.CleanupTest(ctx)
 }
 
-func TestUtilityContext_GetAppHash(t *testing.T) {
-	ctx := NewTestingUtilityContext(t, 0)
-
-	appHashTest, err := ctx.GetAppHash()
-	require.NoError(t, err)
-
-	appHashSource, er := ctx.Context.AppHash()
-	require.NoError(t, er)
-	require.Equal(t, appHashTest, appHashSource, "unexpected appHash")
-
-	test_artifacts.CleanupTest(ctx)
-}
-
 func TestUtilityContext_UnstakeValidatorsActorsThatAreReady(t *testing.T) {
 	for _, actorType := range actorTypes {
 		ctx := NewTestingUtilityContext(t, 1)

From 4dae396b41fa86013d47bd8c6fb0bd474068b4d6 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 10 Nov 2022 16:25:31 -0800
Subject: [PATCH 145/227] Added TODO for #344R

---
 app/client/cli/debug.go                | 10 +++++-----
 shared/debug/proto/debug_message.proto |  3 ++-
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/app/client/cli/debug.go b/app/client/cli/debug.go
index db24cacd8..1ea960061 100644
--- a/app/client/cli/debug.go
+++ b/app/client/cli/debug.go
@@ -23,11 +23,11 @@ import (
 
 // TECHDEBT: Lowercase variables / constants that do not need to be exported.
 const (
-	PromptResetToGenesis         string = "ResetToGenesis (broadcast)"
-	PromptPrintNodeState         string = "PrintNodeState (broadcast)"
-	PromptTriggerNextView        string = "TriggerNextView (broadcast)"
-	PromptTogglePacemakerMode    string = "TogglePacemakerMode (broadcast)"
-	PromptShowLatestBlockInStore string = "ShowLatestBlockInStore (send)"
+	PromptResetToGenesis         string = "ResetToGenesis"
+	PromptPrintNodeState         string = "PrintNodeState"
+	PromptTriggerNextView        string = "TriggerNextView"
+	PromptTogglePacemakerMode    string = "TogglePacemakerMode"
+	PromptShowLatestBlockInStore string = "ShowLatestBlockInStore"
 
 	defaultConfigPath  = "build/config/config1.json"
 	defaultGenesisPath = "build/config/genesis.json"
diff --git a/shared/debug/proto/debug_message.proto b/shared/debug/proto/debug_message.proto
index 85941eeb2..5ac05319c 100644
--- a/shared/debug/proto/debug_message.proto
+++ b/shared/debug/proto/debug_message.proto
@@ -13,12 +13,13 @@ enum DebugMessageAction {
 	DEBUG_CONSENSUS_TRIGGER_NEXT_VIEW = 3;
 	DEBUG_CONSENSUS_TOGGLE_PACE_MAKER_MODE = 4; // toggle between manual and automatic
 
-	DEBUG_SHOW_LATEST_BLOCK_IN_STORE = 5; // toggle between manual and automatic
+	DEBUG_SHOW_LATEST_BLOCK_IN_STORE = 5;
 
 	DEBUG_PERSISTENCE_CLEAR_STATE = 6;
 	DEBUG_PERSISTENCE_RESET_TO_GENESIS = 7;
 }
 
+// IMPROVE(#344): Add a message type for each action
 message DebugMessage {
   DebugMessageAction action = 1;
   google.protobuf.Any message = 2;

From 991fe30a1d578683f167bcab914b9fb872228e16 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky@pokt.network>
Date: Thu, 10 Nov 2022 16:40:57 -0800
Subject: [PATCH 146/227] Update persistence/test/benchmark_state_test.go

Co-authored-by: Andrew Nguyen <amnguyen1@mail.usf.edu>
---
 persistence/test/benchmark_state_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/persistence/test/benchmark_state_test.go b/persistence/test/benchmark_state_test.go
index 669229ca0..6f4a1f468 100644
--- a/persistence/test/benchmark_state_test.go
+++ b/persistence/test/benchmark_state_test.go
@@ -31,7 +31,7 @@ func BenchmarkStateHash(b *testing.B) {
 
 	b.Cleanup(clearAllState)
 
-	// NOTE: THe idiomatic way to run Go benchmarks is to use `b.N` and the `-benchtime` flag,
+	// NOTE: The idiomatic way to run Go benchmarks is to use `b.N` and the `-benchtime` flag,
 	// to specify how long the benchmark should take. However, the code below is non-idiomatic
 	// since our goal is to test a specific we use a fixed number of iterations
 	testCases := []struct {

From 898f4a7e4e4c97b5d515047e91f33c09b4ec5efb Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky@pokt.network>
Date: Thu, 10 Nov 2022 17:42:35 -0800
Subject: [PATCH 147/227] Update persistence/account.go

Co-authored-by: Andrew Nguyen <amnguyen1@mail.usf.edu>
---
 persistence/account.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/persistence/account.go b/persistence/account.go
index 56fbb3bb1..fd27fc6d5 100644
--- a/persistence/account.go
+++ b/persistence/account.go
@@ -166,7 +166,8 @@ func (p *PostgresContext) getPoolOrAccUpdatedInternal(query string) (accounts []
 	if err != nil {
 		return nil, err
 	}
-
+	defer rows.Close()
+	
 	accounts = make([]*types.Account, 0)
 	for rows.Next() {
 		account := new(types.Account)

From 05db30410d23e1554f398ef17d3d4feffab49af3 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 10 Nov 2022 16:28:04 -0800
Subject: [PATCH 148/227] Tend to minor comments

---
 consensus/block.go            | 3 +--
 consensus/hotstuff_replica.go | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/consensus/block.go b/consensus/block.go
index 2008308a1..3ad4f327e 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -57,8 +57,7 @@ func (m *consensusModule) refreshUtilityContext() error {
 	// Ideally, this should not be called.
 	if m.utilityContext != nil {
 		m.nodeLog(typesCons.NilUtilityContextWarning)
-		err := m.utilityContext.Release()
-		if err != nil {
+		if err := m.utilityContext.Release(); err != nil {
 			log.Printf("[WARN] Error releasing utility context: %v\n", err)
 		}
 		m.utilityContext = nil
diff --git a/consensus/hotstuff_replica.go b/consensus/hotstuff_replica.go
index de80a6998..9373f9549 100644
--- a/consensus/hotstuff_replica.go
+++ b/consensus/hotstuff_replica.go
@@ -240,8 +240,7 @@ func (m *consensusModule) applyBlock(block *typesCons.Block) error {
 	}
 
 	// CONSOLIDATE: Terminology of `appHash` and `stateHash`
-	appHashString := hex.EncodeToString(appHash)
-	if blockHeader.Hash != appHashString {
+	if appHashString := hex.EncodeToString(appHash); blockHeader.Hash != appHashString {
 		return typesCons.ErrInvalidAppHash(blockHeader.Hash, appHashString)
 	}
 

From f5ca864c837e12bb2a94e7d0b52d76ef923eef39 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 10 Nov 2022 16:49:48 -0800
Subject: [PATCH 149/227] Remove height from callRandomDatabaseModifierFunc

---
 persistence/test/benchmark_state_test.go | 3 +--
 persistence/test/state_test.go           | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/persistence/test/benchmark_state_test.go b/persistence/test/benchmark_state_test.go
index 6f4a1f468..e1bd39dad 100644
--- a/persistence/test/benchmark_state_test.go
+++ b/persistence/test/benchmark_state_test.go
@@ -61,7 +61,7 @@ func BenchmarkStateHash(b *testing.B) {
 				for i := 0; i < numTxPerHeight; i++ {
 
 					for op := 0; op < numOpsPerTx; op++ {
-						callRandomDatabaseModifierFunc(db, h, false)
+						callRandomDatabaseModifierFunc(db, false)
 					}
 					db.IndexTransaction(modules.TxResult(getRandomTxResult(h)))
 				}
@@ -76,7 +76,6 @@ func BenchmarkStateHash(b *testing.B) {
 // Calls a random database modifier function on the given persistence context
 func callRandomDatabaseModifierFunc(
 	p *persistence.PostgresContext,
-	height int64,
 	mustSucceed bool,
 ) (string, []reflect.Value, error) {
 	t := reflect.TypeOf(modules.PersistenceWriteContext(p))
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index bbf9abf27..35d53533d 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -150,7 +150,7 @@ func TestStateHash_ReplayingRandomTransactionsIsDeterministic(t *testing.T) {
 					replayableOps := make([]*TestReplayableOperation, numOpsPerTx)
 
 					for opIdx := 0; opIdx < numOpsPerTx; opIdx++ {
-						methodName, args, err := callRandomDatabaseModifierFunc(db, height, true)
+						methodName, args, err := callRandomDatabaseModifierFunc(db, true)
 						require.NoError(t, err)
 
 						replayableOps[opIdx] = &TestReplayableOperation{

From fa7a39271d12d8f35b06436155c350bcf5deddbe Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 10 Nov 2022 17:35:57 -0800
Subject: [PATCH 150/227] minor improvements to benchmarking code

---
 Makefile                                 |  2 +-
 persistence/test/benchmark_state_test.go | 37 ++++++++++++++----------
 2 files changed, 22 insertions(+), 17 deletions(-)

diff --git a/Makefile b/Makefile
index 6f876444b..2ff9b8ff7 100644
--- a/Makefile
+++ b/Makefile
@@ -377,7 +377,7 @@ test_p2p_raintree_addrbook:
 .PHONY: benchmark_persistence_state_hash
 ## Benchmark the state hash computation
 benchmark_persistence_state_hash:
-	go test ${VERBOSE_TEST} -bench=. -run BenchmarkStateHash -count=1 ./persistence/...
+	go test ${VERBOSE_TEST} -cpu 1,2 -benchtime=1s -benchmem -bench=. -run BenchmarkStateHash -count=1 ./persistence/...
 
 .PHONY: benchmark_sortition
 ## Benchmark the Sortition library
diff --git a/persistence/test/benchmark_state_test.go b/persistence/test/benchmark_state_test.go
index e1bd39dad..73e2e0a20 100644
--- a/persistence/test/benchmark_state_test.go
+++ b/persistence/test/benchmark_state_test.go
@@ -29,6 +29,7 @@ func BenchmarkStateHash(b *testing.B) {
 	log.SetOutput(ioutil.Discard)
 	defer log.SetOutput(os.Stderr)
 
+	clearAllState()
 	b.Cleanup(clearAllState)
 
 	// NOTE: The idiomatic way to run Go benchmarks is to use `b.N` and the `-benchtime` flag,
@@ -40,13 +41,17 @@ func BenchmarkStateHash(b *testing.B) {
 		numOpsPerTx    int
 	}{
 		{1, 1, 1},
-		{1, 100, 1},
-		{100, 1, 1},
-		{100, 10, 1},
-		{1000, 1, 1},
-		{1000, 10, 1},
-		// {10000, 10},
-		// {10000, 1000},
+		{1, 1, 10},
+		{1, 10, 10},
+
+		{10, 1, 1},
+		{10, 1, 10},
+		{10, 10, 10},
+
+		// This takes a VERY long time to run
+		// {100, 1, 1},
+		// {100, 1, 100},
+		// {100, 100, 100},
 	}
 
 	for _, testCase := range testCases {
@@ -54,20 +59,19 @@ func BenchmarkStateHash(b *testing.B) {
 		numTxPerHeight := testCase.numTxPerHeight
 		numOpsPerTx := testCase.numOpsPerTx
 
-		b.Run(fmt.Sprintf("BenchmarkStateHash(%d;%d,%d)", numHeights, numTxPerHeight, numOpsPerTx), func(b *testing.B) {
-			for h := int64(0); h < numHeights; h++ {
-				db := NewTestPostgresContext(b, h)
-
-				for i := 0; i < numTxPerHeight; i++ {
-
-					for op := 0; op < numOpsPerTx; op++ {
+		// Since this is a benchmark, errors are not
+		b.Run(fmt.Sprintf("height=%d;txs=%d,ops=%d", numHeights, numTxPerHeight, numOpsPerTx), func(b *testing.B) {
+			for height := int64(0); height < numHeights; height++ {
+				db := NewTestPostgresContext(b, height)
+				for txIdx := 0; txIdx < numTxPerHeight; txIdx++ {
+					for opIdx := 0; opIdx < numOpsPerTx; opIdx++ {
 						callRandomDatabaseModifierFunc(db, false)
 					}
-					db.IndexTransaction(modules.TxResult(getRandomTxResult(h)))
+					db.IndexTransaction(modules.TxResult(getRandomTxResult(height)))
 				}
-
 				db.ComputeAppHash()
 				db.Commit([]byte("TODOquorumCert"))
+				db.Release()
 			}
 		})
 	}
@@ -157,6 +161,7 @@ func getRandomIntString(n int) string {
 	return strconv.Itoa(rand.Intn(n))
 }
 
+// NOTE: This is not current used but was added for future usage.
 func getRandomString(numChars int64) string {
 	return string(getRandomBytes(numChars))
 }

From 3f5235843c9a105ec1191f7a0db47544bd8d9fa9 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 10 Nov 2022 17:38:41 -0800
Subject: [PATCH 151/227] Updated comments in persistence/HandleDebugMessage

---
 persistence/debug.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/persistence/debug.go b/persistence/debug.go
index f6e65589e..9ce16cb74 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -23,10 +23,12 @@ func (m *persistenceModule) HandleDebugMessage(debugMessage *debug.DebugMessage)
 	switch debugMessage.Action {
 	case debug.DebugMessageAction_DEBUG_SHOW_LATEST_BLOCK_IN_STORE:
 		m.showLatestBlockInStore(debugMessage)
+	// Clears all the state (SQL DB, KV Stores, Trees, etc) to nothing
 	case debug.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE:
 		if err := m.clearAllState(debugMessage); err != nil {
 			return err
 		}
+	// Clears all the state (SQL DB, KV Stores, Trees, etc) to the tate specified in the genesis file provided
 	case debug.DebugMessageAction_DEBUG_PERSISTENCE_RESET_TO_GENESIS:
 		if err := m.clearAllState(debugMessage); err != nil {
 			return err

From bb1069cce1bf1421a3c07c9e1c614d8dbebe8087 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 10 Nov 2022 17:42:49 -0800
Subject: [PATCH 152/227] Append to nil slice

---
 persistence/account.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/persistence/account.go b/persistence/account.go
index fd27fc6d5..a5db3bc19 100644
--- a/persistence/account.go
+++ b/persistence/account.go
@@ -167,8 +167,7 @@ func (p *PostgresContext) getPoolOrAccUpdatedInternal(query string) (accounts []
 		return nil, err
 	}
 	defer rows.Close()
-	
-	accounts = make([]*types.Account, 0)
+
 	for rows.Next() {
 		account := new(types.Account)
 		var height int64

From 4f9f87df23ee9887678fa2f6b5daa2902fe771bf Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky@pokt.network>
Date: Thu, 10 Nov 2022 17:57:26 -0800
Subject: [PATCH 153/227] Update persistence/debug.go

Co-authored-by: Andrew Nguyen <amnguyen1@mail.usf.edu>
---
 persistence/debug.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/persistence/debug.go b/persistence/debug.go
index 9ce16cb74..a3aa11323 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -56,7 +56,7 @@ func (m *persistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 	log.Printf("Block at height %d: %+v \n", height, block)
 }
 
-// TODO: MAke sure this is atomic
+// TODO: Make sure this is atomic
 func (m *persistenceModule) clearAllState(_ *debug.DebugMessage) error {
 	context, err := m.NewRWContext(-1)
 	if err != nil {

From e442648ed62d54785d9d87ab4da23d1a47306dd2 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky@pokt.network>
Date: Thu, 10 Nov 2022 20:10:28 -0800
Subject: [PATCH 154/227] Update persistence/state.go

Co-authored-by: Andrew Nguyen <amnguyen1@mail.usf.edu>
---
 persistence/state.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/persistence/state.go b/persistence/state.go
index 8b97ef4e1..f8b004d65 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -27,7 +27,7 @@ type stateTrees struct {
 // A list of Merkle Trees used to maintain the state hash.
 const (
 	// VERY IMPORTANT: The order in which these trees are defined is important and strict. It implicitly
-	// defines the index of the the root hash each independent as they are concatenated together
+	// defines the index of the root hash each independent as they are concatenated together
 	// to generate the state hash.
 
 	// Actor Merkle Trees

From 4b86e6f15f6763e4e01fe38ae73743b35dd061a6 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 10 Nov 2022 17:50:11 -0800
Subject: [PATCH 155/227] Remove unused height var when getting all accounts
 updated

---
 persistence/account.go       | 3 +--
 persistence/types/account.go | 4 ++--
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/persistence/account.go b/persistence/account.go
index a5db3bc19..335260915 100644
--- a/persistence/account.go
+++ b/persistence/account.go
@@ -170,8 +170,7 @@ func (p *PostgresContext) getPoolOrAccUpdatedInternal(query string) (accounts []
 
 	for rows.Next() {
 		account := new(types.Account)
-		var height int64
-		if err = rows.Scan(&account.Address, &account.Amount, &height); err != nil {
+		if err = rows.Scan(&account.Address, &account.Amount); err != nil {
 			return nil, err
 		}
 		accounts = append(accounts, account)
diff --git a/persistence/types/account.go b/persistence/types/account.go
index 5174345d2..07f0aa7d4 100644
--- a/persistence/types/account.go
+++ b/persistence/types/account.go
@@ -81,11 +81,11 @@ func SelectPools(height int64, tableName string) string {
 }
 
 func GetAccountsUpdatedAtHeightQuery(height int64) string {
-	return SelectAtHeight(AllColsSelector, height, AccountTableName)
+	return SelectAtHeight(fmt.Sprintf("%s,%s", AddressCol, BalanceCol), height, AccountTableName)
 }
 
 func GetPoolsUpdatedAtHeightQuery(height int64) string {
-	return SelectAtHeight(AllColsSelector, height, PoolTableName)
+	return SelectAtHeight(fmt.Sprintf("%s,%s", NameCol, BalanceCol), height, PoolTableName)
 }
 
 func ClearAllAccounts() string {

From c353335cb6c4185991b825c1ccac2a6efc682bc5 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 10 Nov 2022 17:56:14 -0800
Subject: [PATCH 156/227] Removed unnecessary height param

---
 persistence/block.go |  4 ++--
 persistence/state.go | 30 +++++++++++++++---------------
 2 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/persistence/block.go b/persistence/block.go
index 7445af4fe..22cec7940 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -97,7 +97,7 @@ func (p *PostgresContext) prepareBlock(quorumCert []byte) (*types.Block, error)
 		}
 	}
 
-	txsHash, err := p.getTxsHash(p.Height)
+	txsHash, err := p.getTxsHash()
 	if err != nil {
 		return nil, err
 	}
@@ -134,7 +134,7 @@ func (p PostgresContext) storeBlock(block *types.Block) error {
 	return p.blockStore.Set(heightToBytes(p.Height), blockBz)
 }
 
-func (p PostgresContext) getTxsHash(height int64) ([]byte, error) {
+func (p PostgresContext) getTxsHash() ([]byte, error) {
 	// The order (descending) is important here since it is used to comprise the hash in the block
 	txResults, err := p.txIndexer.GetByHeight(p.Height, false)
 	if err != nil {
diff --git a/persistence/state.go b/persistence/state.go
index f8b004d65..cdbd0cd09 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -143,31 +143,31 @@ func (p *PostgresContext) updateMerkleTrees() ([]byte, error) {
 			if !ok {
 				return nil, fmt.Errorf("no actor type found for merkle tree: %v\n", treeType)
 			}
-			if err := p.updateActorsTree(actorType, p.Height); err != nil {
+			if err := p.updateActorsTree(actorType); err != nil {
 				return nil, err
 			}
 
 		// Account Merkle Trees
 		case accountMerkleTree:
-			if err := p.updateAccountTrees(p.Height); err != nil {
+			if err := p.updateAccountTrees(); err != nil {
 				return nil, err
 			}
 		case poolMerkleTree:
-			if err := p.updatePoolTrees(p.Height); err != nil {
+			if err := p.updatePoolTrees(); err != nil {
 				return nil, err
 			}
 
 		// Data Merkle Trees
 		case transactionsMerkleTree:
-			if err := p.updateTransactionsTree(p.Height); err != nil {
+			if err := p.updateTransactionsTree(); err != nil {
 				return nil, err
 			}
 		case paramsMerkleTree:
-			if err := p.updateParamsTree(p.Height); err != nil {
+			if err := p.updateParamsTree(); err != nil {
 				return nil, err
 			}
 		case flagsMerkleTree:
-			if err := p.updateFlagsTree(p.Height); err != nil {
+			if err := p.updateFlagsTree(); err != nil {
 				return nil, err
 			}
 
@@ -192,8 +192,8 @@ func (p *PostgresContext) updateMerkleTrees() ([]byte, error) {
 
 // Actor Tree Helpers
 
-func (p *PostgresContext) updateActorsTree(actorType types.ActorType, height int64) error {
-	actors, err := p.getActorsUpdatedAtHeight(actorType, height)
+func (p *PostgresContext) updateActorsTree(actorType types.ActorType) error {
+	actors, err := p.getActorsUpdatedAtHeight(actorType, p.Height)
 	if err != nil {
 		return err
 	}
@@ -252,8 +252,8 @@ func (p *PostgresContext) getActorsUpdatedAtHeight(actorType types.ActorType, he
 
 // Account Tree Helpers
 
-func (p *PostgresContext) updateAccountTrees(height int64) error {
-	accounts, err := p.getAccountsUpdated(height)
+func (p *PostgresContext) updateAccountTrees() error {
+	accounts, err := p.getAccountsUpdated(p.Height)
 	if err != nil {
 		return err
 	}
@@ -277,8 +277,8 @@ func (p *PostgresContext) updateAccountTrees(height int64) error {
 	return nil
 }
 
-func (p *PostgresContext) updatePoolTrees(height int64) error {
-	pools, err := p.getPoolsUpdated(height)
+func (p *PostgresContext) updatePoolTrees() error {
+	pools, err := p.getPoolsUpdated(p.Height)
 	if err != nil {
 		return err
 	}
@@ -300,7 +300,7 @@ func (p *PostgresContext) updatePoolTrees(height int64) error {
 
 // Data Tree Helpers
 
-func (p *PostgresContext) updateTransactionsTree(height int64) error {
+func (p *PostgresContext) updateTransactionsTree() error {
 	txResults, err := p.txIndexer.GetByHeight(p.Height, false)
 	if err != nil {
 		return err
@@ -319,12 +319,12 @@ func (p *PostgresContext) updateTransactionsTree(height int64) error {
 	return nil
 }
 
-func (p *PostgresContext) updateParamsTree(height int64) error {
+func (p *PostgresContext) updateParamsTree() error {
 	// TODO_IN_NEXT_COMMIT(olshansky): Implement me
 	return nil
 }
 
-func (p *PostgresContext) updateFlagsTree(height int64) error {
+func (p *PostgresContext) updateFlagsTree() error {
 	// TODO_IN_NEXT_COMMIT(olshansky): Implement me
 	return nil
 }

From 4ec24213083af01a6b40bc5cd5551e86be0660a8 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 10 Nov 2022 19:40:10 -0800
Subject: [PATCH 157/227] Added txsOrderInBlockHashDescending constant

---
 persistence/block.go | 12 ++++++++----
 persistence/debug.go |  3 +--
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/persistence/block.go b/persistence/block.go
index 22cec7940..538f655f1 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -11,6 +11,12 @@ import (
 	"github.com/pokt-network/pocket/shared/crypto"
 )
 
+const (
+	// The order (ascending) is important here since it is used to comprise the hash in the block.
+	// If this changes, the txsHash in the block will differ rendering it invalid.
+	txsOrderInBlockHashDescending = false
+)
+
 // OPTIMIZE(team): get from blockstore or keep in memory
 func (p PostgresContext) GetLatestBlockHeight() (latestHeight uint64, err error) {
 	ctx, tx, err := p.GetCtxAndTx()
@@ -134,14 +140,12 @@ func (p PostgresContext) storeBlock(block *types.Block) error {
 	return p.blockStore.Set(heightToBytes(p.Height), blockBz)
 }
 
-func (p PostgresContext) getTxsHash() ([]byte, error) {
-	// The order (descending) is important here since it is used to comprise the hash in the block
-	txResults, err := p.txIndexer.GetByHeight(p.Height, false)
+func (p PostgresContext) getTxsHash() (txs []byte, err error) {
+	txResults, err := p.txIndexer.GetByHeight(p.Height, txsHashInBlockOrderAscending)
 	if err != nil {
 		return nil, err
 	}
 
-	txs := make([]byte, 0)
 	for _, txResult := range txResults {
 		txHash, err := txResult.Hash()
 		if err != nil {
diff --git a/persistence/debug.go b/persistence/debug.go
index a3aa11323..5cc0e5984 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -49,9 +49,8 @@ func (m *persistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 		log.Printf("Error getting block %d from block store: %s \n", height, err)
 		return
 	}
-	codec := codec.GetCodec()
 	block := &types.Block{}
-	codec.Unmarshal(blockBytes, block)
+	codec.GetCodec().Unmarshal(blockBytes, block)
 
 	log.Printf("Block at height %d: %+v \n", height, block)
 }

From ca658f08c4056e2448b8d3778ba0706c4673b089 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 10 Nov 2022 20:27:41 -0800
Subject: [PATCH 158/227] A few minor edits

---
 persistence/block.go      | 2 +-
 persistence/shared_sql.go | 2 +-
 persistence/state.go      | 6 +++---
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/persistence/block.go b/persistence/block.go
index 538f655f1..2cbabee46 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -141,7 +141,7 @@ func (p PostgresContext) storeBlock(block *types.Block) error {
 }
 
 func (p PostgresContext) getTxsHash() (txs []byte, err error) {
-	txResults, err := p.txIndexer.GetByHeight(p.Height, txsHashInBlockOrderAscending)
+	txResults, err := p.txIndexer.GetByHeight(p.Height, txsOrderInBlockHashDescending)
 	if err != nil {
 		return nil, err
 	}
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
index 09494afe9..6936d9659 100644
--- a/persistence/shared_sql.go
+++ b/persistence/shared_sql.go
@@ -72,7 +72,7 @@ func (p *PostgresContext) GetActorsUpdated(actorSchema types.ProtocolActorSchema
 
 	actors = make([]*types.Actor, len(addrs))
 	for i, addr := range addrs {
-		actor, err := p.GetActor(actorSchema, []byte(addr), height)
+		actor, err := p.GetActor(actorSchema, addr, height)
 		if err != nil {
 			return nil, err
 		}
diff --git a/persistence/state.go b/persistence/state.go
index cdbd0cd09..c40502f6e 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -63,21 +63,21 @@ var merkleTreeToString = map[merkleTree]string{
 	flagsMerkleTree:        "flags",
 }
 
-var actorTypeToMerkleTreeName map[types.ActorType]merkleTree = map[types.ActorType]merkleTree{
+var actorTypeToMerkleTreeName = map[types.ActorType]merkleTree{
 	types.ActorType_App:  appMerkleTree,
 	types.ActorType_Val:  valMerkleTree,
 	types.ActorType_Fish: fishMerkleTree,
 	types.ActorType_Node: serviceNodeMerkleTree,
 }
 
-var actorTypeToSchemaName map[types.ActorType]types.ProtocolActorSchema = map[types.ActorType]types.ProtocolActorSchema{
+var actorTypeToSchemaName = map[types.ActorType]types.ProtocolActorSchema{
 	types.ActorType_App:  types.ApplicationActor,
 	types.ActorType_Val:  types.ValidatorActor,
 	types.ActorType_Fish: types.FishermanActor,
 	types.ActorType_Node: types.ServiceNodeActor,
 }
 
-var merkleTreeToActorTypeName map[merkleTree]types.ActorType = map[merkleTree]types.ActorType{
+var merkleTreeToActorTypeName = map[merkleTree]types.ActorType{
 	appMerkleTree:         types.ActorType_App,
 	valMerkleTree:         types.ActorType_Val,
 	fishMerkleTree:        types.ActorType_Fish,

From 85078f37a77782e164f9521a6da154739b0d0107 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Thu, 10 Nov 2022 20:43:31 -0800
Subject: [PATCH 159/227] Updated documentation for ComputeAppHash

---
 persistence/context.go | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/persistence/context.go b/persistence/context.go
index 62818882b..71f545fbb 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -22,11 +22,23 @@ func (p PostgresContext) RollbackToSavePoint(bytes []byte) error {
 }
 
 func (p *PostgresContext) ComputeAppHash() ([]byte, error) {
-	// DISCUSS_IN_THIS_COMMIT:
+	// !!! DISCUSS_IN_THIS_COMMIT !!!
+
+	// `PostgresContext` contains a `blockHash` in its state set by `SetProposalBlock`.
+	// The caller of `ComputeAppHash` is responsible (given the context) to compare
+	// the return hash with the proposed hash (if that is the case).
+
+	// Situations:
+	// 	1. What if `p.updateMerkleTrees()` != `p.blockHash` && `p.blockHash` != nil?
+	// 	2. Do we set `p.blockHash` =`p.updateMerkleTrees()` if it's nil?
+	// 	3. In `SetProposalBlock`,
+
+	// Future work: Need to implement rollback of the trees (i.e. key-value stores) alongside the SQL DB transaction.
+
 	// 1. Should we compare the `appHash` returned from `updateMerkleTrees`?
 	// 2. Should this update the internal state of the context?
-	// Proposal: If the current internal appHash is not set, we update it.
-	//           If the current internal appHash is set, we compare it and return an error if different.
+	// Idea: If `p.blockHash` is nil => update it
+	//       If `p.blockHash` is nil => compare it with the return value of `updateMerkleTrees` and error if different
 	return p.updateMerkleTrees()
 }
 

From 25439db46fb38275420099c56b4935efa0dc6367 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Fri, 11 Nov 2022 14:00:49 -0800
Subject: [PATCH 160/227] Added db_cli_node

---
 Makefile | 8 ++++++++
 go.mod   | 1 +
 2 files changed, 9 insertions(+)

diff --git a/Makefile b/Makefile
index 9ad10f84d..31f391654 100644
--- a/Makefile
+++ b/Makefile
@@ -162,6 +162,14 @@ db_cli:
 	echo "View schema by running 'SELECT schema_name FROM information_schema.schemata;'"
 	docker exec -it pocket-db bash -c "psql -U postgres"
 
+psqlSchema ?= node1
+
+.PHONY: db_cli_node
+## Open a CLI to the local containerized postgres instance for a specific node
+db_cli_node:
+	echo "View all avialable tables by running \dt"
+	docker exec -it pocket-db bash -c "PGOPTIONS=--search_path=${psqlSchema} psql -U postgres"
+
 .PHONY: db_drop
 ## Drop all schemas used for LocalNet development matching `node%`
 db_drop: docker_check
diff --git a/go.mod b/go.mod
index 9d996637b..90e531b54 100644
--- a/go.mod
+++ b/go.mod
@@ -84,6 +84,7 @@ require (
 	github.com/go-openapi/jsonpointer v0.19.5 // indirect
 	github.com/go-openapi/swag v0.19.5 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/golang-jwt/jwt v3.2.2+incompatible // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
 	github.com/invopop/yaml v0.1.0 // indirect
 	github.com/jackc/chunkreader/v2 v2.0.1 // indirect

From 4e81e6a19f6ae87d80d3e073c72e3cffcd2197d7 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Fri, 11 Nov 2022 14:13:08 -0800
Subject: [PATCH 161/227] Update utility/block.go

---
 utility/block.go | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/utility/block.go b/utility/block.go
index 055ef458a..ced7be8d5 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -68,11 +68,17 @@ func (u *UtilityContext) CreateAndApplyProposalBlock(proposer []byte, maxTransac
 		transactions = append(transactions, txBytes)
 		txIndex++
 	}
+
 	if err := u.EndBlock(proposer); err != nil {
 		return nil, nil, err
 	}
+
 	// return the app hash (consensus module will get the validator set directly)
-	appHash, err := u.getAppHash()
+	appHash, err := u.Context.ComputeAppHash()
+	if err != nil {
+		log.Fatalf("Updating the app hash failed: %v. TODO: Look into roll-backing the entire commit...\n", err)
+	}
+
 	return appHash, transactions, err
 }
 
@@ -157,14 +163,6 @@ func (u *UtilityContext) EndBlock(proposer []byte) typesUtil.Error {
 	return nil
 }
 
-func (u *UtilityContext) getAppHash() ([]byte, typesUtil.Error) {
-	appHash, er := u.Context.ComputeAppHash()
-	if er != nil {
-		return nil, typesUtil.ErrAppHash(er)
-	}
-	return appHash, nil
-}
-
 // HandleByzantineValidators handles the validators who either didn't sign at all or disagreed with the 2/3+ majority
 func (u *UtilityContext) HandleByzantineValidators(lastBlockByzantineValidators [][]byte) typesUtil.Error {
 	latestBlockHeight, err := u.GetLatestBlockHeight()

From e7c34551130911675049c5fe6d2d4783979b11fa Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Fri, 11 Nov 2022 14:55:29 -0800
Subject: [PATCH 162/227] Added unit tests for GetPoolsUpdated and
 GetAccountsUpdated

---
 persistence/account.go           |  6 +-
 persistence/state.go             |  4 +-
 persistence/test/account_test.go | 96 ++++++++++++++++++++++++++++++++
 3 files changed, 100 insertions(+), 6 deletions(-)

diff --git a/persistence/account.go b/persistence/account.go
index 335260915..feac02075 100644
--- a/persistence/account.go
+++ b/persistence/account.go
@@ -68,8 +68,7 @@ func (p PostgresContext) SetAccountAmount(address []byte, amount string) error {
 	return nil
 }
 
-// TODO_IN_THIS_COMMIT: Add unit tests for this
-func (p PostgresContext) getAccountsUpdated(height int64) (accounts []*types.Account, err error) {
+func (p PostgresContext) GetAccountsUpdated(height int64) (accounts []*types.Account, err error) {
 	return p.getPoolOrAccUpdatedInternal(types.GetAccountsUpdatedAtHeightQuery(height))
 }
 
@@ -147,8 +146,7 @@ func (p *PostgresContext) operationPoolAmount(name string, amount string, op fun
 	return p.operationPoolOrAccAmount(name, amount, op, p.GetPoolAmount, types.InsertPoolAmountQuery)
 }
 
-// TODO_IN_THIS_COMMIT: Add unit tests for this
-func (p PostgresContext) getPoolsUpdated(height int64) ([]*types.Account, error) {
+func (p PostgresContext) GetPoolsUpdated(height int64) ([]*types.Account, error) {
 	return p.getPoolOrAccUpdatedInternal(types.GetPoolsUpdatedAtHeightQuery(height))
 }
 
diff --git a/persistence/state.go b/persistence/state.go
index c40502f6e..87c6f1643 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -253,7 +253,7 @@ func (p *PostgresContext) getActorsUpdatedAtHeight(actorType types.ActorType, he
 // Account Tree Helpers
 
 func (p *PostgresContext) updateAccountTrees() error {
-	accounts, err := p.getAccountsUpdated(p.Height)
+	accounts, err := p.GetAccountsUpdated(p.Height)
 	if err != nil {
 		return err
 	}
@@ -278,7 +278,7 @@ func (p *PostgresContext) updateAccountTrees() error {
 }
 
 func (p *PostgresContext) updatePoolTrees() error {
-	pools, err := p.getPoolsUpdated(p.Height)
+	pools, err := p.GetPoolsUpdated(p.Height)
 	if err != nil {
 		return err
 	}
diff --git a/persistence/test/account_test.go b/persistence/test/account_test.go
index 82ed66b79..fd679c1ab 100644
--- a/persistence/test/account_test.go
+++ b/persistence/test/account_test.go
@@ -141,6 +141,54 @@ func TestAddAccountAmount(t *testing.T) {
 	require.Equal(t, expectedAccountAmount, accountAmount, "unexpected amount after add")
 }
 
+func TestAccountsUpdatedAtHeight(t *testing.T) {
+	db := NewTestPostgresContext(t, 0)
+	numAccsInTestGenesis := 8
+
+	// Check num accounts in genesis
+	accs, err := db.GetAccountsUpdated(0)
+	require.NoError(t, err)
+	require.Equal(t, numAccsInTestGenesis, len(accs))
+
+	// Insert a new account at height 0
+	_, err = createAndInsertNewAccount(db)
+	require.NoError(t, err)
+
+	// Verify that num accounts incremented by 1
+	accs, err = db.GetAccountsUpdated(0)
+	require.NoError(t, err)
+	require.Equal(t, numAccsInTestGenesis+1, len(accs))
+
+	// Close context at height 0 without committing new account
+	require.NoError(t, db.Close())
+	// start a new context at height 1
+	db = NewTestPostgresContext(t, 1)
+
+	// Verify that num accounts at height 0 is genesis because the new one was not committed
+	accs, err = db.GetAccountsUpdated(0)
+	require.NoError(t, err)
+	require.Equal(t, numAccsInTestGenesis, len(accs))
+
+	// Insert a new account at height 1
+	_, err = createAndInsertNewAccount(db)
+	require.NoError(t, err)
+
+	// Verify that num accounts updated height 1 is 1
+	accs, err = db.GetAccountsUpdated(1)
+	require.NoError(t, err)
+	require.Equal(t, 1, len(accs))
+
+	// Commit & close the context at height 1
+	require.NoError(t, db.Commit(nil))
+	// start a new context at height 2
+	db = NewTestPostgresContext(t, 2)
+
+	// Verify only 1 account was updated at height 1
+	accs, err = db.GetAccountsUpdated(1)
+	require.NoError(t, err)
+	require.Equal(t, 1, len(accs))
+}
+
 func TestSubAccountAmount(t *testing.T) {
 	db := NewTestPostgresContext(t, 0)
 	account := newTestAccount(t)
@@ -315,6 +363,54 @@ func TestGetAllPools(t *testing.T) {
 	getAllActorsTest(t, db, db.GetAllPools, createAndInsertNewPool, updatePool, 7)
 }
 
+func TestPoolsUpdatedAtHeight(t *testing.T) {
+	db := NewTestPostgresContext(t, 0)
+	numPoolsInTestGenesis := 7
+
+	// Check num Pools in genesis
+	accs, err := db.GetPoolsUpdated(0)
+	require.NoError(t, err)
+	require.Equal(t, numPoolsInTestGenesis, len(accs))
+
+	// Insert a new Pool at height 0
+	_, err = createAndInsertNewPool(db)
+	require.NoError(t, err)
+
+	// Verify that num Pools incremented by 1
+	accs, err = db.GetPoolsUpdated(0)
+	require.NoError(t, err)
+	require.Equal(t, numPoolsInTestGenesis+1, len(accs))
+
+	// Close context at height 0 without committing new Pool
+	require.NoError(t, db.Close())
+	// start a new context at height 1
+	db = NewTestPostgresContext(t, 1)
+
+	// Verify that num Pools at height 0 is genesis because the new one was not committed
+	accs, err = db.GetPoolsUpdated(0)
+	require.NoError(t, err)
+	require.Equal(t, numPoolsInTestGenesis, len(accs))
+
+	// Insert a new Pool at height 1
+	_, err = createAndInsertNewPool(db)
+	require.NoError(t, err)
+
+	// Verify that num Pools updated height 1 is 1
+	accs, err = db.GetPoolsUpdated(1)
+	require.NoError(t, err)
+	require.Equal(t, 1, len(accs))
+
+	// Commit & close the context at height 1
+	require.NoError(t, db.Commit(nil))
+	// start a new context at height 2
+	db = NewTestPostgresContext(t, 2)
+
+	// Verify only 1 Pool was updated at height 1
+	accs, err = db.GetPoolsUpdated(1)
+	require.NoError(t, err)
+	require.Equal(t, 1, len(accs))
+}
+
 // --- Helpers ---
 
 func createAndInsertNewAccount(db *persistence.PostgresContext) (modules.Account, error) {

From 8a9b130472db6959d4db88d8f3099f154f5795e9 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Fri, 11 Nov 2022 15:31:36 -0800
Subject: [PATCH 163/227] Proper implementation of GetPrevHash

---
 persistence/application.go     |  1 -
 persistence/block.go           | 14 ++++++++++----
 persistence/test/block_test.go | 30 ++++++++++++++++++++++++++++++
 3 files changed, 40 insertions(+), 5 deletions(-)
 create mode 100644 persistence/test/block_test.go

diff --git a/persistence/application.go b/persistence/application.go
index 9c745ddde..23081fd98 100644
--- a/persistence/application.go
+++ b/persistence/application.go
@@ -5,7 +5,6 @@ import (
 	"log"
 
 	"github.com/pokt-network/pocket/persistence/types"
-
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
diff --git a/persistence/block.go b/persistence/block.go
index 2cbabee46..128f3fe54 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -53,14 +53,20 @@ func (p PostgresContext) GetPrevAppHash() (string, error) {
 	if err != nil {
 		return "", err
 	}
-	if height <= 1 {
-		return "TODO: get from genesis", nil
+	if height <= 0 {
+		return "", fmt.Errorf("Cannot get previous app hash relative to height %d", height)
 	}
-	block, err := p.blockStore.Get(heightToBytes(height - 1))
+
+	blockBz, err := p.blockStore.Get(heightToBytes(height - 1))
 	if err != nil {
 		return "", fmt.Errorf("error getting block hash for height %d even though it's in the database: %s", height, err)
 	}
-	return hex.EncodeToString(block), nil // TODO(#284): Return `block.Hash` instead of the hex encoded representation of the blockBz
+	var block types.Block
+	if err := codec.GetCodec().Unmarshal(blockBz, &block); err != nil {
+		return "", err
+	}
+
+	return block.Hash, nil
 }
 
 func (p PostgresContext) TransactionExists(transactionHash string) (bool, error) {
diff --git a/persistence/test/block_test.go b/persistence/test/block_test.go
new file mode 100644
index 000000000..9798197b3
--- /dev/null
+++ b/persistence/test/block_test.go
@@ -0,0 +1,30 @@
+package test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestGetPrevAppHash(t *testing.T) {
+	db := NewTestPostgresContext(t, 0)
+
+	// Cannot get prev hash at height 0
+	_, err := db.GetPrevAppHash()
+	require.Error(t, err)
+
+	db.Close()
+	db = NewTestPostgresContext(t, 1)
+
+	// Cannot a non empty prev hash at height 1 (i.e. the genesis hash)
+	appHash, err := db.GetPrevAppHash()
+	require.NoError(t, err)
+	require.NotEmpty(t, appHash)
+
+	db.Close()
+	db = NewTestPostgresContext(t, 10)
+
+	// This hash does not exist
+	appHash, err = db.GetPrevAppHash()
+	require.Error(t, err)
+}

From 93b94b1f54e805e0cb38c573f9cbed1b1885d03b Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Fri, 11 Nov 2022 15:40:35 -0800
Subject: [PATCH 164/227] Removed GetBlockHash

---
 consensus/consensus_tests/utils_test.go |  2 +-
 consensus/hotstuff_leader.go            |  2 +-
 persistence/block.go                    | 22 ----------------------
 persistence/test/block_test.go          | 21 ++++++++-------------
 shared/modules/persistence_module.go    |  1 -
 5 files changed, 10 insertions(+), 38 deletions(-)

diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 99ea3ef3d..3222b90d3 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -361,7 +361,7 @@ func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 	utilityContextMock := modulesMock.NewMockUtilityContext(ctrl)
 	persistenceContextMock := modulesMock.NewMockPersistenceRWContext(ctrl)
 	persistenceContextMock.EXPECT().SetProposalBlock(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
-	persistenceContextMock.EXPECT().GetPrevAppHash().Return("", nil).AnyTimes()
+	persistenceContextMock.EXPECT().GetBlockHash().Return("", nil).AnyTimes()
 
 	utilityContextMock.EXPECT().
 		CreateAndApplyProposalBlock(gomock.Any(), maxTxBytes).
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 2936a9a58..8fa302af9 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -349,7 +349,7 @@ func (m *consensusModule) prepareAndApplyBlock(qc *typesCons.QuorumCertificate)
 	persistenceContext := m.utilityContext.GetPersistenceContext()
 
 	// CONSOLIDATE: Last/Prev & AppHash/StateHash/BlockHash
-	prevAppHash, err := persistenceContext.GetPrevAppHash()
+	prevAppHash, err := persistenceContext.GetBlockHash(int64(m.Height) - 1)
 	if err != nil {
 		return nil, err
 	}
diff --git a/persistence/block.go b/persistence/block.go
index 128f3fe54..8e2ee0365 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -3,7 +3,6 @@ package persistence
 import (
 	"encoding/binary"
 	"encoding/hex"
-	"fmt"
 
 	"github.com/pokt-network/pocket/persistence/kvstore"
 	"github.com/pokt-network/pocket/persistence/types"
@@ -48,27 +47,6 @@ func (p PostgresContext) GetHeight() (int64, error) {
 	return p.Height, nil
 }
 
-func (p PostgresContext) GetPrevAppHash() (string, error) {
-	height, err := p.GetHeight()
-	if err != nil {
-		return "", err
-	}
-	if height <= 0 {
-		return "", fmt.Errorf("Cannot get previous app hash relative to height %d", height)
-	}
-
-	blockBz, err := p.blockStore.Get(heightToBytes(height - 1))
-	if err != nil {
-		return "", fmt.Errorf("error getting block hash for height %d even though it's in the database: %s", height, err)
-	}
-	var block types.Block
-	if err := codec.GetCodec().Unmarshal(blockBz, &block); err != nil {
-		return "", err
-	}
-
-	return block.Hash, nil
-}
-
 func (p PostgresContext) TransactionExists(transactionHash string) (bool, error) {
 	hash, err := hex.DecodeString(transactionHash)
 	if err != nil {
diff --git a/persistence/test/block_test.go b/persistence/test/block_test.go
index 9798197b3..c92f09d3c 100644
--- a/persistence/test/block_test.go
+++ b/persistence/test/block_test.go
@@ -6,25 +6,20 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestGetPrevAppHash(t *testing.T) {
+func TestGetBlockHash(t *testing.T) {
 	db := NewTestPostgresContext(t, 0)
 
 	// Cannot get prev hash at height 0
-	_, err := db.GetPrevAppHash()
-	require.Error(t, err)
-
-	db.Close()
-	db = NewTestPostgresContext(t, 1)
-
-	// Cannot a non empty prev hash at height 1 (i.e. the genesis hash)
-	appHash, err := db.GetPrevAppHash()
+	appHash, err := db.GetBlockHash(0)
 	require.NoError(t, err)
 	require.NotEmpty(t, appHash)
 
-	db.Close()
-	db = NewTestPostgresContext(t, 10)
+	// Cannot get a hash at height 1 since it doesn't exist
+	appHash, err = db.GetBlockHash(1)
+	require.Error(t, err)
 
-	// This hash does not exist
-	appHash, err = db.GetPrevAppHash()
+	// Cannot get a hash at height 10 since it doesn't exist
+	appHash, err = db.GetBlockHash(10)
 	require.Error(t, err)
+
 }
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index 65410c9c7..acf4d6206 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -124,7 +124,6 @@ type PersistenceReadContext interface {
 
 	// Block Queries
 	GetLatestBlockHeight() (uint64, error)         // Returns the height of the latest block in the persistence layer
-	GetPrevAppHash() (string, error)               // Returns the app hash from the previous block relate to the context height
 	GetBlockHash(height int64) ([]byte, error)     // Returns the app hash corresponding to the height provides
 	GetLatestProposerAddr() []byte                 // Returns the proposer set via `SetProposalBlock`
 	GetBlocksPerSession(height int64) (int, error) // TECHDEBT(#286): Deprecate this method

From f3164af73f4c118e627af82970193039c3ba9efa Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Fri, 11 Nov 2022 15:47:50 -0800
Subject: [PATCH 165/227] Update comment

---
 persistence/block.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/persistence/block.go b/persistence/block.go
index 8e2ee0365..f6e0657d4 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -124,6 +124,8 @@ func (p PostgresContext) storeBlock(block *types.Block) error {
 	return p.blockStore.Set(heightToBytes(p.Height), blockBz)
 }
 
+// Returns a digest (a single hash) of all the transactions included in the block.
+// This allows separating the integrity of the transactions from their storage.
 func (p PostgresContext) getTxsHash() (txs []byte, err error) {
 	txResults, err := p.txIndexer.GetByHeight(p.Height, txsOrderInBlockHashDescending)
 	if err != nil {

From d0dc9c11426cc1502e6c418df4c159ad1bfd3b8a Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Fri, 11 Nov 2022 19:53:36 -0800
Subject: [PATCH 166/227] Minor code cleanup throughout

---
 persistence/context.go                    | 12 +++---
 persistence/db.go                         | 20 ++++-----
 persistence/debug.go                      | 49 +++++++++++++++--------
 persistence/module.go                     |  1 -
 persistence/proto/block_persistence.proto |  8 ++--
 persistence/types/base_actor.go           |  2 +-
 runtime/test_artifacts/util.go            |  2 +-
 shared/modules/persistence_module.go      |  2 +-
 utility/test/module_test.go               |  4 +-
 9 files changed, 60 insertions(+), 40 deletions(-)

diff --git a/persistence/context.go b/persistence/context.go
index 71f545fbb..8707ebb29 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -42,6 +42,7 @@ func (p *PostgresContext) ComputeAppHash() ([]byte, error) {
 	return p.updateMerkleTrees()
 }
 
+// TECHDEBT: Make sure these operations are atomic
 func (p PostgresContext) Commit(quorumCert []byte) error {
 	log.Printf("About to commit context at height %d.\n", p.Height)
 
@@ -99,8 +100,13 @@ func (p *PostgresContext) resetContext() (err error) {
 		return nil
 	}
 
+	p.blockHash = ""
+	p.quorumCert = nil
+	p.proposerAddr = nil
+	p.blockTxs = nil
+
 	tx := p.GetTx()
-	if tx == nil {
+	if p.tx == nil {
 		return nil
 	}
 
@@ -117,10 +123,6 @@ func (p *PostgresContext) resetContext() (err error) {
 
 	p.conn = nil
 	p.tx = nil
-	p.blockHash = ""
-	p.quorumCert = nil
-	p.proposerAddr = nil
-	p.blockTxs = nil
 
 	return err
 }
diff --git a/persistence/db.go b/persistence/db.go
index 51c0ed7a2..ef4151a14 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -36,18 +36,19 @@ var protocolActorSchemas = []types.ProtocolActorSchema{
 var _ modules.PersistenceRWContext = &PostgresContext{}
 
 type PostgresContext struct {
-	Height int64 // TODO(olshansky): `Height` is only externalized for testing purposes. Replace with helpers...
+	Height int64 // TODO: `Height` is only externalized for testing purposes. Replace with helpers...
 	conn   *pgx.Conn
 	tx     pgx.Tx
 
-	// REFACTOR_IN_THIS_COMMIT: Access `blockStore` and `merkleTree` from the persistence module via bus.
+	// TECHDEBT: These three values are pointers to objects maintained by the PersistenceModule,
+	// so there should be a better way to access them (via the bus?) rather than embedding here.
 	blockStore kvstore.KVStore
 	txIndexer  indexer.TxIndexer
-
 	stateTrees *stateTrees
 
-	// DISCUSS(#284): this might be retrieved from the block store - temporarily we will access it directly from the module
-	//                following the pattern of the Consensus Module prior to pocket/issue-#315
+	// DISCUSS_IN_THIS_COMMIT:
+	// 1. Could/should we rename these to proposalXX?
+	// 2. Could/should we move these to the utilityContext?
 	proposerAddr []byte
 	quorumCert   []byte
 	blockHash    string // CONSOLIDATE: blockHash / appHash / stateHash
@@ -66,10 +67,11 @@ func (pg *PostgresContext) GetCtx() (context.Context, error) {
 	return context.TODO(), nil
 }
 
-// DISCUSS:
-// 1. Can we remove `Latest` from these Setter & Getter methods
-// 2. Can we scope that to this package?
-// 3. Is `context.go` more appropriate for these than `db.go`?
+// DISCUSS_IN_THIS_COMMIT:
+// 1. Can we remove these Getters/Setters
+// 2. Can we remove `Latest` from these Setter & Getter methods?
+// 3. Can we downscope them to this package only and remove from the interface?
+// 4. If we keep them, is `context.go` more appropriate for these than `db.go`?
 func (p PostgresContext) GetLatestProposerAddr() []byte {
 	return p.proposerAddr
 }
diff --git a/persistence/debug.go b/persistence/debug.go
index 5cc0e5984..40ab62c63 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -49,44 +49,42 @@ func (m *persistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 		log.Printf("Error getting block %d from block store: %s \n", height, err)
 		return
 	}
+
 	block := &types.Block{}
-	codec.GetCodec().Unmarshal(blockBytes, block)
+	if err := codec.GetCodec().Unmarshal(blockBytes, block); err != nil {
+		log.Printf("Error decoding block %d from block store: %s \n", height, err)
+		return
+	}
 
 	log.Printf("Block at height %d: %+v \n", height, block)
 }
 
 // TODO: Make sure this is atomic
 func (m *persistenceModule) clearAllState(_ *debug.DebugMessage) error {
-	context, err := m.NewRWContext(-1)
+	ctx, err := m.NewRWContext(-1)
 	if err != nil {
 		return err
 	}
+	postgresCtx := ctx.(*PostgresContext)
 
 	// Clear the SQL DB
-	if err := context.(*PostgresContext).clearAllSQLState(); err != nil {
+	if err := postgresCtx.clearAllSQLState(); err != nil {
 		return err
 	}
+
+	// Release the SQL context
 	if err := m.ReleaseWriteContext(); err != nil {
 		return err
 	}
 
-	// Clear the KV Stores
+	// Clear the BlockStore
 	if err := m.blockStore.ClearAll(); err != nil {
 		return err
 	}
-	for treeType := merkleTree(0); treeType < numMerkleTrees; treeType++ {
-		valueStore := m.stateTrees.valueStores[treeType]
-		nodeStore := m.stateTrees.nodeStores[treeType]
 
-		if err := valueStore.ClearAll(); err != nil {
-			return err
-		}
-		if err := nodeStore.ClearAll(); err != nil {
-			return err
-		}
-
-		// Needed in order to make sure the root is re-set correctly after clearing
-		m.stateTrees.merkleTrees[treeType] = smt.NewSparseMerkleTree(valueStore, nodeStore, sha256.New())
+	// Clear all the Trees
+	if err := postgresCtx.clearAllTreeState(); err != nil {
+		return err
 	}
 
 	log.Println("Cleared all the state")
@@ -122,3 +120,22 @@ func (p *PostgresContext) clearAllSQLState() error {
 
 	return nil
 }
+
+func (p *PostgresContext) clearAllTreeState() error {
+	for treeType := merkleTree(0); treeType < numMerkleTrees; treeType++ {
+		valueStore := p.stateTrees.valueStores[treeType]
+		nodeStore := p.stateTrees.nodeStores[treeType]
+
+		if err := valueStore.ClearAll(); err != nil {
+			return err
+		}
+		if err := nodeStore.ClearAll(); err != nil {
+			return err
+		}
+
+		// Needed in order to make sure the root is re-set correctly after clearing
+		p.stateTrees.merkleTrees[treeType] = smt.NewSparseMerkleTree(valueStore, nodeStore, sha256.New())
+	}
+
+	return nil
+}
diff --git a/persistence/module.go b/persistence/module.go
index 644770dcd..a3fc5285b 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -169,7 +169,6 @@ func (m *persistenceModule) NewRWContext(height int64) (modules.PersistenceRWCon
 		conn:   conn,
 		tx:     tx,
 
-		// TODO_IN_THIS_COMMIT: Can we access these via the bus?
 		blockStore: m.blockStore,
 		txIndexer:  m.txIndexer,
 		stateTrees: m.stateTrees,
diff --git a/persistence/proto/block_persistence.proto b/persistence/proto/block_persistence.proto
index b1a1604bd..71b1645ae 100644
--- a/persistence/proto/block_persistence.proto
+++ b/persistence/proto/block_persistence.proto
@@ -6,8 +6,8 @@ option go_package = "github.com/pokt-network/pocket/persistence/types";
 message Block {
     uint64 height = 1;
     string hash = 2;
-    string prevHash = 3;
-    bytes proposerAddress = 4;
-    bytes quorumCertificate = 5;
-    bytes transactionsHash = 6; // The has of all the translactions in the block
+    string prevHash = 3; // The hash of the block at height-1
+    bytes proposerAddress = 4; // The proposer of this block
+    bytes quorumCertificate = 5; // The quorum certificate containing signature from 2/3+ validators at height
+    bytes transactionsHash = 6; // The hash of all the translactions in the block
 }
\ No newline at end of file
diff --git a/persistence/types/base_actor.go b/persistence/types/base_actor.go
index a0c65ca6c..b5e3b2521 100644
--- a/persistence/types/base_actor.go
+++ b/persistence/types/base_actor.go
@@ -1,6 +1,6 @@
 package types
 
-// CLEANUP: Move schema related functions to a separate sub-package
+// REFACTOR: Move schema related functions to a separate sub-package
 import "github.com/pokt-network/pocket/shared/modules"
 
 var _ ProtocolActorSchema = &BaseProtocolActorSchema{}
diff --git a/runtime/test_artifacts/util.go b/runtime/test_artifacts/util.go
index 802035df5..f692b253e 100644
--- a/runtime/test_artifacts/util.go
+++ b/runtime/test_artifacts/util.go
@@ -96,5 +96,5 @@ func CleanupPostgresDocker(_ *testing.M, pool *dockertest.Pool, resource *docker
 }
 
 func CleanupTest(u utility.UtilityContext) {
-	// TODO(olshansky): Remove this since it's no longer used or necessary.
+	// CLEANUP: Remove this since it's no longer used or necessary.
 }
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index acf4d6206..44ec0f132 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -124,7 +124,7 @@ type PersistenceReadContext interface {
 
 	// Block Queries
 	GetLatestBlockHeight() (uint64, error)         // Returns the height of the latest block in the persistence layer
-	GetBlockHash(height int64) ([]byte, error)     // Returns the app hash corresponding to the height provides
+	GetBlockHash(height int64) ([]byte, error)     // Returns the app hash corresponding to the height provided
 	GetLatestProposerAddr() []byte                 // Returns the proposer set via `SetProposalBlock`
 	GetBlocksPerSession(height int64) (int, error) // TECHDEBT(#286): Deprecate this method
 
diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index b45904d04..dd861c9f3 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -63,8 +63,8 @@ func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext
 	require.NoError(t, err)
 
 	// TECHDEBT: Move the internal of cleanup into a separate function and call this in the
-	// beginning of every test. This can be problematic if we call `NewTestingUtilityContext` more
-	// than once in a single test.
+	// beginning of every test. This is an issue because if we call `NewTestingUtilityContext` more
+	// than once in a single test, we create unnecessary calls to clean.
 	t.Cleanup(func() {
 		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
 		require.NoError(t, testPersistenceMod.HandleDebugMessage(&debug.DebugMessage{

From 741949f3ba71d1434c575d03a24f7f4f95d9a689 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Fri, 11 Nov 2022 20:30:45 -0800
Subject: [PATCH 167/227] Added TODO for #346

---
 shared/docs/PROTOCOL_STATE_HASH.md | 2 ++
 utility/block.go                   | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/shared/docs/PROTOCOL_STATE_HASH.md b/shared/docs/PROTOCOL_STATE_HASH.md
index 67f1240a6..17d6d8e59 100644
--- a/shared/docs/PROTOCOL_STATE_HASH.md
+++ b/shared/docs/PROTOCOL_STATE_HASH.md
@@ -1,5 +1,7 @@
 # State Hash <!-- omit in toc -->
 
+TODO_IN_THIS_COMMIT: Make the appropriate updates necessary to the flow based on discussion items
+
 This document describes the cross-module communication using the interfaces in [../shared/modules](../shared/modules) to compute a new state hash. See module specific documentation & implementation details inside each module respectively.
 
 - [Context Management](#context-management)
diff --git a/utility/block.go b/utility/block.go
index ced7be8d5..9b3eb36fd 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -103,7 +103,7 @@ func (u *UtilityContext) ApplyBlock() (appHash []byte, err error) {
 		if err := tx.ValidateBasic(); err != nil {
 			return nil, err
 		}
-		// DISCUSS(#315): Currently, the pattern is allowing nil err with an error transaction...
+		// TODO(#346): Currently, the pattern is allowing nil err with an error transaction...
 		//                Should we terminate applyBlock immediately if there's an invalid transaction?
 		//                Or wait until the entire lifecycle is over to evaluate an 'invalid' block
 

From e10b147ad2dd55105b883d9aa91262786fbdd66c Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 14 Nov 2022 16:18:52 -0800
Subject: [PATCH 168/227] Consensus fixes

---
 consensus/block.go                      | 2 ++
 consensus/consensus_tests/utils_test.go | 2 +-
 consensus/hotstuff_leader.go            | 2 +-
 3 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/consensus/block.go b/consensus/block.go
index 3ad4f327e..f20566273 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -63,6 +63,8 @@ func (m *consensusModule) refreshUtilityContext() error {
 		m.utilityContext = nil
 	}
 
+	m.GetBus().GetPersistenceModule().ReleaseWriteContext()
+
 	utilityContext, err := m.GetBus().GetUtilityModule().NewContext(int64(m.Height))
 	if err != nil {
 		return err
diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 3222b90d3..49126c1f7 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -361,7 +361,7 @@ func baseUtilityContextMock(t *testing.T) *modulesMock.MockUtilityContext {
 	utilityContextMock := modulesMock.NewMockUtilityContext(ctrl)
 	persistenceContextMock := modulesMock.NewMockPersistenceRWContext(ctrl)
 	persistenceContextMock.EXPECT().SetProposalBlock(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
-	persistenceContextMock.EXPECT().GetBlockHash().Return("", nil).AnyTimes()
+	persistenceContextMock.EXPECT().GetBlockHash(gomock.Any()).Return([]byte(""), nil).AnyTimes()
 
 	utilityContextMock.EXPECT().
 		CreateAndApplyProposalBlock(gomock.Any(), maxTxBytes).
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 8fa302af9..9520d9182 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -364,7 +364,7 @@ func (m *consensusModule) prepareAndApplyBlock(qc *typesCons.QuorumCertificate)
 		Height:            int64(m.Height),
 		Hash:              hex.EncodeToString(appHash),
 		NumTxs:            uint32(len(txs)),
-		LastBlockHash:     prevAppHash,
+		LastBlockHash:     hex.EncodeToString(prevAppHash),
 		ProposerAddress:   m.privateKey.Address().Bytes(),
 		QuorumCertificate: qcBytes,
 	}

From b4e800792e331aea3abb41bf72e9ddfd10d13224 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky@pokt.network>
Date: Tue, 15 Nov 2022 14:50:14 -0800
Subject: [PATCH 169/227] Update shared/docs/PROTOCOL_STATE_HASH.md

Co-authored-by: Andrew Nguyen <amnguyen1@mail.usf.edu>
---
 shared/docs/PROTOCOL_STATE_HASH.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/shared/docs/PROTOCOL_STATE_HASH.md b/shared/docs/PROTOCOL_STATE_HASH.md
index 67f1240a6..229a103cd 100644
--- a/shared/docs/PROTOCOL_STATE_HASH.md
+++ b/shared/docs/PROTOCOL_STATE_HASH.md
@@ -11,7 +11,7 @@ _NOTE: The diagrams below use some [Hotstuff specific](https://arxiv.org/abs/180
 
 ## Context Management
 
-The `Utility` and `Persistence` modules maintain a context (i.e. an ephemeral states) driven by the `Consensus` module that can be released & reverted as a result of various (e.g. lack of Validator consensus) before the state is committed and persisted to disk (i.e. the block is finalized).
+The `Utility` and `Persistence` modules maintain a context (i.e. an ephemeral states) driven by the `Consensus` module that can be `released & reverted` (i.e. the block is invalid / no Validator Consensus reached) or can be `committed & persisted` to disk (i.e. the block is finalized).
 
 On every round of every height:
 

From e4135768fc703c0435bc587ecfe06108ea95d587 Mon Sep 17 00:00:00 2001
From: Alessandro De Blasis <alex@deblasis.net>
Date: Fri, 11 Nov 2022 15:29:42 +0000
Subject: [PATCH 170/227] [Utility] Local Proof of Stake CLI -  RPC server
 [part 2/2] - Issue #112 (#176)

## Description

This PR introduces a simple RPC (JSONRPC) server that will be used to interact with the CLI and/or other clients

## Issue

Part of Issue #112 but we decided to split the work in 2 separate PRs

## Type of change

Please mark the options that are relevant.

- [x] New feature, functionality or library

## List of changes

- Updated node to start an RPC server if enabled via config

## Testing

- [x] `make test_all`
- [x] [LocalNet](https://github.com/pokt-network/pocket/blob/main/docs/development/README.md) w/ all of the steps outlined in the `README`

## Checklist

- [x] I have performed a self-review of my own code
- [x] I have commented my code, particularly in hard-to-understand areas
- [x] I have tested my changes using the available tooling
- [x] If applicable, I have made corresponding changes to related local or global README
- [x] If applicable, I have added new diagrams using [mermaid.js](https://mermaid-js.github.io)
- [x] If applicable, I have added tests that prove my fix is effective or that my feature works

* feat(RPC): scaffolding

Signed-off-by: Alessandro De Blasis <alex@deblasis.net>

* feat(RPC): scaffolding

* feat(RPC): scaffolding

Signed-off-by: Alessandro De Blasis <alex@deblasis.net>

* fix(RPC): updated config handling

* fix(config.proto): updated timeout type

* feat(RPC): basic RPC server with naive sync TX broadcast

* fix(RPC): fixed HTTP method for Health and Version routes

* style(RPC): format

* refactor(Utility): RPC server RoutesMap for CLI/client use

* refactor(Utility): RPC server exporting RouteKey and RoutesMap

for CLI/client use

* feat(Utility): RPC OpenApi spec and code generation

* refactor(Utility): RPC server refactoring using code generation

RPC server refactoring with code generation from openapi spec

* feat(Utility): Updated RPC spec

* feat(Utility): Regenerated RPC boilerplate and updates

* docs(Utility): RPC and node docs barebones + RPC spec notes

* refactor(Shared): RPC config defaults -changing soon,I'm centralizin

Signed-off-by: Alessandro De Blasis <alex@deblasis.net>

* fix(Utility): RPC: updated to use test_artifacts defaults

* docs(Utility): RPC and node basic docs

* chore(Utility): fixed versioning schema

* fix(Utility): RPC configs post-merge

* feat(Consensus): configOptions

* feat(P2P): configOptions

* fix(Utility): RPC fix post merge

* fix(Utility): RPC disabled by default because of TECHDEBT

* fix(RPC): test_artifacts in runtime

* fix(go.mod): tidy

* fix(RPC): added imports used in codegen files

* feat(RPC): config proto

* feat(RPC): RPCModule and noopRpcModule

* refactor(Shared): shared.Create -> shared.CreateNode

* docs(RPC): updated code organization post refactoring

* fix(RPC): gitignoring generated files

Signed-off-by: Alessandro De Blasis <alex@deblasis.net>

* refactor(Consensus): mocks with Return(nil) and not Do(...)

* docs(RPC): updated changelog versions

* fix(Makefile): generate_rpc_openapi

* fix(Makefile): fix for git clone + make develop_test

* Update rpc/v1/openapi.yaml

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* Update rpc/doc/CHANGELOG.md

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* Update rpc/noop_module.go

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* chore(Shared): added TODOes for ValidateXXX() in modules

* docs(RPC): broadcast_tx_sync summary updated

* Update rpc/doc/README.md

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* Update rpc/doc/README.md

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* Update rpc/doc/README.md

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* fix(Makefile): gitignoring generated files breaks tests fix

* feat(Consensus): CurrentRound() and CurrentStep()

* feat(RPC): /v1/consensus/round_state

* feat(RPC): /v1/consensus/round_state handler

* docs(Docs): Adding some more color config + raw_hex_bytes

* chore(Runtime): comment spacing

* Update runtime/docs/README.md

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* chore(Consensus): SetBus mock Do(func(modules.Bus) {}) -> Return()

* docs(Pocket): changelog

* Update app/pocket/doc/README.md

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* Update app/pocket/doc/README.md

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* docs(RPC): changelog

* docs(RPC): docs TOC

* docs(RPC): Transports -> Endpoints

* feat(Tooling): swagger-ui

Signed-off-by: Alessandro De Blasis <alex@deblasis.net>

* docs(RPC): swagger ui link to editor and ref to make cmd

* feat(rpcServer): rpcServer is now IntegratableModule

* chore(Shared): tracking TODO (implement validations) #334

* fix(RPC): merge fix

* chore(go.mod): tidy

* docs(RPC): nit

* fix(RPC): int64 on RoundState fields

* refactor(Shared): unexporting XXModuleName

* feat(node): single source of truth for version + overridable

Signed-off-by: Alessandro De Blasis <alex@deblasis.net>
Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>
---
 Makefile                                |  11 ++-
 app/app.go                              |   5 ++
 app/pocket/doc/CHANGELOG.md             |  15 ++++
 app/pocket/doc/README.md                |  32 +++++++
 app/pocket/main.go                      |  13 +--
 build/config/config1.json               |   5 ++
 build/config/config2.json               |   5 ++
 build/config/config3.json               |   5 ++
 build/config/config4.json               |   5 ++
 build/deployments/docker-compose.yaml   |   8 ++
 consensus/consensus_tests/utils_test.go |  12 ++-
 consensus/leader_election/module.go     |   4 +-
 consensus/module.go                     |  13 ++-
 consensus/pacemaker.go                  |   4 +-
 go.mod                                  |   2 +
 go.sum                                  |   4 +
 p2p/module.go                           |   5 +-
 persistence/module.go                   |   6 +-
 rpc/doc/CHANGELOG.md                    |  28 ++++++
 rpc/doc/README.md                       | 111 ++++++++++++++++++++++++
 rpc/handlers.go                         |  49 +++++++++++
 rpc/module.go                           |  74 ++++++++++++++++
 rpc/noop_module.go                      |  40 +++++++++
 rpc/server.go                           |  52 +++++++++++
 rpc/types/proto/rpc_config.proto        |  11 +++
 rpc/v1/openapi.yaml                     |   9 +-
 runtime/config.go                       |  11 +++
 runtime/docs/README.md                  |  10 +++
 shared/bus.go                           |  11 +++
 shared/modules/bus_module.go            |   1 +
 shared/modules/consensus_module.go      |   2 +
 shared/modules/rpc_module.go            |   8 ++
 shared/modules/types.go                 |   1 +
 shared/node.go                          |  21 +++--
 telemetry/module.go                     |   4 +-
 telemetry/noop_module.go                |   4 +-
 telemetry/prometheus_module.go          |   5 +-
 utility/module.go                       |   5 +-
 38 files changed, 574 insertions(+), 37 deletions(-)
 create mode 100644 app/app.go
 create mode 100644 app/pocket/doc/CHANGELOG.md
 create mode 100644 app/pocket/doc/README.md
 create mode 100644 rpc/doc/CHANGELOG.md
 create mode 100644 rpc/doc/README.md
 create mode 100644 rpc/handlers.go
 create mode 100644 rpc/module.go
 create mode 100644 rpc/noop_module.go
 create mode 100644 rpc/server.go
 create mode 100644 rpc/types/proto/rpc_config.proto
 create mode 100644 shared/modules/rpc_module.go

diff --git a/Makefile b/Makefile
index 665c67090..3ca0ac38f 100644
--- a/Makefile
+++ b/Makefile
@@ -87,7 +87,6 @@ go_oapi-codegen:
 		echo "Install with 'go install github.com/deepmap/oapi-codegen/cmd/oapi-codegen@v1.11.0'"; \
 	fi; \
 	}
-
 .PHONY: go_clean_deps
 ## Runs `go mod tidy` && `go mod vendor`
 go_clean_deps:
@@ -251,6 +250,7 @@ protogen_local: go_protoc-go-inject-tag
 	protoc --go_opt=paths=source_relative  -I=./p2p/raintree/types/proto  --go_out=./p2p/types          	./p2p/raintree/types/proto/*.proto  --experimental_allow_proto3_optional
 	protoc --go_opt=paths=source_relative  -I=./p2p/types/proto           --go_out=./p2p/types          	./p2p/types/proto/*.proto           --experimental_allow_proto3_optional
 	protoc --go_opt=paths=source_relative  -I=./telemetry/proto           --go_out=./telemetry          	./telemetry/proto/*.proto           --experimental_allow_proto3_optional
+	protoc --go_opt=paths=source_relative  -I=./rpc/types/proto 		  --go_out=./rpc/types          	./rpc/types/proto/*.proto           --experimental_allow_proto3_optional
 	echo "View generated proto files by running: make protogen_show"
 
 .PHONY: protogen_docker_m1
@@ -270,7 +270,12 @@ generate_rpc_openapi: go_oapi-codegen
 	oapi-codegen  --config ./rpc/client.gen.config.yml ./rpc/v1/openapi.yaml > ./rpc/client.gen.go
 	echo "OpenAPI client and server generated"
 
+## Starts a local Swagger UI instance for the RPC API
+swagger-ui:
+	echo "Attempting to start Swagger UI at http://localhost:8080\n\n"
+	docker run -p 8080:8080 -e SWAGGER_JSON=/v1/openapi.yaml -v $(shell pwd)/rpc/v1:/v1 swaggerapi/swagger-ui
 .PHONY: generate_cli_commands_docs
+
 ### (Re)generates the CLI commands docs (this is meant to be called by CI)
 generate_cli_commands_docs:
 	$(eval cli_docs_dir = "app/client/cli/doc/commands")
@@ -285,12 +290,12 @@ test_all: # generate_mocks
 
 .PHONY: test_all_with_json
 ## Run all go unit tests, output results in json file
-test_all_with_json: # generate_mocks
+test_all_with_json: generate_rpc_openapi # generate_mocks
 	go test -p 1 -json ./... > test_results.json
 
 .PHONY: test_all_with_coverage
 ## Run all go unit tests, output results & coverage into files
-test_all_with_coverage: # generate_mocks
+test_all_with_coverage: generate_rpc_openapi # generate_mocks
 	go test -p 1 -v ./... -covermode=count -coverprofile=coverage.out
 	go tool cover -func=coverage.out -o=coverage.out
 
diff --git a/app/app.go b/app/app.go
new file mode 100644
index 000000000..881d37efa
--- /dev/null
+++ b/app/app.go
@@ -0,0 +1,5 @@
+package app
+
+var (
+	AppVersion = "v0.0.1-pre-alpha.1" // this can be injected at build time with something like: go build -ldflags "-X github.com/pokt-network/pocket/app.AppVersion=v1.0.1" ./app/pocket
+)
diff --git a/app/pocket/doc/CHANGELOG.md b/app/pocket/doc/CHANGELOG.md
new file mode 100644
index 000000000..be3b31ab8
--- /dev/null
+++ b/app/pocket/doc/CHANGELOG.md
@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to this module will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.0.0.0] - 2022-11-02
+
+### Added
+
+- Added the simplest form of feature flagging for the RPC server functionality
+- Calling the RPC server entrypoint in a goroutine if enabled
diff --git a/app/pocket/doc/README.md b/app/pocket/doc/README.md
new file mode 100644
index 000000000..fa58adaf5
--- /dev/null
+++ b/app/pocket/doc/README.md
@@ -0,0 +1,32 @@
+# Node binary
+
+The node binary is essentially the program that executes the node logic along with its supporting functions like for example the RPC server.
+
+The spirit of the documentation is to continuously update and inform the reader of the general scope of the node binary as breaking, rapid development occurs.
+
+## Flags
+
+Currently, in order to run the node, it's necessary to provide at least two flags:
+
+- `config`: Relative or absolute path to the config file
+- `genesis`: Relative or absolute path to the genesis file.
+
+### Example
+
+```bash
+pocket -config ./config.json -genesis ./genesis.json
+```
+
+## Configuration
+
+The configuration file provides a structured way for configuring various aspects of the node and how it should behave functionally.
+
+Things like "should the RPC server be enabled?", "what port should it be listening to?" are all defined in the config file.
+
+For a detailed overview of all the possible settings, please review `RuntimeMgr` at [README.md](../../../runtime/docs/README.md).
+
+## Genesis
+
+The genesis file contains the initial state (aka genesis) of the blockchain associated with each module. Feel free to dive into the specific modules and their genesis-specific types for more information.
+
+For a detailed overview of all the possible settings, please look in the `RuntimeMgr` [README.md](../../../runtime/docs/README.md).
diff --git a/app/pocket/main.go b/app/pocket/main.go
index f49f015ac..81f4d527d 100644
--- a/app/pocket/main.go
+++ b/app/pocket/main.go
@@ -4,13 +4,11 @@ import (
 	"flag"
 	"log"
 
-	"github.com/benbjohnson/clock"
+	"github.com/pokt-network/pocket/app"
+	"github.com/pokt-network/pocket/runtime"
 	"github.com/pokt-network/pocket/shared"
 )
 
-// See `docs/build/README.md` for details on how this is injected via mage.
-var version = "UNKNOWN"
-
 func main() {
 	configFilename := flag.String("config", "", "Relative or absolute path to the config file.")
 	genesisFilename := flag.String("genesis", "", "Relative or absolute path to the genesis file.")
@@ -19,10 +17,13 @@ func main() {
 	flag.Parse()
 
 	if *v {
-		log.Printf("Version flag currently unused %s\n", version)
+		log.Printf("Version flag currently unused %s\n", app.AppVersion)
 		return
 	}
-	pocketNode, err := shared.Create(*configFilename, *genesisFilename, clock.New())
+
+	runtimeMgr := runtime.NewManagerFromFiles(*configFilename, *genesisFilename)
+
+	pocketNode, err := shared.CreateNode(runtimeMgr)
 	if err != nil {
 		log.Fatalf("Failed to create pocket node: %s", err)
 	}
diff --git a/build/config/config1.json b/build/config/config1.json
index e6a377cae..a81a73bf7 100755
--- a/build/config/config1.json
+++ b/build/config/config1.json
@@ -31,5 +31,10 @@
     "enabled": true,
     "address": "0.0.0.0:9000",
     "endpoint": "/metrics"
+  },
+  "rpc": {
+    "enabled": true,
+    "port": "50832",
+    "timeout": 30000
   }
 }
diff --git a/build/config/config2.json b/build/config/config2.json
index e8bb9c78e..0583a094e 100755
--- a/build/config/config2.json
+++ b/build/config/config2.json
@@ -31,5 +31,10 @@
     "enabled": true,
     "address": "0.0.0.0:9000",
     "endpoint": "/metrics"
+  },
+  "rpc": {
+    "enabled": true,
+    "port": "50832",
+    "timeout": 30000
   }
 }
diff --git a/build/config/config3.json b/build/config/config3.json
index 5352ab5e3..37229ef36 100755
--- a/build/config/config3.json
+++ b/build/config/config3.json
@@ -31,5 +31,10 @@
     "enabled": true,
     "address": "0.0.0.0:9000",
     "endpoint": "/metrics"
+  },
+  "rpc": {
+    "enabled": true,
+    "port": "50832",
+    "timeout": 30000
   }
 }
diff --git a/build/config/config4.json b/build/config/config4.json
index 11f98b275..839c37d00 100755
--- a/build/config/config4.json
+++ b/build/config/config4.json
@@ -31,5 +31,10 @@
     "enabled": true,
     "address": "0.0.0.0:9000",
     "endpoint": "/metrics"
+  },
+  "rpc": {
+    "enabled": true,
+    "port": "50832",
+    "timeout": 30000
   }
 }
diff --git a/build/deployments/docker-compose.yaml b/build/deployments/docker-compose.yaml
index f94ac95de..d740a2bb9 100755
--- a/build/deployments/docker-compose.yaml
+++ b/build/deployments/docker-compose.yaml
@@ -35,10 +35,12 @@ services:
       - "8080"
       - "9080"
       - "9000"
+      - "50832"
     ports:
       - "7081:7081"
       - "8081:8080"
       - "9081:9080"
+      - "50832:50832"
     volumes:
       - ${PWD}:/go/src/github.com/pocket-network
     # Needed for DLV debugging
@@ -61,10 +63,12 @@ services:
       - "8080"
       - "9080"
       - "9000"
+      - "50832"
     ports:
       - "7082:7082"
       - "8082:8080"
       - "9082:9080"
+      - "50833:50832"
     volumes:
       - ${PWD}:/go/src/github.com/pocket-network
     # Needed for DLV debugging
@@ -87,10 +91,12 @@ services:
       - "8080"
       - "9080"
       - "9000"
+      - "50832"
     ports:
       - "7083:7083"
       - "8083:8080"
       - "9083:9080"
+      - "50834:50832"
     volumes:
       - ${PWD}:/go/src/github.com/pocket-network
     # Needed for DLV debugging
@@ -113,10 +119,12 @@ services:
       - "8080"
       - "9080"
       - "9000"
+      - "50832"
     ports:
       - "7084:7084"
       - "8084:8080"
       - "9084:9080"
+      - "50835:50832"
     volumes:
       - ${PWD}:/go/src/github.com/pocket-network
     # Needed for DLV debugging
diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 30b7d0625..3014af3ce 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -141,8 +141,9 @@ func CreateTestConsensusPocketNode(
 	p2pMock := baseP2PMock(t, testChannel)
 	utilityMock := baseUtilityMock(t, testChannel)
 	telemetryMock := baseTelemetryMock(t, testChannel)
+	rpcMock := baseRpcMock(t, testChannel)
 
-	bus, err := shared.CreateBus(runtimeMgr, persistenceMock, p2pMock, utilityMock, consensusMod.(modules.ConsensusModule), telemetryMock)
+	bus, err := shared.CreateBus(runtimeMgr, persistenceMock, p2pMock, utilityMock, consensusMod.(modules.ConsensusModule), telemetryMock, rpcMock)
 	require.NoError(t, err)
 
 	pk, err := cryptoPocket.NewPrivateKey(runtimeMgr.GetConfig().GetBaseConfig().GetPrivateKey())
@@ -391,6 +392,15 @@ func baseTelemetryMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockT
 	return telemetryMock
 }
 
+func baseRpcMock(t *testing.T, _ modules.EventsChannel) *modulesMock.MockRPCModule {
+	ctrl := gomock.NewController(t)
+	rpcMock := modulesMock.NewMockRPCModule(ctrl)
+	rpcMock.EXPECT().Start().Return(nil).AnyTimes()
+	rpcMock.EXPECT().SetBus(gomock.Any()).Return().AnyTimes()
+
+	return rpcMock
+}
+
 func baseTelemetryTimeSeriesAgentMock(t *testing.T) *modulesMock.MockTimeSeriesAgent {
 	ctrl := gomock.NewController(t)
 	timeSeriesAgentMock := modulesMock.NewMockTimeSeriesAgent(ctrl)
diff --git a/consensus/leader_election/module.go b/consensus/leader_election/module.go
index 8341a162c..f5f5d4c6e 100644
--- a/consensus/leader_election/module.go
+++ b/consensus/leader_election/module.go
@@ -8,7 +8,7 @@ import (
 )
 
 const (
-	LeaderElectionModuleName = "leader_election"
+	leaderElectionModuleName = "leader_election"
 )
 
 type LeaderElectionModule interface {
@@ -40,7 +40,7 @@ func (m *leaderElectionModule) Stop() error {
 }
 
 func (m *leaderElectionModule) GetModuleName() string {
-	return LeaderElectionModuleName
+	return leaderElectionModuleName
 }
 
 func (m *leaderElectionModule) SetBus(pocketBus modules.Bus) {
diff --git a/consensus/module.go b/consensus/module.go
index d0f968fe8..2ee9e825e 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -18,7 +18,7 @@ import (
 
 const (
 	DefaultLogPrefix    = "NODE" // TODO(#164): Make implicit when logging is standardized
-	ConsensusModuleName = "consensus"
+	consensusModuleName = "consensus"
 )
 
 var (
@@ -181,7 +181,7 @@ func (m *consensusModule) Stop() error {
 }
 
 func (m *consensusModule) GetModuleName() string {
-	return ConsensusModuleName
+	return consensusModuleName
 }
 
 func (m *consensusModule) GetBus() modules.Bus {
@@ -198,6 +198,7 @@ func (m *consensusModule) SetBus(pocketBus modules.Bus) {
 }
 
 func (*consensusModule) ValidateConfig(cfg modules.Config) error {
+	// TODO (#334): implement this
 	return nil
 }
 
@@ -259,6 +260,14 @@ func (m *consensusModule) CurrentHeight() uint64 {
 	return m.Height
 }
 
+func (m *consensusModule) CurrentRound() uint64 {
+	return m.Round
+}
+
+func (m *consensusModule) CurrentStep() uint64 {
+	return uint64(m.Step)
+}
+
 func (m *consensusModule) ValidatorMap() modules.ValidatorMap { // TODO: This needs to be dynamically updated during various operations and network changes.
 	return typesCons.ValidatorMapToModulesValidatorMap(m.validatorMap)
 }
diff --git a/consensus/pacemaker.go b/consensus/pacemaker.go
index 644fb9b89..203b43cdf 100644
--- a/consensus/pacemaker.go
+++ b/consensus/pacemaker.go
@@ -13,7 +13,7 @@ import (
 )
 
 const (
-	PacemakerModuleName = "pacemaker"
+	pacemakerModuleName = "pacemaker"
 )
 
 type Pacemaker interface {
@@ -93,7 +93,7 @@ func (p *paceMaker) Stop() error {
 }
 
 func (p *paceMaker) GetModuleName() string {
-	return PacemakerModuleName
+	return pacemakerModuleName
 }
 
 func (m *paceMaker) SetBus(pocketBus modules.Bus) {
diff --git a/go.mod b/go.mod
index e4f69404a..6d7599fd0 100644
--- a/go.mod
+++ b/go.mod
@@ -83,6 +83,7 @@ require (
 	github.com/fsnotify/fsnotify v1.6.0 // indirect
 	github.com/go-openapi/jsonpointer v0.19.5 // indirect
 	github.com/go-openapi/swag v0.19.5 // indirect
+	github.com/golang-jwt/jwt v3.2.2+incompatible // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
 	github.com/invopop/yaml v0.1.0 // indirect
 	github.com/jackc/chunkreader/v2 v2.0.1 // indirect
@@ -110,6 +111,7 @@ require (
 	golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 // indirect
 	golang.org/x/sys v0.0.0-20221013171732-95e765b1cc43 // indirect
 	golang.org/x/text v0.3.8 // indirect
+	golang.org/x/time v0.0.0-20201208040808-7e3f01d25324 // indirect
 	golang.org/x/tools v0.1.12 // indirect
 	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
diff --git a/go.sum b/go.sum
index 50c98d461..2425f509d 100644
--- a/go.sum
+++ b/go.sum
@@ -156,6 +156,8 @@ github.com/gofrs/uuid v4.0.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRx
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
+github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY=
+github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
 github.com/golang/glog v1.0.0 h1:nfP3RFugxnNRyKgeWd4oI1nYvXpxrx8ck8ZrcizshdQ=
 github.com/golang/glog v1.0.0/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4=
@@ -711,6 +713,8 @@ golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20201208040808-7e3f01d25324 h1:Hir2P/De0WpUhtrKGGjvSb2YxUgyZ7EFOSLIcSSpiwE=
+golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
diff --git a/p2p/module.go b/p2p/module.go
index 1e241a702..7f6e768a9 100644
--- a/p2p/module.go
+++ b/p2p/module.go
@@ -18,7 +18,7 @@ import (
 var _ modules.P2PModule = &p2pModule{}
 
 const (
-	P2PModuleName = "p2p"
+	p2pModuleName = "p2p"
 )
 
 type p2pModule struct {
@@ -82,7 +82,7 @@ func (m *p2pModule) GetBus() modules.Bus {
 }
 
 func (m *p2pModule) GetModuleName() string {
-	return P2PModuleName
+	return p2pModuleName
 }
 
 func (m *p2pModule) Start() error {
@@ -163,6 +163,7 @@ func (m *p2pModule) Send(addr cryptoPocket.Address, msg *anypb.Any, topic debug.
 }
 
 func (*p2pModule) ValidateConfig(cfg modules.Config) error {
+	// TODO (#334): implement this
 	return nil
 }
 
diff --git a/persistence/module.go b/persistence/module.go
index 755f34ae3..1d442c0c7 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -38,7 +38,7 @@ type persistenceModule struct {
 }
 
 const (
-	PersistenceModuleName = "persistence"
+	persistenceModuleName = "persistence"
 )
 
 func Create(runtimeMgr modules.RuntimeMgr) (modules.Module, error) {
@@ -116,7 +116,7 @@ func (m *persistenceModule) Stop() error {
 }
 
 func (m *persistenceModule) GetModuleName() string {
-	return PersistenceModuleName
+	return persistenceModuleName
 }
 
 func (m *persistenceModule) SetBus(bus modules.Bus) {
@@ -131,10 +131,12 @@ func (m *persistenceModule) GetBus() modules.Bus {
 }
 
 func (*persistenceModule) ValidateConfig(cfg modules.Config) error {
+	// TODO (#334): implement this
 	return nil
 }
 
 func (*persistenceModule) ValidateGenesis(genesis modules.GenesisState) error {
+	// TODO (#334): implement this
 	return nil
 }
 
diff --git a/rpc/doc/CHANGELOG.md b/rpc/doc/CHANGELOG.md
new file mode 100644
index 000000000..50f3cf428
--- /dev/null
+++ b/rpc/doc/CHANGELOG.md
@@ -0,0 +1,28 @@
+# Changelog
+
+All notable changes to this module will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.0.0.1] - 2022-11-02
+
+### Added
+
+- Consensus RoundState endpoint
+- Added CORS feature flag and config
+- Added dockerized swagger-ui
+
+## [0.0.0.0] - 2022-10-20
+
+### Added
+
+- First iteration of the RPC
+  - Endpoint: Node liveness
+  - Endpoint: Node version
+  - Endpoint Synchronous signed transaction broadcast
+  - Spec: basic Openapi.yaml
+  - Codegen: code generation for the Server + DTOs
+  - Codegen: code generation for the Client
diff --git a/rpc/doc/README.md b/rpc/doc/README.md
new file mode 100644
index 000000000..647eb3bef
--- /dev/null
+++ b/rpc/doc/README.md
@@ -0,0 +1,111 @@
+# RPC <!-- omit in toc -->
+
+This document is meant to be a starting point/placeholder for a full-fledged RPC specification that allows interaction with the nodes.
+
+## Contents <!-- omit in toc -->
+
+- [Inspiration](#inspiration)
+- [Code generation](#code-generation)
+- [Endpoints](#endpoints)
+- [Spec](#spec)
+  - [Node related](#node-related)
+  - [Transaction related](#transaction-related)
+    - [Payload:](#payload)
+    - [Return:](#return)
+    - [What's next?](#whats-next)
+- [Code Organization](#code-organization)
+
+## Inspiration
+
+Pocket V0 has inspired a lot the first iteration but then we converged towards a spec-centric approach, where the boilerplate code (serialization, routing, etc) is derived from an [OpenAPI 3.0](../v1/openapi.yaml) specification.
+
+This approach will allow us to focus on the features and less on the boilerpate and ultimately to iterate more quickly as we discover the way ahead of us.
+
+## Code generation
+
+The current implementation uses code generation for ease of development.
+
+The source of truth is the the [OpenAPI3.0 yaml file](../v1/openapi.yaml).
+
+Anytime we make changes to the yaml file, we need to regenerate the boilerplate code by running
+
+```bash
+$ make generate_rpc_openapi
+```
+
+The compilation errors should guide towards the next steps.
+
+## Endpoints
+
+Currently, the API is in its simplest form. Basically a **REST API**.
+
+As the codebase matures, we'll consider other transports such as [**JSON RPC 2.0**](https://www.jsonrpc.org/specification) and [**GRPC**](https://grpc.io/).
+
+## Spec
+
+The Swagger Editor with preview is available [here](https://editor.swagger.io/?url=https://raw.githubusercontent.com/pokt-network/pocket/main/rpc/v1/openapi.yaml).
+
+Alternatively, you can run:
+
+```bash
+make swagger_ui
+```
+
+and browse/test it locally.
+
+This first iteration includes the bare minimum:
+
+### Node related
+
+- Node liveness check (**GET /v1/health**)
+- Node version check (**GET /v1/version**)
+
+These are pretty self-explanatory.
+
+### Transaction related
+
+- Sync signed transaction submission (**POST /v1/client/broadcast_tx_sync**)
+
+#### Payload:
+
+```json
+{
+  "address": "string",
+  "raw_hex_bytes": "string"
+}
+```
+
+- `address`: specifies the address the transaction originates from.
+- `raw_hex_bytes`: hex encoded raw protobuf bytes of a signed transaction.
+
+#### Return:
+
+Currently only **OK** (HTTP Status code 200) or **KO** (HTTP Status code 4xx/5xx)
+
+This API might be extended to return potentially useful information such as the transaction hash which is known at the moment of submission and can be used to query the blockchain.
+
+#### What's next?
+
+Definitely we'll need ways to retrieve transactions as well so we can envisage:
+
+- Get a transaction by hash (**GET /v1/query/tx **)
+
+## Code Organization
+
+```bash
+├── client.gen.config.yml    # code generation config for the client
+├── client.gen.go            # generated client boilerplate code
+├── doc                      # folder containing RPC specific docs
+├── handlers.go              # concrete implementation of the HTTP handlers invoked by the server
+├── module.go                # RPC module
+├── noop_module.go           # noop RPC module (used when the module is disabled)
+├── server.gen.config.yml    # code generation config for the server + dtos
+├── server.gen.go            # generated server boilerplate code
+├── server.go                # RPC server configuration and initialization
+├── types
+│   ├── proto
+│   │   └── rpc_config.proto # protobuf file describing the RPC module configuration
+│   └── rpc_config.pb.go     # protoc generated struct and methods for RPC config
+└── v1
+    └── openapi.yaml         # OpenAPI v3.0 spec (source for the generated files above)
+```
diff --git a/rpc/handlers.go b/rpc/handlers.go
new file mode 100644
index 000000000..6bf16380e
--- /dev/null
+++ b/rpc/handlers.go
@@ -0,0 +1,49 @@
+package rpc
+
+import (
+	"encoding/hex"
+	"log"
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+	"github.com/pokt-network/pocket/app"
+)
+
+func (s *rpcServer) GetV1Health(ctx echo.Context) error {
+	return ctx.NoContent(http.StatusOK)
+}
+
+func (s *rpcServer) GetV1Version(ctx echo.Context) error {
+	return ctx.String(http.StatusOK, app.AppVersion)
+}
+
+func (s *rpcServer) PostV1ClientBroadcastTxSync(ctx echo.Context) error {
+	params := new(RawTXRequest)
+	if err := ctx.Bind(params); err != nil {
+		return ctx.String(http.StatusBadRequest, "bad request")
+	}
+	bz, err := hex.DecodeString(params.RawHexBytes)
+	if err != nil {
+		return ctx.String(http.StatusBadRequest, "cannot decode tx bytes")
+	}
+	height := s.GetBus().GetConsensusModule().CurrentHeight()
+	uCtx, err := s.GetBus().GetUtilityModule().NewContext(int64(height))
+	if err != nil {
+		defer func() { log.Fatalf("[ERROR] Failed to create UtilityContext: %v", err) }()
+		return ctx.String(http.StatusInternalServerError, err.Error())
+	}
+	err = uCtx.CheckTransaction(bz)
+	if err != nil {
+		return ctx.String(http.StatusInternalServerError, err.Error())
+	}
+	return nil
+}
+
+func (s *rpcServer) GetV1ConsensusRoundState(ctx echo.Context) error {
+	consensus := s.GetBus().GetConsensusModule()
+	return ctx.JSON(200, RoundState{
+		Height: int64(consensus.CurrentHeight()),
+		Round:  int64(consensus.CurrentRound()),
+		Step:   int64(consensus.CurrentStep()),
+	})
+}
diff --git a/rpc/module.go b/rpc/module.go
new file mode 100644
index 000000000..42204dced
--- /dev/null
+++ b/rpc/module.go
@@ -0,0 +1,74 @@
+package rpc
+
+import (
+	"fmt"
+	"log"
+
+	// importing because used by code-generated files that are git ignored and to allow go mod tidy and go mod vendor to function properly
+	_ "github.com/getkin/kin-openapi/openapi3"
+	_ "github.com/labstack/echo/v4"
+
+	"github.com/pokt-network/pocket/shared/modules"
+)
+
+var (
+	_ modules.RPCModule = &rpcModule{}
+)
+
+type rpcModule struct {
+	bus    modules.Bus
+	config modules.RPCConfig
+}
+
+const (
+	rpcModuleName = "rpc"
+)
+
+func Create(runtime modules.RuntimeMgr) (modules.Module, error) {
+	return new(rpcModule).Create(runtime)
+}
+
+func (m *rpcModule) Create(runtime modules.RuntimeMgr) (modules.Module, error) {
+	cfg := runtime.GetConfig()
+	if err := m.ValidateConfig(cfg); err != nil {
+		return nil, fmt.Errorf("config validation failed: %w", err)
+	}
+	rpcCfg := cfg.GetRPCConfig()
+
+	if !rpcCfg.GetEnabled() {
+		return &noopRpcModule{}, nil
+	}
+
+	return &rpcModule{
+		config: rpcCfg,
+	}, nil
+}
+
+func (u *rpcModule) Start() error {
+	go NewRPCServer(u.GetBus()).StartRPC(u.config.GetPort(), u.config.GetTimeout())
+	return nil
+}
+
+func (u *rpcModule) Stop() error {
+	return nil
+}
+
+func (u *rpcModule) GetModuleName() string {
+	return rpcModuleName
+}
+
+func (u *rpcModule) SetBus(bus modules.Bus) {
+	u.bus = bus
+}
+
+func (u *rpcModule) GetBus() modules.Bus {
+	if u.bus == nil {
+		log.Fatalf("Bus is not initialized")
+	}
+	return u.bus
+}
+
+func (*rpcModule) ValidateConfig(cfg modules.Config) error {
+	// TODO (#334): implement this
+	return nil
+}
diff --git a/rpc/noop_module.go b/rpc/noop_module.go
new file mode 100644
index 000000000..444684a9e
--- /dev/null
+++ b/rpc/noop_module.go
@@ -0,0 +1,40 @@
+package rpc
+
+import (
+	"log"
+
+	"github.com/pokt-network/pocket/shared/modules"
+)
+
+var (
+	_ modules.RPCModule = &noopRpcModule{}
+)
+
+type noopRpcModule struct{}
+
+func (m *noopRpcModule) GetModuleName() string {
+	return "noop_rpc_module"
+}
+
+func (m *noopRpcModule) Create(runtime modules.RuntimeMgr) (modules.Module, error) {
+	return &rpcModule{}, nil
+}
+
+func (m *noopRpcModule) SetBus(_ modules.Bus) {}
+
+func (m *noopRpcModule) GetBus() modules.Bus {
+	return nil
+}
+
+func (m *noopRpcModule) Start() error {
+	log.Println("[WARN] RPC server: OFFLINE")
+	return nil
+}
+
+func (m *noopRpcModule) Stop() error {
+	return nil
+}
+
+func (m *noopRpcModule) ValidateConfig(_ modules.Config) error {
+	return nil
+}
diff --git a/rpc/server.go b/rpc/server.go
new file mode 100644
index 000000000..90e69a617
--- /dev/null
+++ b/rpc/server.go
@@ -0,0 +1,52 @@
+package rpc
+
+import (
+	"log"
+	"net/http"
+	"time"
+
+	"github.com/labstack/echo/v4"
+	"github.com/labstack/echo/v4/middleware"
+	"github.com/pokt-network/pocket/runtime/defaults"
+	"github.com/pokt-network/pocket/shared/modules"
+)
+
+type rpcServer struct {
+	bus modules.Bus
+}
+
+var _ ServerInterface = &rpcServer{}
+var _ modules.IntegratableModule = &rpcServer{}
+
+func NewRPCServer(bus modules.Bus) *rpcServer {
+	s := &rpcServer{}
+	s.SetBus(bus)
+	return s
+}
+
+func (s *rpcServer) StartRPC(port string, timeout uint64) {
+	log.Printf("Starting RPC on port %s...\n", port)
+
+	e := echo.New()
+	e.Use(
+		middleware.Logger(),
+		middleware.TimeoutWithConfig(middleware.TimeoutConfig{
+			Skipper:      middleware.DefaultSkipper,
+			ErrorMessage: "Request timed out",
+			Timeout:      time.Duration(defaults.DefaultRpcTimeout) * time.Millisecond,
+		}),
+	)
+	RegisterHandlers(e, s)
+
+	if err := e.Start(":" + port); err != http.ErrServerClosed {
+		log.Fatal(err)
+	}
+}
+
+func (s *rpcServer) SetBus(bus modules.Bus) {
+	s.bus = bus
+}
+
+func (s *rpcServer) GetBus() modules.Bus {
+	return s.bus
+}
diff --git a/rpc/types/proto/rpc_config.proto b/rpc/types/proto/rpc_config.proto
new file mode 100644
index 000000000..4d95b3e86
--- /dev/null
+++ b/rpc/types/proto/rpc_config.proto
@@ -0,0 +1,11 @@
+syntax = "proto3";
+
+package rpc;
+
+option go_package = "github.com/pokt-network/pocket/rpc/types";
+
+message RPCConfig {
+  bool enabled = 1;
+  string port = 2;
+  uint64 timeout = 3;
+}
diff --git a/rpc/v1/openapi.yaml b/rpc/v1/openapi.yaml
index 5333ff244..a8bce9d31 100644
--- a/rpc/v1/openapi.yaml
+++ b/rpc/v1/openapi.yaml
@@ -3,7 +3,7 @@ servers:
   - url: 'http://localhost:50832'
 info:
   description: >-
-    This is the API definition Pocket Network core RPC call.
+    This is the API definition Pocket Network Node RPC interface.
 
 
     Pocket is a distributed network that relays data requests and responses to and from any blockchain system.
@@ -75,9 +75,9 @@ paths:
     post:
       tags:
         - client
-      summary: Relays a raw transaction
+      summary: Broadcast raw transaction bytes
       requestBody:
-        description: Raw transaction to be relayed
+        description: Raw transaction to be broadcasted
         required: true
         content:
           application/json:
@@ -120,10 +120,13 @@ components:
         properties:
           height:
             type: integer
+            format: int64
           round:
             type: integer
+            format: int64
           step:
             type: integer
+            format: int64
   requestBodies: {}
   securitySchemes: {}
   links: {}
diff --git a/runtime/config.go b/runtime/config.go
index 5cddd4057..70c8bc148 100644
--- a/runtime/config.go
+++ b/runtime/config.go
@@ -4,6 +4,7 @@ import (
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 	typesP2P "github.com/pokt-network/pocket/p2p/types"
 	typesPers "github.com/pokt-network/pocket/persistence/types"
+	typesRPC "github.com/pokt-network/pocket/rpc/types"
 	"github.com/pokt-network/pocket/shared/modules"
 	typesTelemetry "github.com/pokt-network/pocket/telemetry"
 	typesUtil "github.com/pokt-network/pocket/utility/types"
@@ -18,6 +19,7 @@ type runtimeConfig struct {
 	Persistence *typesPers.PersistenceConfig    `json:"persistence"`
 	P2P         *typesP2P.P2PConfig             `json:"p2p"`
 	Telemetry   *typesTelemetry.TelemetryConfig `json:"telemetry"`
+	RPC         *typesRPC.RPCConfig             `json:"rpc"`
 }
 
 func NewConfig(base *BaseConfig, otherConfigs ...func(modules.Config)) *runtimeConfig {
@@ -62,18 +64,27 @@ func WithTelemetryConfig(telemetryConfig modules.TelemetryConfig) func(modules.C
 func (c *runtimeConfig) GetBaseConfig() modules.BaseConfig {
 	return c.Base
 }
+
 func (c *runtimeConfig) GetConsensusConfig() modules.ConsensusConfig {
 	return c.Consensus
 }
+
 func (c *runtimeConfig) GetUtilityConfig() modules.UtilityConfig {
 	return c.Utility
 }
+
 func (c *runtimeConfig) GetPersistenceConfig() modules.PersistenceConfig {
 	return c.Persistence
 }
+
 func (c *runtimeConfig) GetP2PConfig() modules.P2PConfig {
 	return c.P2P
 }
+
 func (c *runtimeConfig) GetTelemetryConfig() modules.TelemetryConfig {
 	return c.Telemetry
 }
+
+func (c *runtimeConfig) GetRPCConfig() modules.RPCConfig {
+	return c.RPC
+}
diff --git a/runtime/docs/README.md b/runtime/docs/README.md
index cc6cac0cc..4b5b8ecb2 100644
--- a/runtime/docs/README.md
+++ b/runtime/docs/README.md
@@ -23,6 +23,16 @@ This module includes the following components:
 
   It also has a `Base` configuration that is supposed to contain more cross-functional settings that cannot really find place in module-specific "subconfigs" (as another way to define module-specific configurations).
 
+  Configuration can be supplied via JSON file but also via environment variables ([12 factor app](12factor.net)).
+
+  The naming convention is as follow:
+
+  `POCKET_[module][configuration key]`
+
+  So, for example, if you want to override the default RPC port we would use:
+
+  > POCKET_RPC_PORT=yourport
+
 - **Genesis**
 
   The genesis represents the initial state of the blockchain.
diff --git a/shared/bus.go b/shared/bus.go
index 7a85e4c75..0a6a5dfd2 100644
--- a/shared/bus.go
+++ b/shared/bus.go
@@ -21,6 +21,7 @@ type bus struct {
 	utility     modules.UtilityModule
 	consensus   modules.ConsensusModule
 	telemetry   modules.TelemetryModule
+	rpc         modules.RPCModule
 
 	runtimeMgr modules.RuntimeMgr
 }
@@ -36,6 +37,7 @@ func CreateBus(
 	utility modules.UtilityModule,
 	consensus modules.ConsensusModule,
 	telemetry modules.TelemetryModule,
+	rpc modules.RPCModule,
 ) (modules.Bus, error) {
 	bus := &bus{
 		channel: make(modules.EventsChannel, DefaultPocketBusBufferSize),
@@ -47,6 +49,7 @@ func CreateBus(
 		utility:     utility,
 		consensus:   consensus,
 		telemetry:   telemetry,
+		rpc:         rpc,
 	}
 
 	modules := map[string]modules.Module{
@@ -55,6 +58,7 @@ func CreateBus(
 		"p2p":         p2p,
 		"utility":     utility,
 		"telemetry":   telemetry,
+		"rpc":         rpc,
 	}
 
 	// checks if modules are not nil and sets their bus to this bus instance.
@@ -86,6 +90,7 @@ func CreateBusWithOptionalModules(
 	utility modules.UtilityModule,
 	consensus modules.ConsensusModule,
 	telemetry modules.TelemetryModule,
+	rpc modules.RPCModule,
 ) modules.Bus {
 	bus := &bus{
 		channel: make(modules.EventsChannel, DefaultPocketBusBufferSize),
@@ -97,6 +102,7 @@ func CreateBusWithOptionalModules(
 		utility:     utility,
 		consensus:   consensus,
 		telemetry:   telemetry,
+		rpc:         rpc,
 	}
 
 	maybeSetModuleBus := func(mod modules.Module) {
@@ -110,6 +116,7 @@ func CreateBusWithOptionalModules(
 	maybeSetModuleBus(utility)
 	maybeSetModuleBus(consensus)
 	maybeSetModuleBus(telemetry)
+	maybeSetModuleBus(rpc)
 
 	return bus
 }
@@ -147,6 +154,10 @@ func (m bus) GetTelemetryModule() modules.TelemetryModule {
 	return m.telemetry
 }
 
+func (m bus) GetRPCModule() modules.RPCModule {
+	return m.rpc
+}
+
 func (m *bus) GetRuntimeMgr() modules.RuntimeMgr {
 	return m.runtimeMgr
 }
diff --git a/shared/modules/bus_module.go b/shared/modules/bus_module.go
index 05140e0ed..1e60ab121 100644
--- a/shared/modules/bus_module.go
+++ b/shared/modules/bus_module.go
@@ -23,6 +23,7 @@ type Bus interface {
 	GetUtilityModule() UtilityModule
 	GetConsensusModule() ConsensusModule
 	GetTelemetryModule() TelemetryModule
+	GetRPCModule() RPCModule
 
 	// Runtime
 	GetRuntimeMgr() RuntimeMgr
diff --git a/shared/modules/consensus_module.go b/shared/modules/consensus_module.go
index 4d598bb49..c4d458829 100644
--- a/shared/modules/consensus_module.go
+++ b/shared/modules/consensus_module.go
@@ -25,5 +25,7 @@ type ConsensusModule interface {
 
 	// Consensus State Accessors
 	CurrentHeight() uint64
+	CurrentRound() uint64
+	CurrentStep() uint64
 	ValidatorMap() ValidatorMap
 }
diff --git a/shared/modules/rpc_module.go b/shared/modules/rpc_module.go
new file mode 100644
index 000000000..54bf62bb1
--- /dev/null
+++ b/shared/modules/rpc_module.go
@@ -0,0 +1,8 @@
+package modules
+
+//go:generate mockgen -source=$GOFILE -destination=./mocks/rpc_module_mock.go -aux_files=github.com/pokt-network/pocket/shared/modules=module.go
+
+type RPCModule interface {
+	Module
+	ConfigurableModule
+}
diff --git a/shared/modules/types.go b/shared/modules/types.go
index c07345dd5..c6e2738b4 100644
--- a/shared/modules/types.go
+++ b/shared/modules/types.go
@@ -21,6 +21,7 @@ type Config interface {
 	GetPersistenceConfig() PersistenceConfig
 	GetP2PConfig() P2PConfig
 	GetTelemetryConfig() TelemetryConfig
+	GetRPCConfig() RPCConfig
 }
 
 type BaseConfig interface {
diff --git a/shared/node.go b/shared/node.go
index 026a2c9f8..ea28e5112 100644
--- a/shared/node.go
+++ b/shared/node.go
@@ -3,11 +3,10 @@ package shared
 import (
 	"log"
 
-	"github.com/benbjohnson/clock"
 	"github.com/pokt-network/pocket/consensus"
 	"github.com/pokt-network/pocket/p2p"
 	"github.com/pokt-network/pocket/persistence"
-	"github.com/pokt-network/pocket/runtime"
+	"github.com/pokt-network/pocket/rpc"
 	cryptoPocket "github.com/pokt-network/pocket/shared/crypto"
 	"github.com/pokt-network/pocket/shared/debug"
 	"github.com/pokt-network/pocket/shared/modules"
@@ -18,7 +17,7 @@ import (
 )
 
 const (
-	MainModuleName = "main"
+	mainModuleName = "main"
 )
 
 type Node struct {
@@ -30,8 +29,8 @@ func NewNodeWithP2PAddress(address cryptoPocket.Address) *Node {
 	return &Node{p2pAddress: address}
 }
 
-func Create(configPath, genesisPath string, clock clock.Clock) (modules.Module, error) {
-	return new(Node).Create(runtime.NewManagerFromFiles(configPath, genesisPath))
+func CreateNode(runtime modules.RuntimeMgr) (modules.Module, error) {
+	return new(Node).Create(runtime)
 }
 
 func (m *Node) Create(runtimeMgr modules.RuntimeMgr) (modules.Module, error) {
@@ -60,6 +59,11 @@ func (m *Node) Create(runtimeMgr modules.RuntimeMgr) (modules.Module, error) {
 		return nil, err
 	}
 
+	rpcMod, err := rpc.Create(runtimeMgr)
+	if err != nil {
+		return nil, err
+	}
+
 	bus, err := CreateBus(
 		runtimeMgr,
 		persistenceMod.(modules.PersistenceModule),
@@ -67,6 +71,7 @@ func (m *Node) Create(runtimeMgr modules.RuntimeMgr) (modules.Module, error) {
 		utilityMod.(modules.UtilityModule),
 		consensusMod.(modules.ConsensusModule),
 		telemetryMod.(modules.TelemetryModule),
+		rpcMod.(modules.RPCModule),
 	)
 	if err != nil {
 		return nil, err
@@ -106,6 +111,10 @@ func (node *Node) Start() error {
 		return err
 	}
 
+	if err := node.GetBus().GetRPCModule().Start(); err != nil {
+		return err
+	}
+
 	// The first event signaling that the node has started
 	signalNodeStartedEvent := &debug.PocketEvent{Topic: debug.PocketTopic_POCKET_NODE_TOPIC, Data: nil}
 	node.GetBus().PublishEventToBus(signalNodeStartedEvent)
@@ -176,7 +185,7 @@ func (node *Node) handleDebugEvent(anyMessage *anypb.Any) error {
 }
 
 func (node *Node) GetModuleName() string {
-	return MainModuleName
+	return mainModuleName
 }
 
 func (node *Node) GetP2PAddress() cryptoPocket.Address {
diff --git a/telemetry/module.go b/telemetry/module.go
index 50d385f37..afe331374 100644
--- a/telemetry/module.go
+++ b/telemetry/module.go
@@ -10,7 +10,7 @@ var (
 )
 
 const (
-	TelemetryModuleName = "telemetry"
+	telemetryModuleName = "telemetry"
 )
 
 func Create(runtime modules.RuntimeMgr) (modules.Module, error) {
@@ -32,7 +32,7 @@ func (*telemetryModule) Create(runtime modules.RuntimeMgr) (modules.Module, erro
 
 type telemetryModule struct{}
 
-func (t *telemetryModule) GetModuleName() string                                          { return TelemetryModuleName }
+func (t *telemetryModule) GetModuleName() string                                          { return telemetryModuleName }
 func (t *telemetryModule) InitGenesis(_ string) (genesis modules.GenesisState, err error) { return }
 func (t *telemetryModule) SetBus(bus modules.Bus)                                         {}
 func (t *telemetryModule) GetBus() modules.Bus                                            { return nil }
diff --git a/telemetry/noop_module.go b/telemetry/noop_module.go
index 1866e86a3..4dee405f0 100644
--- a/telemetry/noop_module.go
+++ b/telemetry/noop_module.go
@@ -18,7 +18,7 @@ type NoopTelemetryModule struct {
 }
 
 const (
-	NoOpModuleName = "noOP"
+	noOpModuleName = "noOP"
 )
 
 func NOOP() {
@@ -45,7 +45,7 @@ func (m *NoopTelemetryModule) Stop() error {
 }
 
 func (m *NoopTelemetryModule) GetModuleName() string {
-	return NoOpModuleName
+	return noOpModuleName
 }
 
 func (m *NoopTelemetryModule) SetBus(bus modules.Bus) {
diff --git a/telemetry/prometheus_module.go b/telemetry/prometheus_module.go
index c81b3b70e..0adcb4483 100644
--- a/telemetry/prometheus_module.go
+++ b/telemetry/prometheus_module.go
@@ -31,7 +31,7 @@ type PrometheusTelemetryModule struct {
 }
 
 const (
-	PrometheusModuleName = "prometheus"
+	prometheusModuleName = "prometheus"
 )
 
 func CreatePrometheusTelemetryModule(runtime modules.RuntimeMgr) (modules.Module, error) {
@@ -74,7 +74,7 @@ func (m *PrometheusTelemetryModule) SetBus(bus modules.Bus) {
 }
 
 func (m *PrometheusTelemetryModule) GetModuleName() string {
-	return PrometheusModuleName
+	return prometheusModuleName
 }
 
 func (m *PrometheusTelemetryModule) GetBus() modules.Bus {
@@ -85,6 +85,7 @@ func (m *PrometheusTelemetryModule) GetBus() modules.Bus {
 }
 
 func (*PrometheusTelemetryModule) ValidateConfig(cfg modules.Config) error {
+	// TODO (#334): implement this
 	return nil
 }
 
diff --git a/utility/module.go b/utility/module.go
index 1e2fd619f..e5b784d9e 100644
--- a/utility/module.go
+++ b/utility/module.go
@@ -21,7 +21,7 @@ type utilityModule struct {
 }
 
 const (
-	UtilityModuleName = "utility"
+	utilityModuleName = "utility"
 )
 
 func Create(runtime modules.RuntimeMgr) (modules.Module, error) {
@@ -52,7 +52,7 @@ func (u *utilityModule) Stop() error {
 }
 
 func (u *utilityModule) GetModuleName() string {
-	return UtilityModuleName
+	return utilityModuleName
 }
 
 func (u *utilityModule) SetBus(bus modules.Bus) {
@@ -67,5 +67,6 @@ func (u *utilityModule) GetBus() modules.Bus {
 }
 
 func (*utilityModule) ValidateConfig(cfg modules.Config) error {
+	// TODO (#334): implement this
 	return nil
 }

From 14c2ae367ae1cf029bd3bd1008e2f692fcb72324 Mon Sep 17 00:00:00 2001
From: Alessandro De Blasis <alex@deblasis.net>
Date: Fri, 11 Nov 2022 15:58:36 +0000
Subject: [PATCH 171/227] [Utility] Local Proof of Stake CLI - Issue #112
 (#169)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Description
This PR aims at introducing CLI commands relative to the Utility module:

- Send
- Stake
- EditStake
- Unstake
- Unpause
- ChangeParameter

Consequently, it introduces an RPC server (HTTP) and the ability to "point" the CLI at specific nodes via flags

Fixes [issue/112](https://github.com/pokt-network/pocket/issues/112)

## Type of change
Please mark the options that are relevant.

- [x] New feature (non-breaking change which adds functionality)

## How Has This Been Tested?

- [x] `make test_all`
- [x] [LocalNet](https://github.com/pokt-network/pocket/blob/main/docs/development/README.md)

## Checklist
- [x] I have performed a self-review of my own code
- [x] I have commented my code, particularly in hard-to-understand areas
- [x] I have tested my changes using the available tooling
- [x] If applicable, I have made corresponding changes to related or global README
- [x] If applicable, I have added added new diagrams using [mermaid.js](https://mermaid-js.github.io)
- [x] If applicable, I have added tests that prove my fix is effective or that my feature works

* fix(config.proto): updated timeout type

* feat(RPC): basic RPC server with naive sync TX broadcast

* fix(RPC): fixed HTTP method for Health and Version routes

* chore(go.mod): tidy

* style(RPC): format

* chore(go.mod): tidy + vendor

* feat(Utility): CLI RPC client function

* feat(Utility): RPC defaults const

* feat(Utility): GetSignBytes

* feat(Utility): CLI utils

* feat(Utility): stake cmd scaffolding

* refactor(Utility): RPC server RoutesMap for CLI/client use

* refactor(Utility): RPC server exporting RouteKey and RoutesMap

for CLI/client use

* feat(Utility): CLI

calling updated QueryRPC to point at route from map

* refactor(Utility): RPC server exporting RouteKey and RoutesMap

for CLI/client use

* chore(Utility): Removed TODO

* fix(Utility): CLI: making use of the pwd flag

* fix(Utility): CLI: code review feedback

* fix(Utility): CLI custodial stake command: OutputAddr = fromAddr

* refactor(Utility): CLI: refactor command bindings

Also added missing functionality in commands other than Stake

* fix(Utility): Fix route after merge

* refactor(Utility): CLI: named return values fix

* test(Utility): CLI: simplified tests for PK parsing from file

* feat(Utility): RPC OpenApi spec and code generation

* refactor(Utility): RPC server refactoring using code generation

RPC server refactoring with code generation from openapi spec

* feat(Utility): RPC OpenApi spec and code generation

* feat(Utility): Updated RPC spec

* feat(Utility): Regenerated RPC boilerplate and updates

* docs(Utility): RPC and node docs barebones + RPC spec notes

* feat(Utility): Updated RPC spec

* docs(Utility): CLI docs barebones

* fix(Utility): CLI: added missing message handling for account

* fix(Shared): fixed RPC config

* feat(Utility): CLI updated to use the generated RPC client

* chore(go.mod): tidy

* refactor(Utility): CLI + RPC models in server.gen.go

* style(Utility): removed redundant struct definition

* docs(README.md): fixed LICENSE reference

* docs(README.md): updated with references to CLI, RPC and Node docs

* refactor(Shared): RPC config defaults -changing soon,I'm centralizin

* refactor(Shared): RPC config defaults -changing soon,I'm centralizin

Signed-off-by: Alessandro De Blasis <alex@deblasis.net>

* fix(Utility): RPC: updated to use test_artifacts defaults

* refactor(Shared): RPC config defaults -changing soon,I'm centralizin

* feat(Utility): CLI: updated to use test_artifacts default

* docs(Utility): RPC and node basic docs

* docs(Utility): CLI: Changelog

* fix(Utility): CLI: fixed output to user. It shouldn't be logging

* fix(Utility): CLI code review feedback

* style(Utility): code review feedback

* feat(Tooling): Updated makefile commands to better handle codegen

* feat(Tooling): Updated makefile commands to better handle codegen

Signed-off-by: Alessandro De Blasis <alex@deblasis.net>

* fix(Utility): Fix duplicated models

* chore(Utility): fixed versioning schema

* feat(Utility): CLI documentation generator + first stab at docs

* fix(Utility): CLI specific fixes

* fix(Utility): types fixes

* fix(Utility): RPC configs post-merge

* feat(Consensus): configOptions

* feat(P2P): configOptions

* feat(Utility): CLI: using configOptions to inject PK

* fix(Utility): RPC configs post-merge

* feat(Consensus): configOptions

* feat(P2P): configOptions

* fix(Utility): RPC fix post merge

* fix(Utility): RPC disabled by default because of TECHDEBT

* chore(go.mod): tidy

* fix(go.mod): tidy

* fix(CLI): test_artifacts

* fix(go.mod): tidy

* fix(CLI): updated to use new typesUtil.ActorType

* fix(CLI): runtime based init

* fix(test_artifacts): fix

* fix(CLI): runtime using WithRandomPK()

* fix(CLI): fixed client-only initialization

* fix(Makefile): protogen first

* feat(Utility): GetActorName function (can we autogenerate these?)

* fix(RPC): test_artifacts in runtime

* fix(go.mod): tidy

* fix(CLI): debug commands are now feature flagged

* chore(go.mod): tidy

* chore(CLI): git rm app/pocket/rpc/client.gen.go

* chore(CLI): s/j/tx and s/prepareTx/prepareTxJson

* refactor(shared): converters

* fix(CLI): debug nits

* refactor(CLI): confirmation and credentials

* chore(CLI): removed HACK todo

* fix(Makefile): premature protoc

* fix(RPC): added imports used in codegen files

* docs(RPC): added swagger editor link

* fix(RPC): added imports used in codegen files

* feat(RPC): config proto

* feat(RPC): RPCModule and noopRpcModule

* refactor(Shared): shared.Create -> shared.CreateNode

* refactor(RPC): moved scaffolding into rpc module

* fix(RPC): removed redundant file

* fix(CLI): debug merge fix

* docs(RPC): fixed link after refactoring

* docs(RPC): updated code organization post refactoring

* Update app/client/cli/utils.go

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* fix(RPC): gitignoring generated files

* style(Persistence): reverting space change

* refactor(Defaults): runtime/defaults package

* chore(CLI): issue handle

* chore(CLI): Issue #310 links

* refactor(CLI): preallocation fix

* style(CLI): oneMillion

* style(CLI): s/RelayChainIDs/relayChainIDs

* feat(Utility): ActorType.GetName()

* chore(Utility): tracking issue #142

* chore(Utility): GetBytes -> GetCanonicalBytes

* chore(CLI): actorCmd -> accountCmd

* docs(CLI): fromAddr note (address currently sourced from pk)

* chore(Runtime): new default value from main

* refactor(CLI): moving utility functions in utils.go

* chore(CLI): NewDebug -> NewDebugCommand

* fix(RPC): gitignoring generated files

Signed-off-by: Alessandro De Blasis <alex@deblasis.net>

* refactor(Consensus): mocks with Return(nil) and not Do(...)

* docs(RPC): updated changelog versions

* fix(Makefile): generate_rpc_openapi

* fix(Makefile): fix for git clone + make develop_test

* Update rpc/v1/openapi.yaml

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* Update rpc/doc/CHANGELOG.md

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* Update rpc/noop_module.go

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* chore(Shared): added TODOes for ValidateXXX() in modules

* docs(RPC): broadcast_tx_sync summary updated

* Update rpc/doc/README.md

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* Update rpc/doc/README.md

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* Update rpc/doc/README.md

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* fix(Makefile): gitignoring generated files breaks tests fix

* docs(CLI): added todos for exactArgs

* chore(RPC): added types.go

* refactor(RPC): sourcing defaults from defaults not test_artifacts

* feat(CLI): system commands RPC🤝CLI

* feat(Consensus): CurrentRound() and CurrentStep()

* feat(RPC): /v1/consensus/round_state

* feat(RPC): /v1/consensus/round_state handler

* feat(RPC): /v1/consensus/round_state

* refactor(CLI): system command typoes copypastas

* feat(CLI): consensus commands -RoundState and individual ones

* chore(CLI): typo

* docs(CLI): short commands descriptions

* docs(Config): Adding some more color around configuration

* fix(CLI): tx message signing

* feat(CLI): reporting statuscode and body

* fix(Proto): deterministic

* refactor(CLI): prepareTxJSON -> prepareTxBytes

* docs(Docs): Adding some more color config + raw_hex_bytes

* refactor(CLI): Stake command

* fix(CLI): tx message signing

* feat(CLI): reporting statuscode and body

* Merge branch 'issue/utility_local_proof_of_stake_cli_CLI' into issue/utility_local_proof_of_stake_cli

* feat(Tooling): swagger-ui

* feat(RPC): cors feature flag

* Update utility/types/message.go

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* chore(Runtime): comment spacing

* docs(CLI): Changelog

* docs(CLI): changelog

* docs(RPC): changelog

* chore(Runtime): comment spacing

* Update runtime/docs/README.md

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* chore(Consensus): SetBus mock Do(func(modules.Bus) {}) -> Return()

* refactor(Consensus): mocks with Return(nil) and not Do(...)

Signed-off-by: Alessandro De Blasis <alex@deblasis.net>

* chore(Consensus): SetBus mock Do(func(modules.Bus) {}) -> Return()

Signed-off-by: Alessandro De Blasis <alex@deblasis.net>

* docs(Pocket): changelog

* Update app/pocket/doc/README.md

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* Update app/pocket/doc/README.md

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* docs(RPC): changelog

* docs(RPC): docs TOC

* docs(RPC): Transports -> Endpoints

* feat(Tooling): swagger-ui

Signed-off-by: Alessandro De Blasis <alex@deblasis.net>

* docs(RPC): swagger ui link to editor and ref to make cmd

* feat(rpcServer): rpcServer is now IntegratableModule

* chore(Shared): tracking TODO (implement validations) #334

* fix(RPC): merge fix

* chore(go.mod): tidy

* chore(go.mod): tidy

* feat(Tooling): added empty mock_module package for cold start

* docs(RPC): nit

* Update app/client/cli/consensus.go

Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>

* docs(CLI): better commands descriptions

* feat(CLI): boldText helper

* style(CLI): nit: real estate

* refactor(CLI): ConsensusState

* docs(CLI): updated docs

* docs(CLI): \n at the end of sentences in Stake command desc.

* docs(CLI): regenerated docs

* fix(RPC): int64 on RoundState fields

* refactor(Shared): unexporting XXModuleName

* feat(node): single source of truth for version + overridable

Signed-off-by: Alessandro De Blasis <alex@deblasis.net>
Co-authored-by: Daniel Olshansky <olshansky.daniel@gmail.com>
---
 .gitignore                                    |   3 +-
 Makefile                                      |   3 +-
 README.md                                     |   9 +-
 app/client/cli/account.go                     |   2 +-
 app/client/cli/actor.go                       |  16 ++-
 app/client/cli/consensus.go                   | 108 ++++++++++++++++++
 app/client/cli/debug.go                       |   9 +-
 app/client/cli/doc/CHANGELOG.md               |   2 +
 app/client/cli/doc/commands/client.md         |   4 +-
 app/client/cli/doc/commands/client_Account.md |   2 +-
 .../cli/doc/commands/client_Account_Send.md   |   2 +-
 .../cli/doc/commands/client_Application.md    |   4 +-
 .../commands/client_Application_EditStake.md  |   2 +-
 .../doc/commands/client_Application_Stake.md  |  19 ++-
 .../client_Application_Stake_Custodial.md     |  35 ------
 .../commands/client_Application_Unpause.md    |   2 +-
 .../commands/client_Application_Unstake.md    |   2 +-
 .../cli/doc/commands/client_Consensus.md      |  26 +++++
 .../doc/commands/client_Consensus_Height.md   |  30 +++++
 .../doc/commands/client_Consensus_Round.md    |  30 +++++
 .../doc/commands/client_Consensus_State.md    |  30 +++++
 .../cli/doc/commands/client_Consensus_Step.md |  30 +++++
 .../cli/doc/commands/client_Fisherman.md      |   4 +-
 .../commands/client_Fisherman_EditStake.md    |   2 +-
 .../doc/commands/client_Fisherman_Stake.md    |  19 ++-
 .../client_Fisherman_Stake_Custodial.md       |  35 ------
 .../doc/commands/client_Fisherman_Unpause.md  |   2 +-
 .../doc/commands/client_Fisherman_Unstake.md  |   2 +-
 .../cli/doc/commands/client_Governance.md     |   2 +-
 .../client_Governance_ChangeParameter.md      |   2 +-
 app/client/cli/doc/commands/client_Node.md    |   4 +-
 .../cli/doc/commands/client_Node_EditStake.md |   2 +-
 .../cli/doc/commands/client_Node_Stake.md     |  19 ++-
 .../commands/client_Node_Stake_Custodial.md   |  35 ------
 .../cli/doc/commands/client_Node_Unpause.md   |   2 +-
 .../cli/doc/commands/client_Node_Unstake.md   |   2 +-
 app/client/cli/doc/commands/client_System.md  |  24 ++++
 .../cli/doc/commands/client_System_Health.md  |  30 +++++
 .../cli/doc/commands/client_System_Version.md |  30 +++++
 .../cli/doc/commands/client_Validator.md      |   4 +-
 .../commands/client_Validator_EditStake.md    |   2 +-
 .../doc/commands/client_Validator_Stake.md    |  19 ++-
 .../client_Validator_Stake_Custodial.md       |  35 ------
 .../doc/commands/client_Validator_Unpause.md  |   2 +-
 .../doc/commands/client_Validator_Unstake.md  |   2 +-
 app/client/cli/gov.go                         |   2 +-
 app/client/cli/system.go                      |  79 +++++++++++++
 app/client/cli/utils.go                       |  24 +++-
 build/config/config1.json                     |   3 +-
 build/config/config2.json                     |   3 +-
 build/config/config3.json                     |   3 +-
 build/config/config4.json                     |   3 +-
 build/deployments/docker-compose.yaml         |   3 +-
 build/scripts/watch_build.sh                  |   2 +-
 go.mod                                        |   4 +-
 go.sum                                        |  10 +-
 p2p/module.go                                 |   4 +-
 p2p/raintree/network.go                       |   5 +-
 rpc/doc/CHANGELOG.md                          |   2 +-
 rpc/doc/README.md                             |   2 +-
 rpc/handlers.go                               |   4 +-
 rpc/server.go                                 |  10 +-
 rpc/types/proto/rpc_config.proto              |   1 +
 rpc/types/types.go                            |   3 +
 rpc/v1/openapi.yaml                           |   6 +-
 shared/codec/codec.go                         |   2 +-
 shared/modules/mocks/mocks.go                 |   1 +
 shared/modules/types.go                       |   1 +
 68 files changed, 601 insertions(+), 226 deletions(-)
 create mode 100644 app/client/cli/consensus.go
 delete mode 100644 app/client/cli/doc/commands/client_Application_Stake_Custodial.md
 create mode 100644 app/client/cli/doc/commands/client_Consensus.md
 create mode 100644 app/client/cli/doc/commands/client_Consensus_Height.md
 create mode 100644 app/client/cli/doc/commands/client_Consensus_Round.md
 create mode 100644 app/client/cli/doc/commands/client_Consensus_State.md
 create mode 100644 app/client/cli/doc/commands/client_Consensus_Step.md
 delete mode 100644 app/client/cli/doc/commands/client_Fisherman_Stake_Custodial.md
 delete mode 100644 app/client/cli/doc/commands/client_Node_Stake_Custodial.md
 create mode 100644 app/client/cli/doc/commands/client_System.md
 create mode 100644 app/client/cli/doc/commands/client_System_Health.md
 create mode 100644 app/client/cli/doc/commands/client_System_Version.md
 delete mode 100644 app/client/cli/doc/commands/client_Validator_Stake_Custodial.md
 create mode 100644 app/client/cli/system.go
 create mode 100644 rpc/types/types.go
 create mode 100644 shared/modules/mocks/mocks.go

diff --git a/.gitignore b/.gitignore
index f8bd5b336..21f9eb7f9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,7 +29,8 @@ prototype/vendor/
 .idea/
 
 # Generated Mocks (for testing)
-shared/modules/mocks/
+shared/modules/mocks/*
+!shared/modules/mocks/mocks.go
 p2p/types/mocks/
 
 # TODO(team): Does the `types` directory contain generated or raw type files?
diff --git a/Makefile b/Makefile
index 3ca0ac38f..6423eb566 100644
--- a/Makefile
+++ b/Makefile
@@ -87,6 +87,7 @@ go_oapi-codegen:
 		echo "Install with 'go install github.com/deepmap/oapi-codegen/cmd/oapi-codegen@v1.11.0'"; \
 	fi; \
 	}
+
 .PHONY: go_clean_deps
 ## Runs `go mod tidy` && `go mod vendor`
 go_clean_deps:
@@ -214,7 +215,7 @@ docker_loki_install: docker_check
 ## Use `mockgen` to generate mocks used for testing purposes of all the modules.
 mockgen:
 	$(eval modules_dir = "shared/modules")
-	rm -rf ${modules_dir}/mocks
+	find ${modules_dir}/mocks -maxdepth 1 -type f ! -name "mocks.go" -exec rm {} \;
 	go generate ./${modules_dir}
 	echo "Mocks generated in ${modules_dir}/mocks"
 
diff --git a/README.md b/README.md
index b0ca09e90..49f26abe3 100644
--- a/README.md
+++ b/README.md
@@ -41,6 +41,9 @@ All the links you'll need are listed below. If you'd like to contribute to the P
 - _Coming Soon: Consensus Architecture_ // TODO(olshansky): needs a README file with proper code structure
 - [Persistence Architecture](persistence/docs/README.md)
 - [P2P Architecture](p2p/README.md)
+- [CLI Architecture](app/client/cli/doc/README.md)
+- [RPC Architecture](app/pocket/rpc/doc/README.md)
+- [Node binary Architecture](app/pocket/doc/README.md)
 
 ### Changelogs
 
@@ -49,6 +52,10 @@ All the links you'll need are listed below. If you'd like to contribute to the P
 - [Consensus Changelog](consensus/CHANGELOG.md)
 - [Persistence Changelog](persistence/docs/CHANGELOG.md)
 - [P2P Changelog](p2p/CHANGELOG.md)
+- [CLI Changelog](app/client/cli/doc/CHANGELOG.md)
+- [RPC Changelog](app/pocket/rpc/doc/CHANGELOG.md)
+- [Node binary Changelog](app/pocket/doc/CHANGELOG.md)
+
 - _Coming Soon: Telemetry Changelog_
 
 ## Support & Contact
@@ -64,4 +71,4 @@ All the links you'll need are listed below. If you'd like to contribute to the P
 
 ## License
 
-This project is licensed under the MIT License; see the [LICENSE.md](LICENSE.md) file for details.
+This project is licensed under the MIT License; see the [LICENSE](LICENSE) file for details.
diff --git a/app/client/cli/account.go b/app/client/cli/account.go
index 5d63256c5..7c1c15cbc 100644
--- a/app/client/cli/account.go
+++ b/app/client/cli/account.go
@@ -54,7 +54,7 @@ func accountCommands() []*cobra.Command {
 					Amount:      amount,
 				}
 
-				tx, err := prepareTxJson(msg, pk)
+				tx, err := prepareTxBytes(msg, pk)
 				if err != nil {
 					return err
 				}
diff --git a/app/client/cli/actor.go b/app/client/cli/actor.go
index 25e147acc..6661cb532 100644
--- a/app/client/cli/actor.go
+++ b/app/client/cli/actor.go
@@ -77,9 +77,13 @@ func newStakeCmd(cmdDef actorCmdDef) *cobra.Command {
 		Use:   "Stake <fromAddr> <amount> <relayChainIDs> <serviceURI>",
 		Short: "Stake a node in the network. Custodial stake uses the same address as operator/output for rewards/return of staked funds.",
 		Long: `Stake the node into the network, making it available for service.
-Will prompt the user for the <fromAddr> account passphrase. If the node is already staked, this transaction acts as an *update* transaction.
+
+Will prompt the user for the *fromAddr* account passphrase. If the node is already staked, this transaction acts as an *update* transaction.
+
 A node can update relayChainIDs, serviceURI, and raise the stake amount with this transaction.
-If the node is currently staked at X and you submit an update with new stake Y. Only Y-X will be subtracted from an account
+
+If the node is currently staked at X and you submit an update with new stake Y. Only Y-X will be subtracted from an account.
+
 If no changes are desired for the parameter, just enter the current param value just as before.`,
 		Args: cobra.ExactArgs(4), // REFACTOR(#150): <fromAddr> not being used at the moment. Update once a keybase is implemented.
 		RunE: func(cmd *cobra.Command, args []string) error {
@@ -116,7 +120,7 @@ If no changes are desired for the parameter, just enter the current param value
 				ActorType:     cmdDef.ActorType,
 			}
 
-			tx, err := prepareTxJson(msg, pk)
+			tx, err := prepareTxBytes(msg, pk)
 			if err != nil {
 				return err
 			}
@@ -171,7 +175,7 @@ func newEditStakeCmd(cmdDef actorCmdDef) *cobra.Command {
 				ActorType:  cmdDef.ActorType,
 			}
 
-			tx, err := prepareTxJson(msg, pk)
+			tx, err := prepareTxBytes(msg, pk)
 			if err != nil {
 				return err
 			}
@@ -212,7 +216,7 @@ func newUnstakeCmd(cmdDef actorCmdDef) *cobra.Command {
 				ActorType: cmdDef.ActorType,
 			}
 
-			tx, err := prepareTxJson(msg, pk)
+			tx, err := prepareTxBytes(msg, pk)
 			if err != nil {
 				return err
 			}
@@ -253,7 +257,7 @@ func newUnpauseCmd(cmdDef actorCmdDef) *cobra.Command {
 				ActorType: cmdDef.ActorType,
 			}
 
-			tx, err := prepareTxJson(msg, pk)
+			tx, err := prepareTxBytes(msg, pk)
 			if err != nil {
 				return err
 			}
diff --git a/app/client/cli/consensus.go b/app/client/cli/consensus.go
new file mode 100644
index 000000000..e909fcd2d
--- /dev/null
+++ b/app/client/cli/consensus.go
@@ -0,0 +1,108 @@
+package cli
+
+import (
+	"fmt"
+
+	"github.com/pokt-network/pocket/rpc"
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	consensusCmd := NewConsensusCommand()
+	rootCmd.AddCommand(consensusCmd)
+}
+
+func NewConsensusCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "Consensus",
+		Short:   "Consensus specific commands",
+		Aliases: []string{"consensus"},
+		Args:    cobra.ExactArgs(0),
+	}
+
+	cmd.AddCommand(consensusCommands()...)
+
+	return cmd
+}
+
+func consensusCommands() []*cobra.Command {
+	cmds := []*cobra.Command{
+		{
+			Use:     "State",
+			Short:   "Returns \"Height/Round/Step\"",
+			Long:    "State returns the height, round and step in \"Height/Round/Step\" format",
+			Aliases: []string{"state"},
+			RunE: func(cmd *cobra.Command, args []string) error {
+				response, err := getConsensusState(cmd)
+				if err != nil {
+					return err
+				}
+
+				fmt.Printf("%d/%d/%d\n", response.JSONDefault.Height, response.JSONDefault.Round, response.JSONDefault.Step)
+
+				return nil
+			},
+		},
+		{
+			Use:     "Height",
+			Short:   "Returns the Height",
+			Long:    "Height returns the height in the node's current consensus state",
+			Aliases: []string{"height"},
+			RunE: func(cmd *cobra.Command, args []string) error {
+				response, err := getConsensusState(cmd)
+				if err != nil {
+					return err
+				}
+
+				fmt.Printf("%d\n", response.JSONDefault.Height)
+
+				return nil
+			},
+		},
+		{
+			Use:     "Round",
+			Short:   "Returns the Round",
+			Long:    "Round returns the round in the node's current consensus state",
+			Aliases: []string{"round"},
+			RunE: func(cmd *cobra.Command, args []string) error {
+				response, err := getConsensusState(cmd)
+				if err != nil {
+					return err
+				}
+
+				fmt.Printf("%d\n", response.JSONDefault.Round)
+
+				return nil
+			},
+		},
+		{
+			Use:     "Step",
+			Short:   "Returns the Step",
+			Long:    "Step returns the step in the node's current consensus state",
+			Aliases: []string{"step"},
+			RunE: func(cmd *cobra.Command, args []string) error {
+				response, err := getConsensusState(cmd)
+				if err != nil {
+					return err
+				}
+
+				fmt.Printf("%d\n", response.JSONDefault.Step)
+
+				return nil
+			},
+		},
+	}
+	return cmds
+}
+
+func getConsensusState(cmd *cobra.Command) (*rpc.GetV1ConsensusStateResponse, error) {
+	client, err := rpc.NewClientWithResponses(remoteCLIURL)
+	if err != nil {
+		return nil, nil
+	}
+	response, err := client.GetV1ConsensusStateWithResponse(cmd.Context())
+	if err != nil {
+		return nil, unableToConnectToRpc(err)
+	}
+	return response, nil
+}
diff --git a/app/client/cli/debug.go b/app/client/cli/debug.go
index 3c6026603..74d2327a8 100644
--- a/app/client/cli/debug.go
+++ b/app/client/cli/debug.go
@@ -11,6 +11,7 @@ import (
 	"github.com/manifoldco/promptui"
 	"github.com/pokt-network/pocket/consensus"
 	"github.com/pokt-network/pocket/p2p"
+	"github.com/pokt-network/pocket/rpc"
 	"github.com/pokt-network/pocket/runtime"
 	"github.com/pokt-network/pocket/shared"
 	pocketCrypto "github.com/pokt-network/pocket/shared/crypto"
@@ -203,7 +204,13 @@ func initDebug(remoteCLIURL string) {
 		}
 		telemetryMod := telemetryM.(modules.TelemetryModule)
 
-		_ = shared.CreateBusWithOptionalModules(runtimeMgr, nil, p2pMod, nil, consensusMod, telemetryMod) // TODO: refactor using the `WithXXXModule()` pattern accepting a slice of IntegratableModule
+		rpcM, err := rpc.Create(runtimeMgr)
+		if err != nil {
+			log.Fatalf("[ERROR] Failed to create rpc module: %v", err.Error())
+		}
+		rpcMod := rpcM.(modules.RPCModule)
+
+		_ = shared.CreateBusWithOptionalModules(runtimeMgr, nil, p2pMod, nil, consensusMod, telemetryMod, rpcMod) // TODO: refactor using the `WithXXXModule()` pattern accepting a slice of IntegratableModule
 
 		p2pMod.Start()
 	})
diff --git a/app/client/cli/doc/CHANGELOG.md b/app/client/cli/doc/CHANGELOG.md
index 5dcc4d29c..3f8516c53 100644
--- a/app/client/cli/doc/CHANGELOG.md
+++ b/app/client/cli/doc/CHANGELOG.md
@@ -13,6 +13,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Fixed message signing
 - Reporting RPC StatusCode and body
+- System commands working end-to-end
+- Added Consensus State commands
 
 ## [0.0.1] - 2022-09-09
 
diff --git a/app/client/cli/doc/commands/client.md b/app/client/cli/doc/commands/client.md
index 5ca0233d0..8e446cbca 100644
--- a/app/client/cli/doc/commands/client.md
+++ b/app/client/cli/doc/commands/client.md
@@ -18,9 +18,11 @@ The CLI is meant to be an user but also a machine friendly way for interacting w
 
 * [client Account](client_Account.md)	 - Account specific commands
 * [client Application](client_Application.md)	 - Application actor specific commands
+* [client Consensus](client_Consensus.md)	 - Consensus specific commands
 * [client Fisherman](client_Fisherman.md)	 - Fisherman actor specific commands
 * [client Governance](client_Governance.md)	 - Governance specific commands
 * [client Node](client_Node.md)	 - Node actor specific commands
+* [client System](client_System.md)	 - Commands related to health and troubleshooting of the node instance
 * [client Validator](client_Validator.md)	 - Validator actor specific commands
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Account.md b/app/client/cli/doc/commands/client_Account.md
index 36d9a117c..9391cf4aa 100644
--- a/app/client/cli/doc/commands/client_Account.md
+++ b/app/client/cli/doc/commands/client_Account.md
@@ -21,4 +21,4 @@ Account specific commands
 * [client](client.md)	 - Pocket Network Command Line Interface (CLI)
 * [client Account Send](client_Account_Send.md)	 - Send <fromAddr> <to> <amount>
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Account_Send.md b/app/client/cli/doc/commands/client_Account_Send.md
index f77348d16..0e2bc312f 100644
--- a/app/client/cli/doc/commands/client_Account_Send.md
+++ b/app/client/cli/doc/commands/client_Account_Send.md
@@ -27,4 +27,4 @@ client Account Send <fromAddr> <to> <amount> [flags]
 
 * [client Account](client_Account.md)	 - Account specific commands
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Application.md b/app/client/cli/doc/commands/client_Application.md
index 7860641ee..7a42ff1f0 100644
--- a/app/client/cli/doc/commands/client_Application.md
+++ b/app/client/cli/doc/commands/client_Application.md
@@ -19,8 +19,8 @@ Application actor specific commands
 
 * [client](client.md)	 - Pocket Network Command Line Interface (CLI)
 * [client Application EditStake](client_Application_EditStake.md)	 - EditStake <fromAddr> <amount> <relayChainIDs> <serviceURI>
-* [client Application Stake](client_Application_Stake.md)	 - Stake an actor (Application) in the network.
+* [client Application Stake](client_Application_Stake.md)	 - Stake a node in the network. Custodial stake uses the same address as operator/output for rewards/return of staked funds.
 * [client Application Unpause](client_Application_Unpause.md)	 - Unpause <fromAddr>
 * [client Application Unstake](client_Application_Unstake.md)	 - Unstake <fromAddr>
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Application_EditStake.md b/app/client/cli/doc/commands/client_Application_EditStake.md
index 901c2d339..16f9ff834 100644
--- a/app/client/cli/doc/commands/client_Application_EditStake.md
+++ b/app/client/cli/doc/commands/client_Application_EditStake.md
@@ -28,4 +28,4 @@ client Application EditStake <fromAddr> <amount> <relayChainIDs> <serviceURI> [f
 
 * [client Application](client_Application.md)	 - Application actor specific commands
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Application_Stake.md b/app/client/cli/doc/commands/client_Application_Stake.md
index ec3c5d55a..56b00b6e3 100644
--- a/app/client/cli/doc/commands/client_Application_Stake.md
+++ b/app/client/cli/doc/commands/client_Application_Stake.md
@@ -1,10 +1,22 @@
 ## client Application Stake
 
-Stake an actor (Application) in the network.
+Stake a node in the network. Custodial stake uses the same address as operator/output for rewards/return of staked funds.
 
 ### Synopsis
 
-Stake the Application actor into the network, making it available for service.
+Stake the node into the network, making it available for service.
+
+Will prompt the user for the *fromAddr* account passphrase. If the node is already staked, this transaction acts as an *update* transaction.
+
+A node can update relayChainIDs, serviceURI, and raise the stake amount with this transaction.
+
+If the node is currently staked at X and you submit an update with new stake Y. Only Y-X will be subtracted from an account.
+
+If no changes are desired for the parameter, just enter the current param value just as before.
+
+```
+client Application Stake <fromAddr> <amount> <relayChainIDs> <serviceURI> [flags]
+```
 
 ### Options
 
@@ -23,6 +35,5 @@ Stake the Application actor into the network, making it available for service.
 ### SEE ALSO
 
 * [client Application](client_Application.md)	 - Application actor specific commands
-* [client Application Stake Custodial](client_Application_Stake_Custodial.md)	 - Stake a node in the network. Custodial stake uses the same address as operator/output for rewards/return of staked funds.
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Application_Stake_Custodial.md b/app/client/cli/doc/commands/client_Application_Stake_Custodial.md
deleted file mode 100644
index e47b59344..000000000
--- a/app/client/cli/doc/commands/client_Application_Stake_Custodial.md
+++ /dev/null
@@ -1,35 +0,0 @@
-## client Application Stake Custodial
-
-Stake a node in the network. Custodial stake uses the same address as operator/output for rewards/return of staked funds.
-
-### Synopsis
-
-Stake the node into the network, making it available for service.
-Will prompt the user for the <fromAddr> account passphrase. If the node is already staked, this transaction acts as an *update* transaction.
-A node can update relayChainIDs, serviceURI, and raise the stake amount with this transaction.
-If the node is currently staked at X and you submit an update with new stake Y. Only Y-X will be subtracted from an account
-If no changes are desired for the parameter, just enter the current param value just as before.
-
-```
-client Application Stake Custodial <fromAddr> <amount> <relayChainIDs> <serviceURI> [flags]
-```
-
-### Options
-
-```
-  -h, --help         help for Custodial
-      --pwd string   passphrase used by the cmd, non empty usage bypass interactive prompt
-```
-
-### Options inherited from parent commands
-
-```
-      --path_to_private_key_file string   Path to private key to use when signing (default "./pk.json")
-      --remote_cli_url string             takes a remote endpoint in the form of <protocol>://<host> (uses RPC Port) (default "http://localhost:50832")
-```
-
-### SEE ALSO
-
-* [client Application Stake](client_Application_Stake.md)	 - Stake an actor (Application) in the network.
-
-###### Auto generated by spf13/cobra on 19-Oct-2022
diff --git a/app/client/cli/doc/commands/client_Application_Unpause.md b/app/client/cli/doc/commands/client_Application_Unpause.md
index 3e6adc4af..0fb2aad9c 100644
--- a/app/client/cli/doc/commands/client_Application_Unpause.md
+++ b/app/client/cli/doc/commands/client_Application_Unpause.md
@@ -28,4 +28,4 @@ client Application Unpause <fromAddr> [flags]
 
 * [client Application](client_Application.md)	 - Application actor specific commands
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Application_Unstake.md b/app/client/cli/doc/commands/client_Application_Unstake.md
index cb0d44aef..316e96e3e 100644
--- a/app/client/cli/doc/commands/client_Application_Unstake.md
+++ b/app/client/cli/doc/commands/client_Application_Unstake.md
@@ -28,4 +28,4 @@ client Application Unstake <fromAddr> [flags]
 
 * [client Application](client_Application.md)	 - Application actor specific commands
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Consensus.md b/app/client/cli/doc/commands/client_Consensus.md
new file mode 100644
index 000000000..08af6c184
--- /dev/null
+++ b/app/client/cli/doc/commands/client_Consensus.md
@@ -0,0 +1,26 @@
+## client Consensus
+
+Consensus specific commands
+
+### Options
+
+```
+  -h, --help   help for Consensus
+```
+
+### Options inherited from parent commands
+
+```
+      --path_to_private_key_file string   Path to private key to use when signing (default "./pk.json")
+      --remote_cli_url string             takes a remote endpoint in the form of <protocol>://<host> (uses RPC Port) (default "http://localhost:50832")
+```
+
+### SEE ALSO
+
+* [client](client.md)	 - Pocket Network Command Line Interface (CLI)
+* [client Consensus Height](client_Consensus_Height.md)	 - Returns the Height
+* [client Consensus Round](client_Consensus_Round.md)	 - Returns the Round
+* [client Consensus State](client_Consensus_State.md)	 - Returns "Height/Round/Step"
+* [client Consensus Step](client_Consensus_Step.md)	 - Returns the Step
+
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Consensus_Height.md b/app/client/cli/doc/commands/client_Consensus_Height.md
new file mode 100644
index 000000000..c9826be3c
--- /dev/null
+++ b/app/client/cli/doc/commands/client_Consensus_Height.md
@@ -0,0 +1,30 @@
+## client Consensus Height
+
+Returns the Height
+
+### Synopsis
+
+Height returns the height in the node's current consensus state
+
+```
+client Consensus Height [flags]
+```
+
+### Options
+
+```
+  -h, --help   help for Height
+```
+
+### Options inherited from parent commands
+
+```
+      --path_to_private_key_file string   Path to private key to use when signing (default "./pk.json")
+      --remote_cli_url string             takes a remote endpoint in the form of <protocol>://<host> (uses RPC Port) (default "http://localhost:50832")
+```
+
+### SEE ALSO
+
+* [client Consensus](client_Consensus.md)	 - Consensus specific commands
+
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Consensus_Round.md b/app/client/cli/doc/commands/client_Consensus_Round.md
new file mode 100644
index 000000000..ae7771c18
--- /dev/null
+++ b/app/client/cli/doc/commands/client_Consensus_Round.md
@@ -0,0 +1,30 @@
+## client Consensus Round
+
+Returns the Round
+
+### Synopsis
+
+Round returns the round in the node's current consensus state
+
+```
+client Consensus Round [flags]
+```
+
+### Options
+
+```
+  -h, --help   help for Round
+```
+
+### Options inherited from parent commands
+
+```
+      --path_to_private_key_file string   Path to private key to use when signing (default "./pk.json")
+      --remote_cli_url string             takes a remote endpoint in the form of <protocol>://<host> (uses RPC Port) (default "http://localhost:50832")
+```
+
+### SEE ALSO
+
+* [client Consensus](client_Consensus.md)	 - Consensus specific commands
+
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Consensus_State.md b/app/client/cli/doc/commands/client_Consensus_State.md
new file mode 100644
index 000000000..af2817529
--- /dev/null
+++ b/app/client/cli/doc/commands/client_Consensus_State.md
@@ -0,0 +1,30 @@
+## client Consensus State
+
+Returns "Height/Round/Step"
+
+### Synopsis
+
+State returns the height, round and step in "Height/Round/Step" format
+
+```
+client Consensus State [flags]
+```
+
+### Options
+
+```
+  -h, --help   help for State
+```
+
+### Options inherited from parent commands
+
+```
+      --path_to_private_key_file string   Path to private key to use when signing (default "./pk.json")
+      --remote_cli_url string             takes a remote endpoint in the form of <protocol>://<host> (uses RPC Port) (default "http://localhost:50832")
+```
+
+### SEE ALSO
+
+* [client Consensus](client_Consensus.md)	 - Consensus specific commands
+
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Consensus_Step.md b/app/client/cli/doc/commands/client_Consensus_Step.md
new file mode 100644
index 000000000..7c99b941b
--- /dev/null
+++ b/app/client/cli/doc/commands/client_Consensus_Step.md
@@ -0,0 +1,30 @@
+## client Consensus Step
+
+Returns the Step
+
+### Synopsis
+
+Step returns the step in the node's current consensus state
+
+```
+client Consensus Step [flags]
+```
+
+### Options
+
+```
+  -h, --help   help for Step
+```
+
+### Options inherited from parent commands
+
+```
+      --path_to_private_key_file string   Path to private key to use when signing (default "./pk.json")
+      --remote_cli_url string             takes a remote endpoint in the form of <protocol>://<host> (uses RPC Port) (default "http://localhost:50832")
+```
+
+### SEE ALSO
+
+* [client Consensus](client_Consensus.md)	 - Consensus specific commands
+
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Fisherman.md b/app/client/cli/doc/commands/client_Fisherman.md
index 4fe0659f1..b0f046abb 100644
--- a/app/client/cli/doc/commands/client_Fisherman.md
+++ b/app/client/cli/doc/commands/client_Fisherman.md
@@ -19,8 +19,8 @@ Fisherman actor specific commands
 
 * [client](client.md)	 - Pocket Network Command Line Interface (CLI)
 * [client Fisherman EditStake](client_Fisherman_EditStake.md)	 - EditStake <fromAddr> <amount> <relayChainIDs> <serviceURI>
-* [client Fisherman Stake](client_Fisherman_Stake.md)	 - Stake an actor (Fisherman) in the network.
+* [client Fisherman Stake](client_Fisherman_Stake.md)	 - Stake a node in the network. Custodial stake uses the same address as operator/output for rewards/return of staked funds.
 * [client Fisherman Unpause](client_Fisherman_Unpause.md)	 - Unpause <fromAddr>
 * [client Fisherman Unstake](client_Fisherman_Unstake.md)	 - Unstake <fromAddr>
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Fisherman_EditStake.md b/app/client/cli/doc/commands/client_Fisherman_EditStake.md
index d4114486b..c7cee878e 100644
--- a/app/client/cli/doc/commands/client_Fisherman_EditStake.md
+++ b/app/client/cli/doc/commands/client_Fisherman_EditStake.md
@@ -28,4 +28,4 @@ client Fisherman EditStake <fromAddr> <amount> <relayChainIDs> <serviceURI> [fla
 
 * [client Fisherman](client_Fisherman.md)	 - Fisherman actor specific commands
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Fisherman_Stake.md b/app/client/cli/doc/commands/client_Fisherman_Stake.md
index dc9a3bf6f..0b6d339aa 100644
--- a/app/client/cli/doc/commands/client_Fisherman_Stake.md
+++ b/app/client/cli/doc/commands/client_Fisherman_Stake.md
@@ -1,10 +1,22 @@
 ## client Fisherman Stake
 
-Stake an actor (Fisherman) in the network.
+Stake a node in the network. Custodial stake uses the same address as operator/output for rewards/return of staked funds.
 
 ### Synopsis
 
-Stake the Fisherman actor into the network, making it available for service.
+Stake the node into the network, making it available for service.
+
+Will prompt the user for the *fromAddr* account passphrase. If the node is already staked, this transaction acts as an *update* transaction.
+
+A node can update relayChainIDs, serviceURI, and raise the stake amount with this transaction.
+
+If the node is currently staked at X and you submit an update with new stake Y. Only Y-X will be subtracted from an account.
+
+If no changes are desired for the parameter, just enter the current param value just as before.
+
+```
+client Fisherman Stake <fromAddr> <amount> <relayChainIDs> <serviceURI> [flags]
+```
 
 ### Options
 
@@ -23,6 +35,5 @@ Stake the Fisherman actor into the network, making it available for service.
 ### SEE ALSO
 
 * [client Fisherman](client_Fisherman.md)	 - Fisherman actor specific commands
-* [client Fisherman Stake Custodial](client_Fisherman_Stake_Custodial.md)	 - Stake a node in the network. Custodial stake uses the same address as operator/output for rewards/return of staked funds.
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Fisherman_Stake_Custodial.md b/app/client/cli/doc/commands/client_Fisherman_Stake_Custodial.md
deleted file mode 100644
index b80f274da..000000000
--- a/app/client/cli/doc/commands/client_Fisherman_Stake_Custodial.md
+++ /dev/null
@@ -1,35 +0,0 @@
-## client Fisherman Stake Custodial
-
-Stake a node in the network. Custodial stake uses the same address as operator/output for rewards/return of staked funds.
-
-### Synopsis
-
-Stake the node into the network, making it available for service.
-Will prompt the user for the <fromAddr> account passphrase. If the node is already staked, this transaction acts as an *update* transaction.
-A node can update relayChainIDs, serviceURI, and raise the stake amount with this transaction.
-If the node is currently staked at X and you submit an update with new stake Y. Only Y-X will be subtracted from an account
-If no changes are desired for the parameter, just enter the current param value just as before.
-
-```
-client Fisherman Stake Custodial <fromAddr> <amount> <relayChainIDs> <serviceURI> [flags]
-```
-
-### Options
-
-```
-  -h, --help         help for Custodial
-      --pwd string   passphrase used by the cmd, non empty usage bypass interactive prompt
-```
-
-### Options inherited from parent commands
-
-```
-      --path_to_private_key_file string   Path to private key to use when signing (default "./pk.json")
-      --remote_cli_url string             takes a remote endpoint in the form of <protocol>://<host> (uses RPC Port) (default "http://localhost:50832")
-```
-
-### SEE ALSO
-
-* [client Fisherman Stake](client_Fisherman_Stake.md)	 - Stake an actor (Fisherman) in the network.
-
-###### Auto generated by spf13/cobra on 19-Oct-2022
diff --git a/app/client/cli/doc/commands/client_Fisherman_Unpause.md b/app/client/cli/doc/commands/client_Fisherman_Unpause.md
index 6f77c2b62..cd3d341c8 100644
--- a/app/client/cli/doc/commands/client_Fisherman_Unpause.md
+++ b/app/client/cli/doc/commands/client_Fisherman_Unpause.md
@@ -28,4 +28,4 @@ client Fisherman Unpause <fromAddr> [flags]
 
 * [client Fisherman](client_Fisherman.md)	 - Fisherman actor specific commands
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Fisherman_Unstake.md b/app/client/cli/doc/commands/client_Fisherman_Unstake.md
index 179e1e314..ca077a01b 100644
--- a/app/client/cli/doc/commands/client_Fisherman_Unstake.md
+++ b/app/client/cli/doc/commands/client_Fisherman_Unstake.md
@@ -28,4 +28,4 @@ client Fisherman Unstake <fromAddr> [flags]
 
 * [client Fisherman](client_Fisherman.md)	 - Fisherman actor specific commands
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Governance.md b/app/client/cli/doc/commands/client_Governance.md
index d3dce12c9..fa8396701 100644
--- a/app/client/cli/doc/commands/client_Governance.md
+++ b/app/client/cli/doc/commands/client_Governance.md
@@ -20,4 +20,4 @@ Governance specific commands
 * [client](client.md)	 - Pocket Network Command Line Interface (CLI)
 * [client Governance ChangeParameter](client_Governance_ChangeParameter.md)	 - ChangeParameter <owner> <key> <value>
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Governance_ChangeParameter.md b/app/client/cli/doc/commands/client_Governance_ChangeParameter.md
index 246cf98bd..a3fdfe398 100644
--- a/app/client/cli/doc/commands/client_Governance_ChangeParameter.md
+++ b/app/client/cli/doc/commands/client_Governance_ChangeParameter.md
@@ -27,4 +27,4 @@ client Governance ChangeParameter <owner> <key> <value> [flags]
 
 * [client Governance](client_Governance.md)	 - Governance specific commands
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Node.md b/app/client/cli/doc/commands/client_Node.md
index 17ada4ecd..d09f91b14 100644
--- a/app/client/cli/doc/commands/client_Node.md
+++ b/app/client/cli/doc/commands/client_Node.md
@@ -19,8 +19,8 @@ Node actor specific commands
 
 * [client](client.md)	 - Pocket Network Command Line Interface (CLI)
 * [client Node EditStake](client_Node_EditStake.md)	 - EditStake <fromAddr> <amount> <relayChainIDs> <serviceURI>
-* [client Node Stake](client_Node_Stake.md)	 - Stake an actor (Node) in the network.
+* [client Node Stake](client_Node_Stake.md)	 - Stake a node in the network. Custodial stake uses the same address as operator/output for rewards/return of staked funds.
 * [client Node Unpause](client_Node_Unpause.md)	 - Unpause <fromAddr>
 * [client Node Unstake](client_Node_Unstake.md)	 - Unstake <fromAddr>
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Node_EditStake.md b/app/client/cli/doc/commands/client_Node_EditStake.md
index ae023c5c0..60150b78b 100644
--- a/app/client/cli/doc/commands/client_Node_EditStake.md
+++ b/app/client/cli/doc/commands/client_Node_EditStake.md
@@ -28,4 +28,4 @@ client Node EditStake <fromAddr> <amount> <relayChainIDs> <serviceURI> [flags]
 
 * [client Node](client_Node.md)	 - Node actor specific commands
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Node_Stake.md b/app/client/cli/doc/commands/client_Node_Stake.md
index 743d15892..bc6e448c8 100644
--- a/app/client/cli/doc/commands/client_Node_Stake.md
+++ b/app/client/cli/doc/commands/client_Node_Stake.md
@@ -1,10 +1,22 @@
 ## client Node Stake
 
-Stake an actor (Node) in the network.
+Stake a node in the network. Custodial stake uses the same address as operator/output for rewards/return of staked funds.
 
 ### Synopsis
 
-Stake the Node actor into the network, making it available for service.
+Stake the node into the network, making it available for service.
+
+Will prompt the user for the *fromAddr* account passphrase. If the node is already staked, this transaction acts as an *update* transaction.
+
+A node can update relayChainIDs, serviceURI, and raise the stake amount with this transaction.
+
+If the node is currently staked at X and you submit an update with new stake Y. Only Y-X will be subtracted from an account.
+
+If no changes are desired for the parameter, just enter the current param value just as before.
+
+```
+client Node Stake <fromAddr> <amount> <relayChainIDs> <serviceURI> [flags]
+```
 
 ### Options
 
@@ -23,6 +35,5 @@ Stake the Node actor into the network, making it available for service.
 ### SEE ALSO
 
 * [client Node](client_Node.md)	 - Node actor specific commands
-* [client Node Stake Custodial](client_Node_Stake_Custodial.md)	 - Stake a node in the network. Custodial stake uses the same address as operator/output for rewards/return of staked funds.
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Node_Stake_Custodial.md b/app/client/cli/doc/commands/client_Node_Stake_Custodial.md
deleted file mode 100644
index bbb309489..000000000
--- a/app/client/cli/doc/commands/client_Node_Stake_Custodial.md
+++ /dev/null
@@ -1,35 +0,0 @@
-## client Node Stake Custodial
-
-Stake a node in the network. Custodial stake uses the same address as operator/output for rewards/return of staked funds.
-
-### Synopsis
-
-Stake the node into the network, making it available for service.
-Will prompt the user for the <fromAddr> account passphrase. If the node is already staked, this transaction acts as an *update* transaction.
-A node can update relayChainIDs, serviceURI, and raise the stake amount with this transaction.
-If the node is currently staked at X and you submit an update with new stake Y. Only Y-X will be subtracted from an account
-If no changes are desired for the parameter, just enter the current param value just as before.
-
-```
-client Node Stake Custodial <fromAddr> <amount> <relayChainIDs> <serviceURI> [flags]
-```
-
-### Options
-
-```
-  -h, --help         help for Custodial
-      --pwd string   passphrase used by the cmd, non empty usage bypass interactive prompt
-```
-
-### Options inherited from parent commands
-
-```
-      --path_to_private_key_file string   Path to private key to use when signing (default "./pk.json")
-      --remote_cli_url string             takes a remote endpoint in the form of <protocol>://<host> (uses RPC Port) (default "http://localhost:50832")
-```
-
-### SEE ALSO
-
-* [client Node Stake](client_Node_Stake.md)	 - Stake an actor (Node) in the network.
-
-###### Auto generated by spf13/cobra on 19-Oct-2022
diff --git a/app/client/cli/doc/commands/client_Node_Unpause.md b/app/client/cli/doc/commands/client_Node_Unpause.md
index 3482556c9..7f500df6a 100644
--- a/app/client/cli/doc/commands/client_Node_Unpause.md
+++ b/app/client/cli/doc/commands/client_Node_Unpause.md
@@ -28,4 +28,4 @@ client Node Unpause <fromAddr> [flags]
 
 * [client Node](client_Node.md)	 - Node actor specific commands
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Node_Unstake.md b/app/client/cli/doc/commands/client_Node_Unstake.md
index c2d458d20..82d1b14be 100644
--- a/app/client/cli/doc/commands/client_Node_Unstake.md
+++ b/app/client/cli/doc/commands/client_Node_Unstake.md
@@ -28,4 +28,4 @@ client Node Unstake <fromAddr> [flags]
 
 * [client Node](client_Node.md)	 - Node actor specific commands
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_System.md b/app/client/cli/doc/commands/client_System.md
new file mode 100644
index 000000000..05fd26896
--- /dev/null
+++ b/app/client/cli/doc/commands/client_System.md
@@ -0,0 +1,24 @@
+## client System
+
+Commands related to health and troubleshooting of the node instance
+
+### Options
+
+```
+  -h, --help   help for System
+```
+
+### Options inherited from parent commands
+
+```
+      --path_to_private_key_file string   Path to private key to use when signing (default "./pk.json")
+      --remote_cli_url string             takes a remote endpoint in the form of <protocol>://<host> (uses RPC Port) (default "http://localhost:50832")
+```
+
+### SEE ALSO
+
+* [client](client.md)	 - Pocket Network Command Line Interface (CLI)
+* [client System Health](client_System_Health.md)	 - RPC endpoint liveness
+* [client System Version](client_System_Version.md)	 - Advertised node software version
+
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_System_Health.md b/app/client/cli/doc/commands/client_System_Health.md
new file mode 100644
index 000000000..4bf141e9f
--- /dev/null
+++ b/app/client/cli/doc/commands/client_System_Health.md
@@ -0,0 +1,30 @@
+## client System Health
+
+RPC endpoint liveness
+
+### Synopsis
+
+Performs a simple liveness check on the node RPC endpoint
+
+```
+client System Health [flags]
+```
+
+### Options
+
+```
+  -h, --help   help for Health
+```
+
+### Options inherited from parent commands
+
+```
+      --path_to_private_key_file string   Path to private key to use when signing (default "./pk.json")
+      --remote_cli_url string             takes a remote endpoint in the form of <protocol>://<host> (uses RPC Port) (default "http://localhost:50832")
+```
+
+### SEE ALSO
+
+* [client System](client_System.md)	 - Commands related to health and troubleshooting of the node instance
+
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_System_Version.md b/app/client/cli/doc/commands/client_System_Version.md
new file mode 100644
index 000000000..e3f22e4a0
--- /dev/null
+++ b/app/client/cli/doc/commands/client_System_Version.md
@@ -0,0 +1,30 @@
+## client System Version
+
+Advertised node software version
+
+### Synopsis
+
+Queries the node RPC to obtain the version of the software currently running
+
+```
+client System Version [flags]
+```
+
+### Options
+
+```
+  -h, --help   help for Version
+```
+
+### Options inherited from parent commands
+
+```
+      --path_to_private_key_file string   Path to private key to use when signing (default "./pk.json")
+      --remote_cli_url string             takes a remote endpoint in the form of <protocol>://<host> (uses RPC Port) (default "http://localhost:50832")
+```
+
+### SEE ALSO
+
+* [client System](client_System.md)	 - Commands related to health and troubleshooting of the node instance
+
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Validator.md b/app/client/cli/doc/commands/client_Validator.md
index 369c11480..10b206138 100644
--- a/app/client/cli/doc/commands/client_Validator.md
+++ b/app/client/cli/doc/commands/client_Validator.md
@@ -19,8 +19,8 @@ Validator actor specific commands
 
 * [client](client.md)	 - Pocket Network Command Line Interface (CLI)
 * [client Validator EditStake](client_Validator_EditStake.md)	 - EditStake <fromAddr> <amount> <relayChainIDs> <serviceURI>
-* [client Validator Stake](client_Validator_Stake.md)	 - Stake an actor (Validator) in the network.
+* [client Validator Stake](client_Validator_Stake.md)	 - Stake a node in the network. Custodial stake uses the same address as operator/output for rewards/return of staked funds.
 * [client Validator Unpause](client_Validator_Unpause.md)	 - Unpause <fromAddr>
 * [client Validator Unstake](client_Validator_Unstake.md)	 - Unstake <fromAddr>
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Validator_EditStake.md b/app/client/cli/doc/commands/client_Validator_EditStake.md
index 45913437a..6b48b6e00 100644
--- a/app/client/cli/doc/commands/client_Validator_EditStake.md
+++ b/app/client/cli/doc/commands/client_Validator_EditStake.md
@@ -28,4 +28,4 @@ client Validator EditStake <fromAddr> <amount> <relayChainIDs> <serviceURI> [fla
 
 * [client Validator](client_Validator.md)	 - Validator actor specific commands
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Validator_Stake.md b/app/client/cli/doc/commands/client_Validator_Stake.md
index 31de3323f..01bc5fa8e 100644
--- a/app/client/cli/doc/commands/client_Validator_Stake.md
+++ b/app/client/cli/doc/commands/client_Validator_Stake.md
@@ -1,10 +1,22 @@
 ## client Validator Stake
 
-Stake an actor (Validator) in the network.
+Stake a node in the network. Custodial stake uses the same address as operator/output for rewards/return of staked funds.
 
 ### Synopsis
 
-Stake the Validator actor into the network, making it available for service.
+Stake the node into the network, making it available for service.
+
+Will prompt the user for the *fromAddr* account passphrase. If the node is already staked, this transaction acts as an *update* transaction.
+
+A node can update relayChainIDs, serviceURI, and raise the stake amount with this transaction.
+
+If the node is currently staked at X and you submit an update with new stake Y. Only Y-X will be subtracted from an account.
+
+If no changes are desired for the parameter, just enter the current param value just as before.
+
+```
+client Validator Stake <fromAddr> <amount> <relayChainIDs> <serviceURI> [flags]
+```
 
 ### Options
 
@@ -23,6 +35,5 @@ Stake the Validator actor into the network, making it available for service.
 ### SEE ALSO
 
 * [client Validator](client_Validator.md)	 - Validator actor specific commands
-* [client Validator Stake Custodial](client_Validator_Stake_Custodial.md)	 - Stake a node in the network. Custodial stake uses the same address as operator/output for rewards/return of staked funds.
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Validator_Stake_Custodial.md b/app/client/cli/doc/commands/client_Validator_Stake_Custodial.md
deleted file mode 100644
index 813281a3c..000000000
--- a/app/client/cli/doc/commands/client_Validator_Stake_Custodial.md
+++ /dev/null
@@ -1,35 +0,0 @@
-## client Validator Stake Custodial
-
-Stake a node in the network. Custodial stake uses the same address as operator/output for rewards/return of staked funds.
-
-### Synopsis
-
-Stake the node into the network, making it available for service.
-Will prompt the user for the <fromAddr> account passphrase. If the node is already staked, this transaction acts as an *update* transaction.
-A node can update relayChainIDs, serviceURI, and raise the stake amount with this transaction.
-If the node is currently staked at X and you submit an update with new stake Y. Only Y-X will be subtracted from an account
-If no changes are desired for the parameter, just enter the current param value just as before.
-
-```
-client Validator Stake Custodial <fromAddr> <amount> <relayChainIDs> <serviceURI> [flags]
-```
-
-### Options
-
-```
-  -h, --help         help for Custodial
-      --pwd string   passphrase used by the cmd, non empty usage bypass interactive prompt
-```
-
-### Options inherited from parent commands
-
-```
-      --path_to_private_key_file string   Path to private key to use when signing (default "./pk.json")
-      --remote_cli_url string             takes a remote endpoint in the form of <protocol>://<host> (uses RPC Port) (default "http://localhost:50832")
-```
-
-### SEE ALSO
-
-* [client Validator Stake](client_Validator_Stake.md)	 - Stake an actor (Validator) in the network.
-
-###### Auto generated by spf13/cobra on 19-Oct-2022
diff --git a/app/client/cli/doc/commands/client_Validator_Unpause.md b/app/client/cli/doc/commands/client_Validator_Unpause.md
index b4fee2c1c..fd442d393 100644
--- a/app/client/cli/doc/commands/client_Validator_Unpause.md
+++ b/app/client/cli/doc/commands/client_Validator_Unpause.md
@@ -28,4 +28,4 @@ client Validator Unpause <fromAddr> [flags]
 
 * [client Validator](client_Validator.md)	 - Validator actor specific commands
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/doc/commands/client_Validator_Unstake.md b/app/client/cli/doc/commands/client_Validator_Unstake.md
index e95079694..dc0b2b9b2 100644
--- a/app/client/cli/doc/commands/client_Validator_Unstake.md
+++ b/app/client/cli/doc/commands/client_Validator_Unstake.md
@@ -28,4 +28,4 @@ client Validator Unstake <fromAddr> [flags]
 
 * [client Validator](client_Validator.md)	 - Validator actor specific commands
 
-###### Auto generated by spf13/cobra on 19-Oct-2022
+###### Auto generated by spf13/cobra on 9-Nov-2022
diff --git a/app/client/cli/gov.go b/app/client/cli/gov.go
index f74c15a6e..6e72b2087 100644
--- a/app/client/cli/gov.go
+++ b/app/client/cli/gov.go
@@ -59,7 +59,7 @@ func govCommands() []*cobra.Command {
 					ParameterValue: pbValue,
 				}
 
-				tx, err := prepareTxJson(msg, pk)
+				tx, err := prepareTxBytes(msg, pk)
 				if err != nil {
 					return err
 				}
diff --git a/app/client/cli/system.go b/app/client/cli/system.go
new file mode 100644
index 000000000..2bcce8e24
--- /dev/null
+++ b/app/client/cli/system.go
@@ -0,0 +1,79 @@
+package cli
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/pokt-network/pocket/rpc"
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	systemCmd := NewSystemCommand()
+	rootCmd.AddCommand(systemCmd)
+}
+
+func NewSystemCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "System",
+		Short:   "Commands related to health and troubleshooting of the node instance",
+		Aliases: []string{"sys"},
+		Args:    cobra.ExactArgs(0),
+	}
+
+	cmd.AddCommand(systemCommands()...)
+
+	return cmd
+}
+
+func systemCommands() []*cobra.Command {
+	cmds := []*cobra.Command{
+		{
+			Use:     "Health",
+			Short:   "RPC endpoint liveness",
+			Long:    "Performs a simple liveness check on the node RPC endpoint",
+			Aliases: []string{"health"},
+			RunE: func(cmd *cobra.Command, args []string) error {
+				client, err := rpc.NewClientWithResponses(remoteCLIURL)
+				if err != nil {
+					return nil
+				}
+				response, err := client.GetV1HealthWithResponse(cmd.Context())
+				if err != nil {
+					return unableToConnectToRpc(err)
+				}
+				statusCode := response.StatusCode()
+				if statusCode == http.StatusOK {
+					fmt.Printf("✅ RPC reporting healthy status for node @ %s\n\n%s", boldText(remoteCLIURL), response.Body)
+					return nil
+				}
+
+				return rpcResponseCodeUnhealthy(statusCode, response.Body)
+			},
+		},
+		{
+			Use:     "Version",
+			Short:   "Advertised node software version",
+			Long:    "Queries the node RPC to obtain the version of the software currently running",
+			Aliases: []string{"version"},
+			RunE: func(cmd *cobra.Command, args []string) error {
+				client, err := rpc.NewClientWithResponses(remoteCLIURL)
+				if err != nil {
+					return err
+				}
+				response, err := client.GetV1VersionWithResponse(cmd.Context())
+				if err != nil {
+					return unableToConnectToRpc(err)
+				}
+				statusCode := response.StatusCode()
+				if statusCode == http.StatusOK {
+					fmt.Printf("Node @ %s reports that it's running version: \n%s\n", boldText(remoteCLIURL), boldText(response.Body))
+					return nil
+				}
+
+				return rpcResponseCodeUnhealthy(statusCode, response.Body)
+			},
+		},
+	}
+	return cmds
+}
diff --git a/app/client/cli/utils.go b/app/client/cli/utils.go
index 58d1aa3c8..ec03639af 100644
--- a/app/client/cli/utils.go
+++ b/app/client/cli/utils.go
@@ -91,10 +91,10 @@ func confirmation(pwd string) bool {
 	}
 }
 
-// prepareTxJson wraps a Message into a Transaction and signs it with the provided pk
+// prepareTxBytes wraps a Message into a Transaction and signs it with the provided pk
 //
-// returns the JSON bytes of the signed transaction
-func prepareTxJson(msg typesUtil.Message, pk crypto.Ed25519PrivateKey) ([]byte, error) {
+// returns the raw protobuf bytes of the signed transaction
+func prepareTxBytes(msg typesUtil.Message, pk crypto.Ed25519PrivateKey) ([]byte, error) {
 	var err error
 	anyMsg, err := codec.GetCodec().ToAny(msg)
 	if err != nil {
@@ -121,11 +121,11 @@ func prepareTxJson(msg typesUtil.Message, pk crypto.Ed25519PrivateKey) ([]byte,
 		PublicKey: pk.PublicKey().Bytes(),
 	}
 
-	j, err := codec.GetCodec().Marshal(tx)
+	bz, err := codec.GetCodec().Marshal(tx)
 	if err != nil {
 		return nil, err
 	}
-	return j, nil
+	return bz, nil
 }
 
 // postRawTx posts a signed transaction
@@ -190,3 +190,17 @@ func attachPwdFlagToSubcommands() []cmdOption {
 		c.Flags().StringVar(&pwd, "pwd", "", "passphrase used by the cmd, non empty usage bypass interactive prompt")
 	}}
 }
+
+func unableToConnectToRpc(err error) error {
+	fmt.Printf("❌ Unable to connect to the RPC @ %s\n\nError: %s", boldText(remoteCLIURL), err)
+	return nil
+}
+
+func rpcResponseCodeUnhealthy(statusCode int, response []byte) error {
+	fmt.Printf("❌ RPC reporting unhealthy status HTTP %d @ %s\n\n%s", statusCode, boldText(remoteCLIURL), response)
+	return nil
+}
+
+func boldText[T string | []byte](s T) string {
+	return fmt.Sprintf("\033[1m%s\033[0m", s)
+}
diff --git a/build/config/config1.json b/build/config/config1.json
index a81a73bf7..d4db38c05 100755
--- a/build/config/config1.json
+++ b/build/config/config1.json
@@ -35,6 +35,7 @@
   "rpc": {
     "enabled": true,
     "port": "50832",
-    "timeout": 30000
+    "timeout": 30000,
+    "use_cors": false
   }
 }
diff --git a/build/config/config2.json b/build/config/config2.json
index 0583a094e..9d7054c25 100755
--- a/build/config/config2.json
+++ b/build/config/config2.json
@@ -35,6 +35,7 @@
   "rpc": {
     "enabled": true,
     "port": "50832",
-    "timeout": 30000
+    "timeout": 30000,
+    "use_cors": false
   }
 }
diff --git a/build/config/config3.json b/build/config/config3.json
index 37229ef36..2903ad0b6 100755
--- a/build/config/config3.json
+++ b/build/config/config3.json
@@ -35,6 +35,7 @@
   "rpc": {
     "enabled": true,
     "port": "50832",
-    "timeout": 30000
+    "timeout": 30000,
+    "use_cors": false
   }
 }
diff --git a/build/config/config4.json b/build/config/config4.json
index 839c37d00..744220822 100755
--- a/build/config/config4.json
+++ b/build/config/config4.json
@@ -35,6 +35,7 @@
   "rpc": {
     "enabled": true,
     "port": "50832",
-    "timeout": 30000
+    "timeout": 30000,
+    "use_cors": false
   }
 }
diff --git a/build/deployments/docker-compose.yaml b/build/deployments/docker-compose.yaml
index d740a2bb9..92ca33920 100755
--- a/build/deployments/docker-compose.yaml
+++ b/build/deployments/docker-compose.yaml
@@ -46,8 +46,9 @@ services:
     # Needed for DLV debugging
     security_opt:
       - "seccomp:unconfined"
+    environment:
+      - POCKET_RPC_USE_CORS=true
     # Uncomment to enable DLV debugging
-    # environment:
     #   - DEBUG_PORT=7081
 
   node2.consensus:
diff --git a/build/scripts/watch_build.sh b/build/scripts/watch_build.sh
index ced2e143a..89f72ccac 100755
--- a/build/scripts/watch_build.sh
+++ b/build/scripts/watch_build.sh
@@ -1,6 +1,6 @@
 #!/bin/bash
 
-if builtin type -P "reflex"
+if command -v reflex >/dev/null
 then
   reflex -r '\.go$' -s -- sh -c "go build -v app/pocket/main.go"
 else
diff --git a/go.mod b/go.mod
index 6d7599fd0..943fd2a61 100644
--- a/go.mod
+++ b/go.mod
@@ -10,7 +10,6 @@ require (
 	github.com/ProtonMail/go-ecvrf v0.0.1
 	github.com/golang/mock v1.6.0
 	github.com/jackc/pgx/v4 v4.17.2
-	github.com/manifoldco/promptui v0.9.0
 	github.com/ory/dockertest v3.3.5+incompatible
 	github.com/stretchr/testify v1.8.0
 	golang.org/x/crypto v0.0.0-20221012134737-56aed061732a
@@ -26,6 +25,7 @@ require (
 	github.com/jackc/pgconn v1.13.0
 	github.com/jordanorelli/lexnum v0.0.0-20141216151731-460eeb125754
 	github.com/labstack/echo/v4 v4.9.1
+	github.com/manifoldco/promptui v0.9.0
 	github.com/mitchellh/mapstructure v1.5.0
 	github.com/quasilyte/go-ruleguard/dsl v0.3.21
 	github.com/spf13/cobra v1.6.0
@@ -77,7 +77,7 @@ require (
 
 require (
 	filippo.io/edwards25519 v1.0.0 // indirect
-	github.com/chzyer/readline v1.5.1 // indirect
+	github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/fsnotify/fsnotify v1.6.0 // indirect
diff --git a/go.sum b/go.sum
index 2425f509d..bd7095f2d 100644
--- a/go.sum
+++ b/go.sum
@@ -73,15 +73,12 @@ github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XL
 github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE=
 github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/checkpoint-restore/go-criu/v5 v5.3.0/go.mod h1:E/eQpaFtUKGOOSEBZgmKAcn+zUUwWxqcaKZlF54wK8E=
+github.com/chzyer/logex v1.1.10 h1:Swpa1K6QvQznwJRcfTfQJmTE72DqScAa40E+fbHEXEE=
 github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
-github.com/chzyer/logex v1.2.1 h1:XHDu3E6q+gdHgsdTPH6ImJMIp436vR6MPtH8gP05QzM=
-github.com/chzyer/logex v1.2.1/go.mod h1:JLbx6lG2kDbNRFnfkgvh4eRJRPX1QCoOIWomwysCBrQ=
+github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e h1:fY5BOSpyZCqRo5OhCuC+XN+r/bBCmeuuJtjz+bCNIf8=
 github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
-github.com/chzyer/readline v1.5.1 h1:upd/6fQk4src78LMRzh5vItIt361/o4uq553V8B5sGI=
-github.com/chzyer/readline v1.5.1/go.mod h1:Eh+b79XXUwfKfcPLepksvw2tcLE/Ct21YObkaSkeBlk=
+github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1 h1:q763qf9huN11kDQavWsoZXJNW3xEE4JJyHa5Q25/sd8=
 github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
-github.com/chzyer/test v1.0.0 h1:p3BQDXSxOhOG0P9z6/hGnII4LGiEPOYBhs8asl/fC04=
-github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38GC8=
 github.com/cilium/ebpf v0.7.0/go.mod h1:/oI2+1shJiTGAMgl6/RgJr36Eo1jzrRcAWbcXO2usCA=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
@@ -689,7 +686,6 @@ golang.org/x/sys v0.0.0-20211103235746-7861aae1554b/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20211116061358-0a5406a5449c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20221010170243-090e33056c14/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
diff --git a/p2p/module.go b/p2p/module.go
index 7f6e768a9..c5ef1cb1f 100644
--- a/p2p/module.go
+++ b/p2p/module.go
@@ -140,7 +140,7 @@ func (m *p2pModule) Broadcast(msg *anypb.Any, topic debug.PocketTopic) error {
 		Topic: topic,
 		Data:  msg,
 	}
-	data, err := proto.Marshal(c)
+	data, err := proto.MarshalOptions{Deterministic: true}.Marshal(c)
 	if err != nil {
 		return err
 	}
@@ -154,7 +154,7 @@ func (m *p2pModule) Send(addr cryptoPocket.Address, msg *anypb.Any, topic debug.
 		Topic: topic,
 		Data:  msg,
 	}
-	data, err := proto.Marshal(c)
+	data, err := proto.MarshalOptions{Deterministic: true}.Marshal(c)
 	if err != nil {
 		return err
 	}
diff --git a/p2p/raintree/network.go b/p2p/raintree/network.go
index 944dc4916..6e7d2c6f3 100644
--- a/p2p/raintree/network.go
+++ b/p2p/raintree/network.go
@@ -7,6 +7,7 @@ import (
 	"time"
 
 	typesP2P "github.com/pokt-network/pocket/p2p/types"
+	"github.com/pokt-network/pocket/shared/codec"
 	cryptoPocket "github.com/pokt-network/pocket/shared/crypto"
 	"github.com/pokt-network/pocket/shared/debug"
 	"github.com/pokt-network/pocket/shared/modules"
@@ -57,7 +58,7 @@ func (n *rainTreeNetwork) networkBroadcastAtLevel(data []byte, level uint32, non
 		Data:  data,
 		Nonce: nonce,
 	}
-	msgBz, err := proto.Marshal(msg)
+	msgBz, err := codec.GetCodec().Marshal(msg)
 	if err != nil {
 		return err
 	}
@@ -93,7 +94,7 @@ func (n *rainTreeNetwork) NetworkSend(data []byte, address cryptoPocket.Address)
 		Nonce: getNonce(),
 	}
 
-	bz, err := proto.Marshal(msg)
+	bz, err := codec.GetCodec().Marshal(msg)
 	if err != nil {
 		return err
 	}
diff --git a/rpc/doc/CHANGELOG.md b/rpc/doc/CHANGELOG.md
index 50f3cf428..375eb32bb 100644
--- a/rpc/doc/CHANGELOG.md
+++ b/rpc/doc/CHANGELOG.md
@@ -11,7 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- Consensus RoundState endpoint
+- Consensus State endpoint
 - Added CORS feature flag and config
 - Added dockerized swagger-ui
 
diff --git a/rpc/doc/README.md b/rpc/doc/README.md
index 647eb3bef..11eca4a09 100644
--- a/rpc/doc/README.md
+++ b/rpc/doc/README.md
@@ -25,7 +25,7 @@ This approach will allow us to focus on the features and less on the boilerpate
 
 The current implementation uses code generation for ease of development.
 
-The source of truth is the the [OpenAPI3.0 yaml file](../v1/openapi.yaml).
+The source of truth is the the [OpenAPI3.0 yaml file](../v1/openapi.yaml) (also conveniently visible [here](https://editor.swagger.io/?url=https://raw.githubusercontent.com/pokt-network/pocket/main/rpc/v1/openapi.yaml) via the Swagger Editor)
 
 Anytime we make changes to the yaml file, we need to regenerate the boilerplate code by running
 
diff --git a/rpc/handlers.go b/rpc/handlers.go
index 6bf16380e..548c3f3e8 100644
--- a/rpc/handlers.go
+++ b/rpc/handlers.go
@@ -39,9 +39,9 @@ func (s *rpcServer) PostV1ClientBroadcastTxSync(ctx echo.Context) error {
 	return nil
 }
 
-func (s *rpcServer) GetV1ConsensusRoundState(ctx echo.Context) error {
+func (s *rpcServer) GetV1ConsensusState(ctx echo.Context) error {
 	consensus := s.GetBus().GetConsensusModule()
-	return ctx.JSON(200, RoundState{
+	return ctx.JSON(200, ConsensusState{
 		Height: int64(consensus.CurrentHeight()),
 		Round:  int64(consensus.CurrentRound()),
 		Step:   int64(consensus.CurrentStep()),
diff --git a/rpc/server.go b/rpc/server.go
index 90e69a617..807e92c49 100644
--- a/rpc/server.go
+++ b/rpc/server.go
@@ -28,14 +28,22 @@ func (s *rpcServer) StartRPC(port string, timeout uint64) {
 	log.Printf("Starting RPC on port %s...\n", port)
 
 	e := echo.New()
-	e.Use(
+	middlewares := []echo.MiddlewareFunc{
 		middleware.Logger(),
 		middleware.TimeoutWithConfig(middleware.TimeoutConfig{
 			Skipper:      middleware.DefaultSkipper,
 			ErrorMessage: "Request timed out",
 			Timeout:      time.Duration(defaults.DefaultRpcTimeout) * time.Millisecond,
 		}),
+	}
+	if s.bus.GetRuntimeMgr().GetConfig().GetRPCConfig().GetUseCors() {
+		log.Println("Enabling CORS middleware")
+		middlewares = append(middlewares, middleware.CORS())
+	}
+	e.Use(
+		middlewares...,
 	)
+
 	RegisterHandlers(e, s)
 
 	if err := e.Start(":" + port); err != http.ErrServerClosed {
diff --git a/rpc/types/proto/rpc_config.proto b/rpc/types/proto/rpc_config.proto
index 4d95b3e86..432fd1f67 100644
--- a/rpc/types/proto/rpc_config.proto
+++ b/rpc/types/proto/rpc_config.proto
@@ -8,4 +8,5 @@ message RPCConfig {
   bool enabled = 1;
   string port = 2;
   uint64 timeout = 3;
+  bool use_cors = 4;
 }
diff --git a/rpc/types/types.go b/rpc/types/types.go
new file mode 100644
index 000000000..08c6e87e8
--- /dev/null
+++ b/rpc/types/types.go
@@ -0,0 +1,3 @@
+package types
+
+// this file is only here to make sure that the go tooling is aware of this package ahead of code-generation
diff --git a/rpc/v1/openapi.yaml b/rpc/v1/openapi.yaml
index a8bce9d31..3183d561b 100644
--- a/rpc/v1/openapi.yaml
+++ b/rpc/v1/openapi.yaml
@@ -53,7 +53,7 @@ paths:
               schema:
                 type: string
                 example: 1.0.0
-  /v1/consensus/round_state:
+  /v1/consensus/state:
     get:
       tags:
         - consensus
@@ -64,7 +64,7 @@ paths:
           content:
             application/json:
               schema:
-                 $ref: '#/components/schemas/RoundState'
+                 $ref: '#/components/schemas/ConsensusState'
               example:
                 {
                   "height": 75016,
@@ -111,7 +111,7 @@ components:
           type: string
         raw_hex_bytes:
           type: string
-    RoundState:
+    ConsensusState:
         type: object
         required:
           - height
diff --git a/shared/codec/codec.go b/shared/codec/codec.go
index 0fc0db663..258858adc 100644
--- a/shared/codec/codec.go
+++ b/shared/codec/codec.go
@@ -21,7 +21,7 @@ var _ Codec = &ProtoCodec{}
 type ProtoCodec struct{}
 
 func (p *ProtoCodec) Marshal(message proto.Message) ([]byte, error) {
-	bz, err := proto.Marshal(message)
+	bz, err := proto.MarshalOptions{Deterministic: true}.Marshal(message)
 	if err != nil {
 		return nil, err
 	}
diff --git a/shared/modules/mocks/mocks.go b/shared/modules/mocks/mocks.go
new file mode 100644
index 000000000..b11cd844d
--- /dev/null
+++ b/shared/modules/mocks/mocks.go
@@ -0,0 +1 @@
+package mock_modules
diff --git a/shared/modules/types.go b/shared/modules/types.go
index c6e2738b4..ce6a3fd4a 100644
--- a/shared/modules/types.go
+++ b/shared/modules/types.go
@@ -70,6 +70,7 @@ type RPCConfig interface {
 	GetEnabled() bool
 	GetPort() string
 	GetTimeout() uint64
+	GetUseCors() bool
 }
 
 type PersistenceGenesisState interface {

From 92897bffda58a38e115d05648bc8a7275d4b1087 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 14 Nov 2022 10:37:56 -0800
Subject: [PATCH 172/227] Updated txResults comment

---
 persistence/db.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/persistence/db.go b/persistence/db.go
index 91929c226..aeb9f4e85 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -50,7 +50,7 @@ type PostgresContext struct {
 	blockProtoBytes []byte
 	blockHash       string
 	blockTxs        [][]byte
-	txResults       []modules.TxResult // DISCUSS_IN_THIS_COMMIT: Can this be removed and retrieved from `txIndexer` using `height`?
+	txResults       []modules.TxResult // Not indexed by `txIndexer` until commit.
 }
 
 func (pg *PostgresContext) GetCtxAndTx() (context.Context, pgx.Tx, error) {

From 0551bbc9bbe806da12cc39bbe76d6f8775167ba4 Mon Sep 17 00:00:00 2001
From: Jason You <Jasonyou1995@users.noreply.github.com>
Date: Mon, 14 Nov 2022 16:35:44 -0500
Subject: [PATCH 173/227] Ticket #211: finding unnecessary public functions in
 the Persistence Module (#320)

Reducing the scope of public functions in the persistence package from public to private for readability purposes
---
 .gitignore                               |  2 +-
 docs/development/FAQ.md                  | 10 ++++++
 persistence/CHANGELOG.md                 |  2 ++
 persistence/account.go                   | 14 ++++-----
 persistence/application.go               | 13 ++------
 persistence/block.go                     |  6 ++--
 persistence/db.go                        |  6 ++--
 persistence/docs/CHANGELOG.md            | 34 ++++++++++++++++++++
 persistence/fisherman.go                 |  6 ++--
 persistence/genesis.go                   | 32 +++++++++----------
 persistence/gov.go                       |  6 ++--
 persistence/service_node.go              |  6 ++--
 persistence/shared_sql.go                | 40 ++++++++++++------------
 persistence/test/application_test.go     |  4 +--
 persistence/test/fisherman_test.go       |  4 +--
 persistence/test/generic_test.go         |  4 +--
 persistence/test/service_node_test.go    |  4 +--
 persistence/test/validator_test.go       |  4 +--
 persistence/types/account.go             | 18 +++++------
 persistence/types/base_actor.go          | 19 ++++++-----
 persistence/types/gov.go                 |  3 --
 persistence/types/persistence_genesis.go |  6 ++--
 persistence/types/shared_sql.go          | 20 ++++++------
 persistence/validator.go                 | 10 +++---
 24 files changed, 153 insertions(+), 120 deletions(-)
 create mode 100644 docs/development/FAQ.md

diff --git a/.gitignore b/.gitignore
index 21f9eb7f9..60287a9e5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -58,4 +58,4 @@ rpc/server.gen.go
 rpc/client.gen.go
 
 # Ignored generated files by build/config/main.go
-build/config/gen*.json
+build/config/gen*.json
\ No newline at end of file
diff --git a/docs/development/FAQ.md b/docs/development/FAQ.md
new file mode 100644
index 000000000..c1b9e65bb
--- /dev/null
+++ b/docs/development/FAQ.md
@@ -0,0 +1,10 @@
+# FAQ
+
+A list of common issues & resolutions shared by the V1 contributors
+
+## Avoid redundant files from iCloud backup
+
+* **Issue**: when working on MacOS with iCloud backup turned on, redundant files could be generated in GitHub projects. (e.g. `file.go` and `file 2.go`) Details can be found here in [this link](https://stackoverflow.com/a/62387243). 
+* **Solution**: adding `.nosync` as suffix to the workspace folder, e.g. `pocket.nosync`. Alternative, working in a folder that iCloud doesn't touch also works.
+
+_NOTE: Consider turning of the `gofmt` in your IDE to prevent unexpected formatting_
\ No newline at end of file
diff --git a/persistence/CHANGELOG.md b/persistence/CHANGELOG.md
index e893f8919..a4d496c49 100644
--- a/persistence/CHANGELOG.md
+++ b/persistence/CHANGELOG.md
@@ -5,6 +5,8 @@ All notable changes to this module will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+TODO: consolidate `persistence/docs/CHANGELOG` and `persistence/CHANGELOG.md`
+
 ## [Unreleased]
 
 ## [0.0.0.7] - 2022-11-01
diff --git a/persistence/account.go b/persistence/account.go
index 398a3c13e..75737413a 100644
--- a/persistence/account.go
+++ b/persistence/account.go
@@ -23,7 +23,7 @@ func (p PostgresContext) GetAccountAmount(address []byte, height int64) (amount
 }
 
 func (p PostgresContext) getAccountAmountStr(address string, height int64) (amount string, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return
 	}
@@ -51,9 +51,9 @@ func (p PostgresContext) SubtractAccountAmount(address []byte, amount string) er
 }
 
 // DISCUSS(team): If we are okay with `GetAccountAmount` return 0 as a default, this function can leverage
-//                `operationAccountAmount` with `*orig = *delta` and make everything much simpler.
+// `operationAccountAmount` with `*orig = *delta` and make everything much simpler.
 func (p PostgresContext) SetAccountAmount(address []byte, amount string) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -76,7 +76,7 @@ func (p *PostgresContext) operationAccountAmount(address []byte, deltaAmount str
 
 // TODO(andrew): remove address param
 func (p PostgresContext) InsertPool(name string, address []byte, amount string) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -91,7 +91,7 @@ func (p PostgresContext) InsertPool(name string, address []byte, amount string)
 }
 
 func (p PostgresContext) GetPoolAmount(name string, height int64) (amount string, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return
 	}
@@ -124,7 +124,7 @@ func (p PostgresContext) SubtractPoolAmount(name string, amount string) error {
 //
 // DISCUSS(team): Do we have a use-case for this function?
 func (p PostgresContext) SetPoolAmount(name string, amount string) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -146,7 +146,7 @@ func (p *PostgresContext) operationPoolOrAccAmount(name, amount string,
 	op func(*big.Int, *big.Int) error,
 	getAmount func(string, int64) (string, error),
 	insert func(name, amount string, height int64) string) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
diff --git a/persistence/application.go b/persistence/application.go
index 60bd930eb..1c8518009 100644
--- a/persistence/application.go
+++ b/persistence/application.go
@@ -2,8 +2,6 @@ package persistence
 
 import (
 	"encoding/hex"
-	"log"
-
 	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 )
@@ -13,7 +11,7 @@ func (p PostgresContext) GetAppExists(address []byte, height int64) (exists bool
 }
 
 func (p PostgresContext) GetApp(address []byte, height int64) (operator, publicKey, stakedTokens, maxRelays, outputAddress string, pauseHeight, unstakingHeight int64, chains []string, err error) {
-	actor, err := p.GetActor(types.ApplicationActor, address, height)
+	actor, err := p.getActor(types.ApplicationActor, address, height)
 	operator = actor.Address
 	publicKey = actor.PublicKey
 	stakedTokens = actor.StakedAmount
@@ -50,16 +48,11 @@ func (p PostgresContext) UpdateApp(address []byte, maxRelays string, stakedAmoun
 }
 
 func (p PostgresContext) GetAppStakeAmount(height int64, address []byte) (string, error) {
-	return p.GetActorStakeAmount(types.ApplicationActor, address, height)
+	return p.getActorStakeAmount(types.ApplicationActor, address, height)
 }
 
 func (p PostgresContext) SetAppStakeAmount(address []byte, stakeAmount string) error {
-	return p.SetActorStakeAmount(types.ApplicationActor, address, stakeAmount)
-}
-
-func (p PostgresContext) DeleteApp(_ []byte) error {
-	log.Println("[DEBUG] DeleteApp is a NOOP")
-	return nil
+	return p.setActorStakeAmount(types.ApplicationActor, address, stakeAmount)
 }
 
 func (p PostgresContext) GetAppsReadyToUnstake(height int64, _ int32) ([]modules.IUnstakingActor, error) {
diff --git a/persistence/block.go b/persistence/block.go
index 3a0d9d585..547afef29 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -12,7 +12,7 @@ import (
 
 // OPTIMIZE(team): get from blockstore or keep in memory
 func (p PostgresContext) GetLatestBlockHeight() (latestHeight uint64, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return 0, err
 	}
@@ -23,7 +23,7 @@ func (p PostgresContext) GetLatestBlockHeight() (latestHeight uint64, err error)
 
 // OPTIMIZE(team): get from blockstore or keep in cache/memory
 func (p PostgresContext) GetBlockHash(height int64) ([]byte, error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return nil, err
 	}
@@ -124,7 +124,7 @@ func (p PostgresContext) storeBlock(quorumCert []byte) error {
 }
 
 func (p PostgresContext) InsertBlock(height uint64, hash string, proposerAddr []byte, quorumCert []byte) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
diff --git a/persistence/db.go b/persistence/db.go
index aeb9f4e85..ad148f790 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -53,7 +53,7 @@ type PostgresContext struct {
 	txResults       []modules.TxResult // Not indexed by `txIndexer` until commit.
 }
 
-func (pg *PostgresContext) GetCtxAndTx() (context.Context, pgx.Tx, error) {
+func (pg *PostgresContext) getCtxAndTx() (context.Context, pgx.Tx, error) {
 	return context.TODO(), pg.GetTx(), nil
 }
 
@@ -61,7 +61,7 @@ func (pg *PostgresContext) GetTx() pgx.Tx {
 	return pg.tx
 }
 
-func (pg *PostgresContext) GetCtx() (context.Context, error) {
+func (pg *PostgresContext) getCtx() (context.Context, error) {
 	return context.TODO(), nil
 }
 
@@ -223,7 +223,7 @@ func initializeBlockTables(ctx context.Context, db *pgx.Conn) error {
 
 // Exposed for testing purposes only
 func (p PostgresContext) DebugClearAll() error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
diff --git a/persistence/docs/CHANGELOG.md b/persistence/docs/CHANGELOG.md
index 47e27c417..b18fd21ee 100644
--- a/persistence/docs/CHANGELOG.md
+++ b/persistence/docs/CHANGELOG.md
@@ -5,8 +5,42 @@ All notable changes to this module will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+TODO: consolidate `persistence/docs/CHANGELOG` and `persistence/CHANGELOG.md`
+
 ## [Unreleased]
 
+## [0.0.0.9] - 2022-11-08
+
+- Changed the following exported functions to lowercase non-exported functions
+- [./pocket/persistence/]
+  - GetActor
+  - GetActorFromRow
+  - GetChainsForActor
+  - SetActorStakeAmount
+  - GetActorStakeAmount
+  - GetCtxAndTx
+  - GetCtx
+  - SetValidatorStakedTokens
+  - GetValidatorStakedTokens
+- [./pocket/persistence/types]
+  - ProtocolActorTableSchema
+  - ProtocolActorChainsTableSchema
+  - SelectChains
+  - ReadyToUnstake
+  - InsertChains
+  - UpdateUnstakingHeight
+  - UpdateStakeAmount
+  - UpdatePausedHeight
+  - UpdateUnstakedHeightIfPausedBefore
+  - AccToAccInterface
+  - TestInsertParams
+  - AccountOrPoolSchema
+  - InsertAcc
+  - SelectBalance
+- [./pocket/persistence/test]
+  - GetGenericActor
+  - NewTestGenericActor
+
 ## [0.0.0.8] - 2022-10-19
 
 - Fixed `ToPersistenceActors()` by filling all structure fields
diff --git a/persistence/fisherman.go b/persistence/fisherman.go
index 5a3105c84..deb079c50 100644
--- a/persistence/fisherman.go
+++ b/persistence/fisherman.go
@@ -12,7 +12,7 @@ func (p PostgresContext) GetFishermanExists(address []byte, height int64) (exist
 }
 
 func (p PostgresContext) GetFisherman(address []byte, height int64) (operator, publicKey, stakedTokens, serviceURL, outputAddress string, pausedHeight, unstakingHeight int64, chains []string, err error) {
-	actor, err := p.GetActor(types.FishermanActor, address, height)
+	actor, err := p.getActor(types.FishermanActor, address, height)
 	operator = actor.Address
 	publicKey = actor.PublicKey
 	stakedTokens = actor.StakedAmount
@@ -49,11 +49,11 @@ func (p PostgresContext) UpdateFisherman(address []byte, serviceURL string, stak
 }
 
 func (p PostgresContext) GetFishermanStakeAmount(height int64, address []byte) (string, error) {
-	return p.GetActorStakeAmount(types.FishermanActor, address, height)
+	return p.getActorStakeAmount(types.FishermanActor, address, height)
 }
 
 func (p PostgresContext) SetFishermanStakeAmount(address []byte, stakeAmount string) error {
-	return p.SetActorStakeAmount(types.FishermanActor, address, stakeAmount)
+	return p.setActorStakeAmount(types.FishermanActor, address, stakeAmount)
 }
 
 func (p PostgresContext) GetFishermenReadyToUnstake(height int64, status int32) ([]modules.IUnstakingActor, error) {
diff --git a/persistence/genesis.go b/persistence/genesis.go
index 37c03455b..544d298a0 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -156,12 +156,10 @@ func (m *persistenceModule) populateGenesisState(state modules.PersistenceGenesi
 }
 
 // TODO(pocket/issues/149): All of the functions below following a structure similar to `GetAll<Actor>`
-//
 //	can easily be refactored and condensed into a single function using a generic type or a common
-//
-// interface.
+//  interface.
 func (p PostgresContext) GetAllAccounts(height int64) (accs []modules.Account, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return nil, err
 	}
@@ -185,7 +183,7 @@ func (p PostgresContext) GetAllAccounts(height int64) (accs []modules.Account, e
 
 // CLEANUP: Consolidate with GetAllAccounts.
 func (p PostgresContext) GetAllPools(height int64) (accs []modules.Account, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return nil, err
 	}
@@ -204,7 +202,7 @@ func (p PostgresContext) GetAllPools(height int64) (accs []modules.Account, err
 }
 
 func (p PostgresContext) GetAllApps(height int64) (apps []modules.Actor, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return nil, err
 	}
@@ -215,7 +213,7 @@ func (p PostgresContext) GetAllApps(height int64) (apps []modules.Actor, err err
 	var actors []*types.Actor
 	for rows.Next() {
 		var actor *types.Actor
-		actor, height, err = p.GetActorFromRow(rows)
+		actor, height, err = p.getActorFromRow(rows)
 		if err != nil {
 			return
 		}
@@ -223,7 +221,7 @@ func (p PostgresContext) GetAllApps(height int64) (apps []modules.Actor, err err
 	}
 	rows.Close()
 	for _, actor := range actors {
-		actor, err = p.GetChainsForActor(ctx, tx, types.ApplicationActor, actor, height)
+		actor, err = p.getChainsForActor(ctx, tx, types.ApplicationActor, actor, height)
 		if err != nil {
 			return
 		}
@@ -233,7 +231,7 @@ func (p PostgresContext) GetAllApps(height int64) (apps []modules.Actor, err err
 }
 
 func (p PostgresContext) GetAllValidators(height int64) (vals []modules.Actor, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return nil, err
 	}
@@ -244,7 +242,7 @@ func (p PostgresContext) GetAllValidators(height int64) (vals []modules.Actor, e
 	var actors []*types.Actor
 	for rows.Next() {
 		var actor *types.Actor
-		actor, height, err = p.GetActorFromRow(rows)
+		actor, height, err = p.getActorFromRow(rows)
 		if err != nil {
 			return
 		}
@@ -252,7 +250,7 @@ func (p PostgresContext) GetAllValidators(height int64) (vals []modules.Actor, e
 	}
 	rows.Close()
 	for _, actor := range actors {
-		actor, err = p.GetChainsForActor(ctx, tx, types.ApplicationActor, actor, height)
+		actor, err = p.getChainsForActor(ctx, tx, types.ApplicationActor, actor, height)
 		if err != nil {
 			return
 		}
@@ -262,7 +260,7 @@ func (p PostgresContext) GetAllValidators(height int64) (vals []modules.Actor, e
 }
 
 func (p PostgresContext) GetAllServiceNodes(height int64) (sn []modules.Actor, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return nil, err
 	}
@@ -273,7 +271,7 @@ func (p PostgresContext) GetAllServiceNodes(height int64) (sn []modules.Actor, e
 	var actors []*types.Actor
 	for rows.Next() {
 		var actor *types.Actor
-		actor, height, err = p.GetActorFromRow(rows)
+		actor, height, err = p.getActorFromRow(rows)
 		if err != nil {
 			return
 		}
@@ -281,7 +279,7 @@ func (p PostgresContext) GetAllServiceNodes(height int64) (sn []modules.Actor, e
 	}
 	rows.Close()
 	for _, actor := range actors {
-		actor, err = p.GetChainsForActor(ctx, tx, types.ServiceNodeActor, actor, height)
+		actor, err = p.getChainsForActor(ctx, tx, types.ServiceNodeActor, actor, height)
 		if err != nil {
 			return
 		}
@@ -291,7 +289,7 @@ func (p PostgresContext) GetAllServiceNodes(height int64) (sn []modules.Actor, e
 }
 
 func (p PostgresContext) GetAllFishermen(height int64) (f []modules.Actor, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return nil, err
 	}
@@ -302,7 +300,7 @@ func (p PostgresContext) GetAllFishermen(height int64) (f []modules.Actor, err e
 	var actors []*types.Actor
 	for rows.Next() {
 		var actor *types.Actor
-		actor, height, err = p.GetActorFromRow(rows)
+		actor, height, err = p.getActorFromRow(rows)
 		if err != nil {
 			return
 		}
@@ -310,7 +308,7 @@ func (p PostgresContext) GetAllFishermen(height int64) (f []modules.Actor, err e
 	}
 	rows.Close()
 	for _, actor := range actors {
-		actor, err = p.GetChainsForActor(ctx, tx, types.FishermanActor, actor, height)
+		actor, err = p.getChainsForActor(ctx, tx, types.FishermanActor, actor, height)
 		if err != nil {
 			return
 		}
diff --git a/persistence/gov.go b/persistence/gov.go
index 09d049143..83a5fbd27 100644
--- a/persistence/gov.go
+++ b/persistence/gov.go
@@ -27,7 +27,7 @@ func (p PostgresContext) GetServiceNodesPerSessionAt(height int64) (int, error)
 }
 
 func (p PostgresContext) InitParams() error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -97,7 +97,7 @@ func (p PostgresContext) setParamOrFlag(name string, value any, enabled *bool) e
 // setParamOrFlag sets a param or a flag.
 // If `enabled` is nil, we are dealing with a param, otherwise it's a flag
 func setParamOrFlag[T types.SupportedParamTypes](p PostgresContext, paramName string, paramValue T, enabled *bool) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -116,7 +116,7 @@ func setParamOrFlag[T types.SupportedParamTypes](p PostgresContext, paramName st
 }
 
 func getParamOrFlag[T int | string | []byte](p PostgresContext, tableName, paramName string, height int64) (i T, enabled bool, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return i, enabled, err
 	}
diff --git a/persistence/service_node.go b/persistence/service_node.go
index bbb537264..e217db649 100644
--- a/persistence/service_node.go
+++ b/persistence/service_node.go
@@ -12,7 +12,7 @@ func (p PostgresContext) GetServiceNodeExists(address []byte, height int64) (exi
 }
 
 func (p PostgresContext) GetServiceNode(address []byte, height int64) (operator, publicKey, stakedTokens, serviceURL, outputAddress string, pausedHeight, unstakingHeight int64, chains []string, err error) {
-	actor, err := p.GetActor(types.ServiceNodeActor, address, height)
+	actor, err := p.getActor(types.ServiceNodeActor, address, height)
 	operator = actor.Address
 	publicKey = actor.PublicKey
 	stakedTokens = actor.StakedAmount
@@ -49,11 +49,11 @@ func (p PostgresContext) UpdateServiceNode(address []byte, serviceURL string, st
 }
 
 func (p PostgresContext) GetServiceNodeStakeAmount(height int64, address []byte) (string, error) {
-	return p.GetActorStakeAmount(types.ServiceNodeActor, address, height)
+	return p.getActorStakeAmount(types.ServiceNodeActor, address, height)
 }
 
 func (p PostgresContext) SetServiceNodeStakeAmount(address []byte, stakeAmount string) error {
-	return p.SetActorStakeAmount(types.ServiceNodeActor, address, stakeAmount)
+	return p.setActorStakeAmount(types.ServiceNodeActor, address, stakeAmount)
 }
 
 func (p PostgresContext) GetServiceNodeCount(chain string, height int64) (int, error) {
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
index 1fae6220a..089b8ab16 100644
--- a/persistence/shared_sql.go
+++ b/persistence/shared_sql.go
@@ -32,7 +32,7 @@ func UnstakingHeightToStatus(unstakingHeight int64) int32 {
 }
 
 func (p *PostgresContext) GetExists(actorSchema types.ProtocolActorSchema, address []byte, height int64) (exists bool, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return
 	}
@@ -44,20 +44,20 @@ func (p *PostgresContext) GetExists(actorSchema types.ProtocolActorSchema, addre
 	return
 }
 
-func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, address []byte, height int64) (actor *types.Actor, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+func (p *PostgresContext) getActor(actorSchema types.ProtocolActorSchema, address []byte, height int64) (actor *types.Actor, err error) {
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return
 	}
-	actor, height, err = p.GetActorFromRow(tx.QueryRow(ctx, actorSchema.GetQuery(hex.EncodeToString(address), height)))
+	actor, height, err = p.getActorFromRow(tx.QueryRow(ctx, actorSchema.GetQuery(hex.EncodeToString(address), height)))
 	if err != nil {
 		return
 	}
 
-	return p.GetChainsForActor(ctx, tx, actorSchema, actor, height)
+	return p.getChainsForActor(ctx, tx, actorSchema, actor, height)
 }
 
-func (p *PostgresContext) GetActorFromRow(row pgx.Row) (actor *types.Actor, height int64, err error) {
+func (p *PostgresContext) getActorFromRow(row pgx.Row) (actor *types.Actor, height int64, err error) {
 	actor = new(types.Actor)
 	err = row.Scan(
 		&actor.Address, &actor.PublicKey, &actor.StakedAmount, &actor.GenericParam,
@@ -66,7 +66,7 @@ func (p *PostgresContext) GetActorFromRow(row pgx.Row) (actor *types.Actor, heig
 	return
 }
 
-func (p *PostgresContext) GetChainsForActor(
+func (p *PostgresContext) getChainsForActor(
 	ctx context.Context,
 	tx pgx.Tx,
 	actorSchema types.ProtocolActorSchema,
@@ -98,7 +98,7 @@ func (p *PostgresContext) GetChainsForActor(
 }
 
 func (p *PostgresContext) InsertActor(actorSchema types.ProtocolActorSchema, actor *types.Actor) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -116,7 +116,7 @@ func (p *PostgresContext) InsertActor(actorSchema types.ProtocolActorSchema, act
 }
 
 func (p *PostgresContext) UpdateActor(actorSchema types.ProtocolActorSchema, actor *types.Actor) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -144,7 +144,7 @@ func (p *PostgresContext) UpdateActor(actorSchema types.ProtocolActorSchema, act
 }
 
 func (p *PostgresContext) GetActorsReadyToUnstake(actorSchema types.ProtocolActorSchema, height int64) (actors []modules.IUnstakingActor, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return nil, err
 	}
@@ -171,7 +171,7 @@ func (p *PostgresContext) GetActorsReadyToUnstake(actorSchema types.ProtocolActo
 
 func (p *PostgresContext) GetActorStatus(actorSchema types.ProtocolActorSchema, address []byte, height int64) (int32, error) {
 	var unstakingHeight int64
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return UndefinedStakingStatus, err
 	}
@@ -191,7 +191,7 @@ func (p *PostgresContext) GetActorStatus(actorSchema types.ProtocolActorSchema,
 }
 
 func (p *PostgresContext) SetActorUnstakingHeightAndStatus(actorSchema types.ProtocolActorSchema, address []byte, unstakingHeight int64) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -206,7 +206,7 @@ func (p *PostgresContext) SetActorUnstakingHeightAndStatus(actorSchema types.Pro
 }
 
 func (p *PostgresContext) GetActorPauseHeightIfExists(actorSchema types.ProtocolActorSchema, address []byte, height int64) (pausedHeight int64, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return types.DefaultBigInt, err
 	}
@@ -219,7 +219,7 @@ func (p *PostgresContext) GetActorPauseHeightIfExists(actorSchema types.Protocol
 }
 
 func (p PostgresContext) SetActorStatusAndUnstakingHeightIfPausedBefore(actorSchema types.ProtocolActorSchema, pausedBeforeHeight, unstakingHeight int64) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -234,7 +234,7 @@ func (p PostgresContext) SetActorStatusAndUnstakingHeightIfPausedBefore(actorSch
 }
 
 func (p PostgresContext) SetActorPauseHeight(actorSchema types.ProtocolActorSchema, address []byte, pauseHeight int64) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -248,8 +248,8 @@ func (p PostgresContext) SetActorPauseHeight(actorSchema types.ProtocolActorSche
 	return err
 }
 
-func (p PostgresContext) SetActorStakeAmount(actorSchema types.ProtocolActorSchema, address []byte, stakeAmount string) error {
-	ctx, tx, err := p.GetCtxAndTx()
+func (p PostgresContext) setActorStakeAmount(actorSchema types.ProtocolActorSchema, address []byte, stakeAmount string) error {
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -263,7 +263,7 @@ func (p PostgresContext) SetActorStakeAmount(actorSchema types.ProtocolActorSche
 }
 
 func (p PostgresContext) GetActorOutputAddress(actorSchema types.ProtocolActorSchema, operatorAddr []byte, height int64) ([]byte, error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return nil, err
 	}
@@ -276,8 +276,8 @@ func (p PostgresContext) GetActorOutputAddress(actorSchema types.ProtocolActorSc
 	return hex.DecodeString(outputAddr)
 }
 
-func (p PostgresContext) GetActorStakeAmount(actorSchema types.ProtocolActorSchema, address []byte, height int64) (string, error) {
-	ctx, tx, err := p.GetCtxAndTx()
+func (p PostgresContext) getActorStakeAmount(actorSchema types.ProtocolActorSchema, address []byte, height int64) (string, error) {
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return "", err
 	}
diff --git a/persistence/test/application_test.go b/persistence/test/application_test.go
index 311bc44b1..c1be72291 100644
--- a/persistence/test/application_test.go
+++ b/persistence/test/application_test.go
@@ -14,8 +14,8 @@ import (
 
 func FuzzApplication(f *testing.F) {
 	fuzzSingleProtocolActor(f,
-		NewTestGenericActor(types.ApplicationActor, newTestApp),
-		GetGenericActor(types.ApplicationActor, getTestApp),
+		newTestGenericActor(types.ApplicationActor, newTestApp),
+		getGenericActor(types.ApplicationActor, getTestApp),
 		types.ApplicationActor)
 }
 
diff --git a/persistence/test/fisherman_test.go b/persistence/test/fisherman_test.go
index 2571b2080..11859fde6 100644
--- a/persistence/test/fisherman_test.go
+++ b/persistence/test/fisherman_test.go
@@ -16,8 +16,8 @@ import (
 
 func FuzzFisherman(f *testing.F) {
 	fuzzSingleProtocolActor(f,
-		NewTestGenericActor(types.FishermanActor, newTestFisherman),
-		GetGenericActor(types.FishermanActor, getTestFisherman),
+		newTestGenericActor(types.FishermanActor, newTestFisherman),
+		getGenericActor(types.FishermanActor, getTestFisherman),
 		types.FishermanActor)
 }
 
diff --git a/persistence/test/generic_test.go b/persistence/test/generic_test.go
index 5e454cc84..c58d15889 100644
--- a/persistence/test/generic_test.go
+++ b/persistence/test/generic_test.go
@@ -12,7 +12,7 @@ import (
 
 // TODO(andrew): Be consistent with `GenericParam` and `ActorSpecificParam` throughout the codebase; preferably the latter.
 
-func GetGenericActor[T any](
+func getGenericActor[T any](
 	protocolActorSchema types.ProtocolActorSchema,
 	getActor func(*persistence.PostgresContext, []byte) (T, error),
 ) func(*persistence.PostgresContext, string) (*types.Actor, error) {
@@ -30,7 +30,7 @@ func GetGenericActor[T any](
 	}
 }
 
-func NewTestGenericActor[T any](protocolActorSchema types.ProtocolActorSchema, newActor func() (T, error)) func() (*types.Actor, error) {
+func newTestGenericActor[T any](protocolActorSchema types.ProtocolActorSchema, newActor func() (T, error)) func() (*types.Actor, error) {
 	return func() (*types.Actor, error) {
 		actor, err := newActor()
 		if err != nil {
diff --git a/persistence/test/service_node_test.go b/persistence/test/service_node_test.go
index b0fbb3a0c..51c1e25c9 100644
--- a/persistence/test/service_node_test.go
+++ b/persistence/test/service_node_test.go
@@ -14,8 +14,8 @@ import (
 
 func FuzzServiceNode(f *testing.F) {
 	fuzzSingleProtocolActor(f,
-		NewTestGenericActor(types.ServiceNodeActor, newTestServiceNode),
-		GetGenericActor(types.ServiceNodeActor, getTestServiceNode),
+		newTestGenericActor(types.ServiceNodeActor, newTestServiceNode),
+		getGenericActor(types.ServiceNodeActor, getTestServiceNode),
 		types.ServiceNodeActor)
 }
 
diff --git a/persistence/test/validator_test.go b/persistence/test/validator_test.go
index f376c05ee..f5d5c1d71 100644
--- a/persistence/test/validator_test.go
+++ b/persistence/test/validator_test.go
@@ -14,8 +14,8 @@ import (
 
 func FuzzValidator(f *testing.F) {
 	fuzzSingleProtocolActor(f,
-		NewTestGenericActor(types.ValidatorActor, newTestValidator),
-		GetGenericActor(types.ValidatorActor, getTestValidator),
+		newTestGenericActor(types.ValidatorActor, newTestValidator),
+		getGenericActor(types.ValidatorActor, getTestValidator),
 		types.ValidatorActor)
 }
 
diff --git a/persistence/types/account.go b/persistence/types/account.go
index a726b3dce..9f90f5526 100644
--- a/persistence/types/account.go
+++ b/persistence/types/account.go
@@ -18,27 +18,27 @@ const (
 )
 
 var (
-	AccountTableSchema = AccountOrPoolSchema(AddressCol, AccountHeightConstraint)
-	PoolTableSchema    = AccountOrPoolSchema(NameCol, PoolHeightConstraint)
+	AccountTableSchema = accountOrPoolSchema(AddressCol, AccountHeightConstraint)
+	PoolTableSchema    = accountOrPoolSchema(NameCol, PoolHeightConstraint)
 )
 
 func GetAccountAmountQuery(address string, height int64) string {
-	return SelectBalance(AddressCol, address, height, AccountTableName)
+	return selectBalance(AddressCol, address, height, AccountTableName)
 }
 
 func InsertAccountAmountQuery(address, amount string, height int64) string {
-	return InsertAcc(AddressCol, address, amount, height, AccountTableName, AccountHeightConstraint)
+	return insertAcc(AddressCol, address, amount, height, AccountTableName, AccountHeightConstraint)
 }
 
 func GetPoolAmountQuery(name string, height int64) string {
-	return SelectBalance(NameCol, name, height, PoolTableName)
+	return selectBalance(NameCol, name, height, PoolTableName)
 }
 
 func InsertPoolAmountQuery(name, amount string, height int64) string {
-	return InsertAcc(NameCol, name, amount, height, PoolTableName, PoolHeightConstraint)
+	return insertAcc(NameCol, name, amount, height, PoolTableName, PoolHeightConstraint)
 }
 
-func AccountOrPoolSchema(mainColName, constraintName string) string {
+func accountOrPoolSchema(mainColName, constraintName string) string {
 	return fmt.Sprintf(`(
 			%s TEXT NOT NULL,
 			%s TEXT NOT NULL,
@@ -48,7 +48,7 @@ func AccountOrPoolSchema(mainColName, constraintName string) string {
 		)`, mainColName, BalanceCol, HeightCol, constraintName, mainColName, HeightCol)
 }
 
-func InsertAcc(actorSpecificParam, actorSpecificParamValue, amount string, height int64, tableName, constraintName string) string {
+func insertAcc(actorSpecificParam, actorSpecificParamValue, amount string, height int64, tableName, constraintName string) string {
 	return fmt.Sprintf(`
 		INSERT INTO %s (%s, balance, height)
 			VALUES ('%s','%s',%d)
@@ -57,7 +57,7 @@ func InsertAcc(actorSpecificParam, actorSpecificParamValue, amount string, heigh
 		`, tableName, actorSpecificParam, actorSpecificParamValue, amount, height, constraintName)
 }
 
-func SelectBalance(actorSpecificParam, actorSpecificParamValue string, height int64, tableName string) string {
+func selectBalance(actorSpecificParam, actorSpecificParamValue string, height int64, tableName string) string {
 	return fmt.Sprintf(`SELECT balance FROM %s WHERE %s='%s' AND height<=%d ORDER BY height DESC LIMIT 1`,
 		tableName, actorSpecificParam, actorSpecificParamValue, height)
 }
diff --git a/persistence/types/base_actor.go b/persistence/types/base_actor.go
index 8fce33e40..7c1134ec3 100644
--- a/persistence/types/base_actor.go
+++ b/persistence/types/base_actor.go
@@ -6,7 +6,6 @@ var _ ProtocolActorSchema = &BaseProtocolActorSchema{}
 
 // Implements the ProtocolActorSchema with behaviour that can be embedded (i.e. inherited) by other protocol
 // actors for a share implementation.
-//
 // Note that this implementation assumes the protocol actor is chain dependant, so that behaviour needs
 // to be overridden if the actor (e.g. Validator) is chain independent.
 type BaseProtocolActorSchema struct {
@@ -35,11 +34,11 @@ func (actor *BaseProtocolActorSchema) GetActorSpecificColName() string {
 }
 
 func (actor *BaseProtocolActorSchema) GetTableSchema() string {
-	return ProtocolActorTableSchema(actor.actorSpecificColName, actor.heightConstraintName)
+	return protocolActorTableSchema(actor.actorSpecificColName, actor.heightConstraintName)
 }
 
 func (actor *BaseProtocolActorSchema) GetChainsTableSchema() string {
-	return ProtocolActorChainsTableSchema(actor.chainsHeightConstraintName)
+	return protocolActorChainsTableSchema(actor.chainsHeightConstraintName)
 }
 
 func (actor *BaseProtocolActorSchema) GetQuery(address string, height int64) string {
@@ -55,7 +54,7 @@ func (actor *BaseProtocolActorSchema) GetExistsQuery(address string, height int6
 }
 
 func (actor *BaseProtocolActorSchema) GetReadyToUnstakeQuery(unstakingHeight int64) string {
-	return ReadyToUnstake(unstakingHeight, actor.tableName)
+	return readyToUnstake(unstakingHeight, actor.tableName)
 }
 
 func (actor *BaseProtocolActorSchema) GetOutputAddressQuery(operatorAddress string, height int64) string {
@@ -75,7 +74,7 @@ func (actor *BaseProtocolActorSchema) GetUnstakingHeightQuery(address string, he
 }
 
 func (actor *BaseProtocolActorSchema) GetChainsQuery(address string, height int64) string {
-	return SelectChains(AllColsSelector, address, height, actor.tableName, actor.chainsTableName)
+	return selectChains(AllColsSelector, address, height, actor.tableName, actor.chainsTableName)
 }
 
 func (actor *BaseProtocolActorSchema) InsertQuery(address, publicKey, stakedTokens, generic, outputAddress string, pausedHeight, unstakingHeight int64, chains []string, height int64) string {
@@ -99,23 +98,23 @@ func (actor *BaseProtocolActorSchema) UpdateQuery(address, stakedTokens, generic
 }
 
 func (actor *BaseProtocolActorSchema) UpdateChainsQuery(address string, chains []string, height int64) string {
-	return InsertChains(address, chains, height, actor.chainsTableName, actor.chainsHeightConstraintName)
+	return insertChains(address, chains, height, actor.chainsTableName, actor.chainsHeightConstraintName)
 }
 
 func (actor *BaseProtocolActorSchema) UpdateUnstakingHeightQuery(address string, unstakingHeight, height int64) string {
-	return UpdateUnstakingHeight(address, actor.actorSpecificColName, unstakingHeight, height, actor.tableName, actor.heightConstraintName)
+	return updateUnstakingHeight(address, actor.actorSpecificColName, unstakingHeight, height, actor.tableName, actor.heightConstraintName)
 }
 
 func (actor *BaseProtocolActorSchema) UpdatePausedHeightQuery(address string, pausedHeight, height int64) string {
-	return UpdatePausedHeight(address, actor.actorSpecificColName, pausedHeight, height, actor.tableName, actor.heightConstraintName)
+	return updatePausedHeight(address, actor.actorSpecificColName, pausedHeight, height, actor.tableName, actor.heightConstraintName)
 }
 
 func (actor *BaseProtocolActorSchema) UpdateUnstakedHeightIfPausedBeforeQuery(pauseBeforeHeight, unstakingHeight, height int64) string {
-	return UpdateUnstakedHeightIfPausedBefore(actor.actorSpecificColName, unstakingHeight, pauseBeforeHeight, height, actor.tableName, actor.heightConstraintName)
+	return updateUnstakedHeightIfPausedBefore(actor.actorSpecificColName, unstakingHeight, pauseBeforeHeight, height, actor.tableName, actor.heightConstraintName)
 }
 
 func (actor *BaseProtocolActorSchema) SetStakeAmountQuery(address string, stakedTokens string, height int64) string {
-	return UpdateStakeAmount(address, actor.actorSpecificColName, stakedTokens, height, actor.tableName, actor.heightConstraintName)
+	return updateStakeAmount(address, actor.actorSpecificColName, stakedTokens, height, actor.tableName, actor.heightConstraintName)
 }
 
 func (actor *BaseProtocolActorSchema) ClearAllQuery() string {
diff --git a/persistence/types/gov.go b/persistence/types/gov.go
index 6a1bcebac..dbfdd9d1b 100644
--- a/persistence/types/gov.go
+++ b/persistence/types/gov.go
@@ -11,7 +11,6 @@ import (
 )
 
 // init initializes a map that contains the metadata extracted from `gov.proto`.
-//
 // Since protobuf files do not change at runtime, it seems efficient to do it here.
 func init() {
 	govParamMetadataMap = parseGovProto()
@@ -59,9 +58,7 @@ var (
 )
 
 // InsertParams generates the SQL INSERT statement given a *genesis.Params
-//
 // It leverages metadata in the form of struct tags (see `parseGovProto` for more information).
-//
 // WARNING: reflections in prod
 func InsertParams(params modules.Params, height int64) string {
 	val := reflect.ValueOf(params)
diff --git a/persistence/types/persistence_genesis.go b/persistence/types/persistence_genesis.go
index 8bcd46a4b..8437faf9b 100644
--- a/persistence/types/persistence_genesis.go
+++ b/persistence/types/persistence_genesis.go
@@ -14,11 +14,11 @@ var _ modules.PersistenceGenesisState = &PersistenceGenesisState{}
 //	not a fan of <module_name>_config/genesis.go would rather just config/genesis.go
 
 func (x *PersistenceGenesisState) GetAccs() []modules.Account {
-	return AccToAccInterface(x.GetAccounts())
+	return accToAccInterface(x.GetAccounts())
 }
 
 func (x *PersistenceGenesisState) GetAccPools() []modules.Account {
-	return AccToAccInterface(x.GetPools())
+	return accToAccInterface(x.GetPools())
 }
 
 func (x *PersistenceGenesisState) GetApps() []modules.Actor {
@@ -50,7 +50,7 @@ func ActorsToActorsInterface(a []*Actor) (actorI []modules.Actor) {
 	return
 }
 
-func AccToAccInterface(a []*Account) (accI []modules.Account) {
+func accToAccInterface(a []*Account) (accI []modules.Account) {
 	for _, acc := range a {
 		accI = append(accI, acc)
 	}
diff --git a/persistence/types/shared_sql.go b/persistence/types/shared_sql.go
index 7a1edd843..b99e36a2c 100644
--- a/persistence/types/shared_sql.go
+++ b/persistence/types/shared_sql.go
@@ -30,7 +30,7 @@ const (
 	HeightCol          = "height"
 )
 
-func ProtocolActorTableSchema(actorSpecificColName, constraintName string) string {
+func protocolActorTableSchema(actorSpecificColName, constraintName string) string {
 	return fmt.Sprintf(`(
 			%s TEXT NOT NULL,
 			%s TEXT NOT NULL,
@@ -59,7 +59,7 @@ func ProtocolActorTableSchema(actorSpecificColName, constraintName string) strin
 		HeightCol)
 }
 
-func ProtocolActorChainsTableSchema(constraintName string) string {
+func protocolActorChainsTableSchema(constraintName string) string {
 	return fmt.Sprintf(`(
 			%s TEXT NOT NULL,
 			%s CHAR(4) NOT NULL,
@@ -83,7 +83,7 @@ func SelectActors(actorSpecificParam string, height int64, tableName string) str
        `, actorSpecificParam, tableName, height)
 }
 
-func SelectChains(selector, address string, height int64, actorTableName, chainsTableName string) string {
+func selectChains(selector, address string, height int64, actorTableName, chainsTableName string) string {
 	return fmt.Sprintf(`SELECT %s FROM %s WHERE address='%s' AND height=(%s);`,
 		selector, chainsTableName, address, Select(HeightCol, address, height, actorTableName))
 }
@@ -97,7 +97,7 @@ func Exists(address string, height int64, tableName string) string {
 //       returns latest/max height for each address
 //   (height, address) IN (SELECT MAX(height), address FROM %s GROUP BY address) ->
 //       ensures the query is acting on max height for the addresses
-func ReadyToUnstake(unstakingHeight int64, tableName string) string {
+func readyToUnstake(unstakingHeight int64, tableName string) string {
 	return fmt.Sprintf(`
 		SELECT address, staked_tokens, output_address
 		FROM %s WHERE unstaking_height=%d
@@ -129,10 +129,10 @@ func Insert(
 	}
 
 	return fmt.Sprintf("WITH baseTableInsert AS (%s)\n%s",
-		insertStatement, InsertChains(actor.Address, actor.Chains, height, chainsTableName, chainsConstraintName))
+		insertStatement, insertChains(actor.Address, actor.Chains, height, chainsTableName, chainsConstraintName))
 }
 
-func InsertChains(address string, chains []string, height int64, tableName, constraintName string) string {
+func insertChains(address string, chains []string, height int64, tableName, constraintName string) string {
 	var buffer bytes.Buffer
 
 	buffer.WriteString(fmt.Sprintf("INSERT INTO %s (address, chain_id, height) VALUES", tableName))
@@ -166,7 +166,7 @@ func Update(address, stakedTokens, actorSpecificParam, actorSpecificParamValue s
 		actorSpecificParam, actorSpecificParam)
 }
 
-func UpdateUnstakingHeight(address, actorSpecificParam string, unstakingHeight, height int64, tableName, constraintName string) string {
+func updateUnstakingHeight(address, actorSpecificParam string, unstakingHeight, height int64, tableName, constraintName string) string {
 	return fmt.Sprintf(`
 		INSERT INTO %s(address, public_key, staked_tokens, %s, output_address, paused_height, unstaking_height, height)
 		(
@@ -181,7 +181,7 @@ func UpdateUnstakingHeight(address, actorSpecificParam string, unstakingHeight,
 		constraintName)
 }
 
-func UpdateStakeAmount(address, actorSpecificParam, stakeAmount string, height int64, tableName, constraintName string) string {
+func updateStakeAmount(address, actorSpecificParam, stakeAmount string, height int64, tableName, constraintName string) string {
 	return fmt.Sprintf(`
 		INSERT INTO %s(address, public_key, staked_tokens, %s, output_address, paused_height, unstaking_height, height)
 		(
@@ -196,7 +196,7 @@ func UpdateStakeAmount(address, actorSpecificParam, stakeAmount string, height i
 		constraintName)
 }
 
-func UpdatePausedHeight(address, actorSpecificParam string, pausedHeight, height int64, tableName, constraintName string) string {
+func updatePausedHeight(address, actorSpecificParam string, pausedHeight, height int64, tableName, constraintName string) string {
 	return fmt.Sprintf(`
 		INSERT INTO %s(address, public_key, staked_tokens, %s, output_address, paused_height, unstaking_height, height)
 		(
@@ -210,7 +210,7 @@ func UpdatePausedHeight(address, actorSpecificParam string, pausedHeight, height
 		tableName, address, height, constraintName)
 }
 
-func UpdateUnstakedHeightIfPausedBefore(actorSpecificParam string, unstakingHeight, pausedBeforeHeight, height int64, tableName, constraintName string) string {
+func updateUnstakedHeightIfPausedBefore(actorSpecificParam string, unstakingHeight, pausedBeforeHeight, height int64, tableName, constraintName string) string {
 	return fmt.Sprintf(`
 		INSERT INTO %s (address, public_key, staked_tokens, %s, output_address, paused_height, unstaking_height, height)
 		(
diff --git a/persistence/validator.go b/persistence/validator.go
index 0e1763fb3..7e2901a50 100644
--- a/persistence/validator.go
+++ b/persistence/validator.go
@@ -12,7 +12,7 @@ func (p PostgresContext) GetValidatorExists(address []byte, height int64) (exist
 }
 
 func (p PostgresContext) GetValidator(address []byte, height int64) (operator, publicKey, stakedTokens, serviceURL, outputAddress string, pausedHeight, unstakingHeight int64, err error) {
-	actor, err := p.GetActor(types.ValidatorActor, address, height)
+	actor, err := p.getActor(types.ValidatorActor, address, height)
 	operator = actor.Address
 	publicKey = actor.PublicKey
 	stakedTokens = actor.StakedAmount
@@ -46,11 +46,11 @@ func (p PostgresContext) UpdateValidator(address []byte, serviceURL string, stak
 }
 
 func (p PostgresContext) GetValidatorStakeAmount(height int64, address []byte) (string, error) {
-	return p.GetActorStakeAmount(types.ValidatorActor, address, height)
+	return p.getActorStakeAmount(types.ValidatorActor, address, height)
 }
 
 func (p PostgresContext) SetValidatorStakeAmount(address []byte, stakeAmount string) error {
-	return p.SetActorStakeAmount(types.ValidatorActor, address, stakeAmount)
+	return p.setActorStakeAmount(types.ValidatorActor, address, stakeAmount)
 }
 
 func (p PostgresContext) GetValidatorsReadyToUnstake(height int64, status int32) ([]modules.IUnstakingActor, error) {
@@ -79,7 +79,7 @@ func (p PostgresContext) SetValidatorPauseHeight(address []byte, height int64) e
 
 // TODO(team): The Get & Update operations need to be made atomic
 // TODO(team): Deprecate this functiona altogether and use UpdateValidator where applicable
-func (p PostgresContext) SetValidatorStakedTokens(address []byte, tokens string) error { //
+func (p PostgresContext) setValidatorStakedTokens(address []byte, tokens string) error {
 	height, err := p.GetHeight()
 	if err != nil {
 		return err
@@ -95,7 +95,7 @@ func (p PostgresContext) SetValidatorStakedTokens(address []byte, tokens string)
 	return p.UpdateValidator(addr, serviceURL, tokens)
 }
 
-func (p PostgresContext) GetValidatorStakedTokens(address []byte, height int64) (tokens string, err error) {
+func (p PostgresContext) getValidatorStakedTokens(address []byte, height int64) (tokens string, err error) {
 	_, _, tokens, _, _, _, _, err = p.GetValidator(address, height)
 	return
 }

From 131d08f9b48922beb78062429e486c6639016d6b Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 15 Nov 2022 15:09:44 -0800
Subject: [PATCH 174/227] Remove unnecessary critical sections

---
 shared/docs/PROTOCOL_STATE_HASH.md | 71 +++++++++++++++---------------
 1 file changed, 35 insertions(+), 36 deletions(-)

diff --git a/shared/docs/PROTOCOL_STATE_HASH.md b/shared/docs/PROTOCOL_STATE_HASH.md
index 229a103cd..3b7204ca1 100644
--- a/shared/docs/PROTOCOL_STATE_HASH.md
+++ b/shared/docs/PROTOCOL_STATE_HASH.md
@@ -29,24 +29,24 @@ sequenceDiagram
     participant P as Persistence
 
     %% Handle New Message
-    B-->>C: HandleMessage(msg)
-
-    critical NewRound
-        %% Create Contexts
-        C->>+U: NewContext(height)
-        U->>+P: NewRWContext(height)
-        P->>-U: PersistenceContext
-        U->>U: store context<br>locally
-        activate U
-        deactivate U
-        U->>-C: UtilityContext
-        C->>C: store context<br>locally
-        activate C
-        deactivate C
-
-        %% Apply Block
-        Note over C, P: See 'Block Application'
-    end
+    B-->>C: HandleMessage(NewRound)
+
+    %% NewRound
+
+    activate C
+    %% Create Contexts
+    C->>+U: NewContext(height)
+    U->>+P: NewRWContext(height)
+    P->>-U: PersistenceContext
+    U->>U: store context<br>locally
+    activate U
+    deactivate U
+    U->>-C: UtilityContext
+    C->>C: store context<br>locally
+    deactivate C
+
+    %% Apply Block
+    Note over C, P: See 'Block Application'
 ```
 
 5. The **HotPOKT lifecycle** takes place so Validators achieve consensus (i.e. steps `PRECOMMIT` and `COMMIT`)
@@ -65,25 +65,24 @@ sequenceDiagram
     participant P as Persistence
 
     %% Handle New Message
-    B-->>C: HandleMessage(msg)
-
-    critical Decide
-        %% Commit Context
-        C->>+U: Context.Commit(quorumCert)
-        U->>+P: Context.Commit(quorumCert)
-        P->>P: Internal Implementation
-        Note over P: Store Block
-        P->>-U: err_code
-        U->>C: err_code
-        deactivate U
-
-        %% Release Context
-        C->>+U: Context.Release()
-        U->>+P: Context.Release()
-        P->>-U: err_code
-        U->>-C: err_code
-    end
+    B-->>C: HandleMessage(Decide)
 
+    activate C
+    %% Commit Context
+    C->>+U: Context.Commit(quorumCert)
+    U->>+P: Context.Commit(quorumCert)
+    P->>P: Internal Implementation
+    Note over P: Store Block
+    P->>-U: err_code
+    U->>C: err_code
+    deactivate U
+
+    %% Release Context
+    C->>+U: Context.Release()
+    U->>+P: Context.Release()
+    P->>-U: err_code
+    U->>-C: err_code
+    deactivate C
 ```
 
 ## Block Application

From bc92358921f10d9eb1d7f04242160e1dbaffbb5b Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 15 Nov 2022 15:23:50 -0800
Subject: [PATCH 175/227] Minor updates in documentation

---
 shared/docs/PROTOCOL_STATE_HASH.md | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/shared/docs/PROTOCOL_STATE_HASH.md b/shared/docs/PROTOCOL_STATE_HASH.md
index 3b7204ca1..4f9899b62 100644
--- a/shared/docs/PROTOCOL_STATE_HASH.md
+++ b/shared/docs/PROTOCOL_STATE_HASH.md
@@ -29,9 +29,9 @@ sequenceDiagram
     participant P as Persistence
 
     %% Handle New Message
-    B-->>C: HandleMessage(NewRound)
+    B-->>C: HandleMessage(NEWROUND)
 
-    %% NewRound
+    %% NEWROUND
 
     activate C
     %% Create Contexts
@@ -46,26 +46,30 @@ sequenceDiagram
     deactivate C
 
     %% Apply Block
-    Note over C, P: See 'Block Application'
+    Note over C, P: 'Block Application'
 ```
 
-5. The **HotPOKT lifecycle** takes place so Validators achieve consensus (i.e. steps `PRECOMMIT` and `COMMIT`)
-6. The `Consensus` module handle the `DECIDE` message
-7. The final `quorumCertificate` is propagated to the `UtilityContext` on Commit
-8. The final `quorumCertificate` is propagated to the `PersistenceContext` on Commit
-9. The persistence module's internal implementation for [Store Block](../../persistence/docs/PROTOCOL_STATE_HASH.md) must execute.
-10. Both the `UtilityContext` and `PersistenceContext` are released
+---
+
+_The **Proposer** drives the **Validators** to agreement via the **Consensus Lifecycle** (i.e. HotPOKT)_
+
+---
+
+1. The `Consensus` module handles the `DECIDE` message
+2. The final `quorumCertificate` is propagated to the `UtilityContext` & `PersistenceContext` on Commit
+3. The persistence module's internal implementation for [Store Block](../../persistence/docs/PROTOCOL_STATE_HASH.md) must execute.
+4. Both the `UtilityContext` and `PersistenceContext` are released
 
 ```mermaid
 sequenceDiagram
-    title Steps 6-10
+    title Steps 5-8
     participant B as Bus
     participant C as Consensus
     participant U as Utility
     participant P as Persistence
 
     %% Handle New Message
-    B-->>C: HandleMessage(Decide)
+    B-->>C: HandleMessage(DECIDE)
 
     activate C
     %% Commit Context

From 53e7dfc099fcbc00e7bab77b5a9c015b577e55c9 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 15 Nov 2022 16:13:50 -0800
Subject: [PATCH 176/227] Removed Latest from function names

---
 persistence/block.go                 |  9 ++-------
 persistence/db.go                    | 12 ++++++------
 shared/docs/PROTOCOL_STATE_HASH.md   |  1 +
 shared/modules/persistence_module.go | 14 +++++++-------
 utility/block.go                     |  8 ++++----
 5 files changed, 20 insertions(+), 24 deletions(-)

diff --git a/persistence/block.go b/persistence/block.go
index 547afef29..d3c1b9125 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -7,7 +7,6 @@ import (
 
 	"github.com/pokt-network/pocket/persistence/kvstore"
 	"github.com/pokt-network/pocket/persistence/types"
-	"github.com/pokt-network/pocket/shared/modules"
 )
 
 // OPTIMIZE(team): get from blockstore or keep in memory
@@ -22,7 +21,7 @@ func (p PostgresContext) GetLatestBlockHeight() (latestHeight uint64, err error)
 }
 
 // OPTIMIZE(team): get from blockstore or keep in cache/memory
-func (p PostgresContext) GetBlockHash(height int64) ([]byte, error) {
+func (p PostgresContext) GetBlockHashAtHeight(height int64) ([]byte, error) {
 	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return nil, err
@@ -56,10 +55,6 @@ func (p PostgresContext) GetPrevAppHash() (string, error) {
 	return hex.EncodeToString(block), nil // TODO(#284): Return `block.Hash` instead of the hex encoded representation of the blockBz
 }
 
-func (p PostgresContext) GetTxResults() []modules.TxResult {
-	return p.txResults
-}
-
 func (p PostgresContext) TransactionExists(transactionHash string) (bool, error) {
 	hash, err := hex.DecodeString(transactionHash)
 	if err != nil {
@@ -78,7 +73,7 @@ func (p PostgresContext) TransactionExists(transactionHash string) (bool, error)
 
 func (p PostgresContext) indexTransactions() error {
 	// TODO: store in batch
-	for _, txResult := range p.GetLatestTxResults() {
+	for _, txResult := range p.GetTxResults() {
 		if err := p.txIndexer.Index(txResult); err != nil {
 			return err
 		}
diff --git a/persistence/db.go b/persistence/db.go
index ad148f790..0dddc7f4f 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -90,27 +90,27 @@ func (pg *PostgresContext) ResetContext() error {
 // 1. Can we remove `Latest` from these Setter & Getter methods
 // 2. Can we scope that to this package?
 // 3. Is `context.go` more appropriate for these than `db.go`?
-func (p PostgresContext) GetLatestProposerAddr() []byte {
+func (p PostgresContext) GetProposerAddr() []byte {
 	return p.proposerAddr
 }
 
-func (p PostgresContext) GetLatestBlockProtoBytes() []byte {
+func (p PostgresContext) GetBlockProtoBytes() []byte {
 	return p.blockProtoBytes
 }
 
-func (p PostgresContext) GetLatestBlockHash() string {
+func (p PostgresContext) GetBlockHash() string {
 	return p.blockHash
 }
 
-func (p PostgresContext) GetLatestBlockTxs() [][]byte {
+func (p PostgresContext) GetBlockTxs() [][]byte {
 	return p.blockTxs
 }
 
-func (p PostgresContext) GetLatestTxResults() []modules.TxResult {
+func (p PostgresContext) GetTxResults() []modules.TxResult {
 	return p.txResults
 }
 
-func (p *PostgresContext) SetLatestTxResults(txResults []modules.TxResult) {
+func (p *PostgresContext) SetTxResults(txResults []modules.TxResult) {
 	p.txResults = txResults
 }
 
diff --git a/shared/docs/PROTOCOL_STATE_HASH.md b/shared/docs/PROTOCOL_STATE_HASH.md
index 4f9899b62..9e7a8576c 100644
--- a/shared/docs/PROTOCOL_STATE_HASH.md
+++ b/shared/docs/PROTOCOL_STATE_HASH.md
@@ -165,6 +165,7 @@ sequenceDiagram
             end
         end
     end
+    %% TODO: Consolidate AppHash and StateHash
     U->>+P: UpdateAppHash()
     P->>P: Internal Implementation
     Note over P: Update state hash
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index 978408774..dc4af9366 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -44,7 +44,7 @@ type PersistenceRWContext interface {
 // - Use general purpose parameter methods such as `Set(enum_gov_type, ...)` such as `Set(STAKING_ADJUSTMENT, ...)`
 // - Reference: https://dave.cheney.net/practical-go/presentations/gophercon-israel.html#_prefer_single_method_interfaces
 
-// TOD (#149): convert address and public key to string from bytes
+// TECHDEBT: convert address and public key to string from bytes
 // NOTE: There's not really a use case for a write only interface, but it abstracts and contrasts nicely against the read only context
 type PersistenceWriteContext interface {
 	// Context Operations
@@ -59,7 +59,7 @@ type PersistenceWriteContext interface {
 
 	// Block Operations
 	// DISCUSS_IN_THIS_COMMIT: Can this function be removed ? If so, could we remove `TxResult` from the public facing interface given that we set transactions in `SetProposalBlock`?
-	SetLatestTxResults(txResults []TxResult)
+	SetTxResults(txResults []TxResult)
 	// TODO(#284): Remove `blockProtoBytes`
 	SetProposalBlock(blockHash string, blockProtoBytes, proposerAddr []byte, transactions [][]byte) error
 	// Store the block into persistence
@@ -128,12 +128,12 @@ type PersistenceReadContext interface {
 	// Block Queries
 	GetPrevAppHash() (string, error) // app hash from the previous block
 	GetLatestBlockHeight() (uint64, error)
-	GetBlockHash(height int64) ([]byte, error)
+	GetBlockHashAtHeight(height int64) ([]byte, error) // CONSOLIDATE: BlockHash / AppHash / StateHash
 	GetBlocksPerSession(height int64) (int, error)
-	GetLatestProposerAddr() []byte
-	GetLatestBlockProtoBytes() []byte
-	GetLatestBlockHash() string
-	GetLatestBlockTxs() [][]byte
+	GetProposerAddr() []byte
+	GetBlockProtoBytes() []byte
+	GetBlockHash() string
+	GetBlockTxs() [][]byte
 
 	// Indexer Queries
 	TransactionExists(transactionHash string) (bool, error)
diff --git a/utility/block.go b/utility/block.go
index f4954e219..f6f4c95d6 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -67,7 +67,7 @@ func (u *UtilityContext) CreateAndApplyProposalBlock(proposer []byte, maxTransac
 	if err := u.EndBlock(proposer); err != nil {
 		return nil, nil, err
 	}
-	u.GetPersistenceContext().SetLatestTxResults(txResults)
+	u.GetPersistenceContext().SetTxResults(txResults)
 	// return the app hash (consensus module will get the validator set directly)
 	appHash, err := u.GetAppHash()
 	return appHash, transactions, err
@@ -85,7 +85,7 @@ func (u *UtilityContext) ApplyBlock() (appHash []byte, err error) {
 		return nil, err
 	}
 	// deliver txs lifecycle phase
-	for index, transactionProtoBytes := range u.GetPersistenceContext().GetLatestBlockTxs() {
+	for index, transactionProtoBytes := range u.GetPersistenceContext().GetBlockTxs() {
 		tx, err := typesUtil.TransactionFromBytes(transactionProtoBytes)
 		if err != nil {
 			return nil, err
@@ -111,10 +111,10 @@ func (u *UtilityContext) ApplyBlock() (appHash []byte, err error) {
 		// }
 	}
 	// end block lifecycle phase
-	if err := u.EndBlock(u.GetPersistenceContext().GetLatestProposerAddr()); err != nil {
+	if err := u.EndBlock(u.GetPersistenceContext().GetProposerAddr()); err != nil {
 		return nil, err
 	}
-	u.GetPersistenceContext().SetLatestTxResults(txResults)
+	u.GetPersistenceContext().SetTxResults(txResults)
 	// return the app hash (consensus module will get the validator set directly)
 	appHash, err = u.GetAppHash()
 	return

From 1afbc784b9c44e90b00c2ea78d12e66f8bb76c9c Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 15 Nov 2022 16:22:41 -0800
Subject: [PATCH 177/227] Updating references documents

---
 persistence/db.go                    | 5 +----
 shared/docs/PROTOCOL_STATE_HASH.md   | 6 +++---
 shared/modules/persistence_module.go | 5 +++--
 3 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/persistence/db.go b/persistence/db.go
index 0dddc7f4f..7adde2595 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -86,10 +86,7 @@ func (pg *PostgresContext) ResetContext() error {
 	return nil
 }
 
-// DISCUSS:
-// 1. Can we remove `Latest` from these Setter & Getter methods
-// 2. Can we scope that to this package?
-// 3. Is `context.go` more appropriate for these than `db.go`?
+// DISCUSS: Given that these are context specific setters/getters, is `context.go` a more appropriate location for these than `db.go`?
 func (p PostgresContext) GetProposerAddr() []byte {
 	return p.proposerAddr
 }
diff --git a/shared/docs/PROTOCOL_STATE_HASH.md b/shared/docs/PROTOCOL_STATE_HASH.md
index 9e7a8576c..cc350ebcb 100644
--- a/shared/docs/PROTOCOL_STATE_HASH.md
+++ b/shared/docs/PROTOCOL_STATE_HASH.md
@@ -57,7 +57,7 @@ _The **Proposer** drives the **Validators** to agreement via the **Consensus Lif
 
 1. The `Consensus` module handles the `DECIDE` message
 2. The final `quorumCertificate` is propagated to the `UtilityContext` & `PersistenceContext` on Commit
-3. The persistence module's internal implementation for [Store Block](../../persistence/docs/PROTOCOL_STATE_HASH.md) must execute.
+3. The persistence module's internal implementation for ['Store Block'](../../persistence/docs/PROTOCOL_STORE_BLOCK.md) must execute.
 4. Both the `UtilityContext` and `PersistenceContext` are released
 
 ```mermaid
@@ -142,7 +142,7 @@ sequenceDiagram
 4. Loop over all transactions proposed
 5. Check if the transaction has already been applied to the local state
 6. Perform the CRUD operation(s) corresponding to each transaction
-7. The persistence module's internal implementation for [Updating a State hash](../../persistence/docs/PROTOCOL_STATE_HASH.md) must be triggered
+7. The persistence module's internal implementation for ['Update State Hash'](../../persistence/docs/PROTOCOL_STATE_HASH.md) must be triggered
 8. Validate that the local state hash computed is the same as that proposed
 
 ```mermaid
@@ -168,7 +168,7 @@ sequenceDiagram
     %% TODO: Consolidate AppHash and StateHash
     U->>+P: UpdateAppHash()
     P->>P: Internal Implementation
-    Note over P: Update state hash
+    Note over P: Update State Hash
     P->>-U: stateHash
     U->>C: stateHash
 
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index dc4af9366..ab29178ff 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -125,10 +125,11 @@ type PersistenceReadContext interface {
 	// Closes the read context
 	Close() error
 
+	// CONSOLIDATE: BlockHash / AppHash / StateHash
 	// Block Queries
-	GetPrevAppHash() (string, error) // app hash from the previous block
+	GetPrevAppHash() (string, error) // hash from the previous block relative to the context height
 	GetLatestBlockHeight() (uint64, error)
-	GetBlockHashAtHeight(height int64) ([]byte, error) // CONSOLIDATE: BlockHash / AppHash / StateHash
+	GetBlockHashAtHeight(height int64) ([]byte, error)
 	GetBlocksPerSession(height int64) (int, error)
 	GetProposerAddr() []byte
 	GetBlockProtoBytes() []byte

From 7e9327226801148636faf307e80e8eb819272918 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 15 Nov 2022 16:34:49 -0800
Subject: [PATCH 178/227] Replace true | false with just false to simplify
 diagram

---
 shared/docs/PROTOCOL_STATE_HASH.md | 16 +++++++---------
 shared/modules/utility_module.go   |  1 -
 utility/block.go                   |  2 ++
 3 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/shared/docs/PROTOCOL_STATE_HASH.md b/shared/docs/PROTOCOL_STATE_HASH.md
index cc350ebcb..94a17813b 100644
--- a/shared/docs/PROTOCOL_STATE_HASH.md
+++ b/shared/docs/PROTOCOL_STATE_HASH.md
@@ -154,15 +154,13 @@ sequenceDiagram
 
     loop for each tx in txs
         U->>+P: TransactionExists(txHash)
-        P->>-U: true | false
-        opt if tx is not indexed
-            loop for each operation in tx
-                U->>+P: Get*/Set*/Update*/Insert*
-                P->>-U: err_code
-                U->>U: Validation logic
-                activate U
-                deactivate U
-            end
+        P->>-U: false (does not exist)
+        loop for each operation in tx
+            U->>+P: Get*/Set*/Update*/Insert*
+            P->>-U: err_code
+            U->>U: Validation logic
+            activate U
+            deactivate U
         end
     end
     %% TODO: Consolidate AppHash and StateHash
diff --git a/shared/modules/utility_module.go b/shared/modules/utility_module.go
index 7bb143af9..67705638f 100644
--- a/shared/modules/utility_module.go
+++ b/shared/modules/utility_module.go
@@ -29,7 +29,6 @@ type UtilityContext interface {
 	GetPersistenceContext() PersistenceRWContext
 
 	// Validation operations
-
 	CheckTransaction(tx []byte) error
 }
 
diff --git a/utility/block.go b/utility/block.go
index f6f4c95d6..a1f7f7394 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -19,6 +19,7 @@ import (
 	operation that executes at the end of every block.
 */
 
+// TODO: Make sure to call `utility.CheckTransaction`, which calls `persistence.TransactionExists`
 func (u *UtilityContext) CreateAndApplyProposalBlock(proposer []byte, maxTransactionBytes int) ([]byte, [][]byte, error) {
 	lastBlockByzantineVals, err := u.GetLastBlockByzantineValidators()
 	if err != nil {
@@ -73,6 +74,7 @@ func (u *UtilityContext) CreateAndApplyProposalBlock(proposer []byte, maxTransac
 	return appHash, transactions, err
 }
 
+// TODO: Make sure to call `utility.CheckTransaction`, which calls `persistence.TransactionExists`
 // CLEANUP: code re-use ApplyBlock() for CreateAndApplyBlock()
 func (u *UtilityContext) ApplyBlock() (appHash []byte, err error) {
 	var txResults []modules.TxResult

From c1f5151920e900b87a7cdec949870ae65cccdd06 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 15 Nov 2022 16:39:18 -0800
Subject: [PATCH 179/227] Updated the consensus changelog

---
 consensus/CHANGELOG.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/consensus/CHANGELOG.md b/consensus/CHANGELOG.md
index 9a254aaf7..2795635f8 100644
--- a/consensus/CHANGELOG.md
+++ b/consensus/CHANGELOG.md
@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.0.8] - 2022-11-15
+
+- Propagate the `quorumCertificate` on `Block` commit to the `Utility` module
+- Slightly improved error handling of the `utilityContext` lifecycle management
+
 ## [0.0.0.7] - 2022-11-01
 
 - Removed `apphash` and `txResults` from `consensusModule` structure

From 00c53789187db3d31b46da3a10b1d1f76c2b7d51 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 15 Nov 2022 16:42:45 -0800
Subject: [PATCH 180/227] Updated the persistence changelog

---
 persistence/CHANGELOG.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/persistence/CHANGELOG.md b/persistence/CHANGELOG.md
index a4d496c49..a22f7a916 100644
--- a/persistence/CHANGELOG.md
+++ b/persistence/CHANGELOG.md
@@ -9,6 +9,16 @@ TODO: consolidate `persistence/docs/CHANGELOG` and `persistence/CHANGELOG.md`
 
 ## [Unreleased]
 
+## [0.0.0.8] - 2022-11-15
+
+- Rename `GetBlockHash` to `GetBlockHashAtHeight`
+- Reduce visibility scope of `IndexTransactions` to `indexTransactions`
+- Remove `quorumCertificate` from the local context state
+- Remove `LatestQC` and `SetLatestQC`
+- Remove `Latest` prefix from several functions including related to setting context of the proposal block
+- Added `ReleaseWriteContext` placeholder
+- Replaced `ResetContext` with `Release`
+
 ## [0.0.0.7] - 2022-11-01
 
 - Ported over storing blocks and block components to the Persistence module from Consensus and Utility modules

From 6c41701f537cb5725d484abfd6a8cee2684501dd Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 15 Nov 2022 16:44:03 -0800
Subject: [PATCH 181/227] Fix numbering in the README

---
 shared/docs/PROTOCOL_STATE_HASH.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/shared/docs/PROTOCOL_STATE_HASH.md b/shared/docs/PROTOCOL_STATE_HASH.md
index 94a17813b..327acdae2 100644
--- a/shared/docs/PROTOCOL_STATE_HASH.md
+++ b/shared/docs/PROTOCOL_STATE_HASH.md
@@ -55,10 +55,10 @@ _The **Proposer** drives the **Validators** to agreement via the **Consensus Lif
 
 ---
 
-1. The `Consensus` module handles the `DECIDE` message
-2. The final `quorumCertificate` is propagated to the `UtilityContext` & `PersistenceContext` on Commit
-3. The persistence module's internal implementation for ['Store Block'](../../persistence/docs/PROTOCOL_STORE_BLOCK.md) must execute.
-4. Both the `UtilityContext` and `PersistenceContext` are released
+5. The `Consensus` module handles the `DECIDE` message
+6. The final `quorumCertificate` is propagated to the `UtilityContext` & `PersistenceContext` on `Commit`
+7. The persistence module's internal implementation for ['Store Block'](../../persistence/docs/PROTOCOL_STORE_BLOCK.md) must execute.
+8. Both the `UtilityContext` and `PersistenceContext` are released
 
 ```mermaid
 sequenceDiagram

From 8353e7041cd5227d97e3546f02a3402387325b71 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 15 Nov 2022 16:49:03 -0800
Subject: [PATCH 182/227] Updated shared/modules changelog

---
 shared/modules/doc/CHANGELOG.md | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/shared/modules/doc/CHANGELOG.md b/shared/modules/doc/CHANGELOG.md
index 3a47a7671..4312d25c9 100644
--- a/shared/modules/doc/CHANGELOG.md
+++ b/shared/modules/doc/CHANGELOG.md
@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.0.3] - 2022-11-15
+
+PersistenceModule
+
+- Added `ReleaseWriteContext`
+- Consolidated `ResetContext`, `Reset` with `Release`
+- Modified `Commit` to accept a `quorumCert`
+- Removed `Latest` prefix from getters related to the proposal block parameters
+
+UtilityModule
+
+- Changed `CommitPersistenceContext()` to `Commit(quorumCert)`
+- Changed `ReleaseContext` to `Release`
+
 ## [0.0.0.2] - 2022-10-12
 
 - Modified interface for Utility Module `ApplyBlock` and `GetProposalTransactions` to return `TxResults`

From 4564c32540b8ae4c009cd7c65fe53e94f43d8a5b Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 15 Nov 2022 16:50:39 -0800
Subject: [PATCH 183/227] Updated utility changelog

---
 utility/doc/CHANGELOG.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/utility/doc/CHANGELOG.md b/utility/doc/CHANGELOG.md
index 8df4d2c55..551eec1c8 100644
--- a/utility/doc/CHANGELOG.md
+++ b/utility/doc/CHANGELOG.md
@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.0.10] - 2022-11-15
+
+- Propagating the `quorumCertificate` appropriately on block commit
+- Removed `Latest` from getters related to retrieving the context of the proposed block
+
 ## [0.0.0.9] - 2022-11-01
 
 - Remove `TxResult` from the utility module interface (added in TxIndexer integration of transaction indexer (issue-#168) #302)

From 9ce3f4fcf79e941878bd4448392d95561054a0c1 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 15 Nov 2022 18:36:04 -0800
Subject: [PATCH 184/227] Merged with main

---
 .github/CODEOWNERS                       |   2 -
 .gitignore                               |   2 +-
 consensus/CHANGELOG.md                   |   5 +
 docs/development/FAQ.md                  |  10 ++
 persistence/CHANGELOG.md                 |  12 +++
 persistence/account.go                   |  19 ++--
 persistence/application.go               |  13 +--
 persistence/block.go                     |   6 +-
 persistence/db.go                        |  45 +++++++--
 persistence/debug.go                     |   2 +-
 persistence/docs/CHANGELOG.md            |  34 +++++++
 persistence/fisherman.go                 |   6 +-
 persistence/genesis.go                   |  32 +++----
 persistence/gov.go                       |   6 +-
 persistence/service_node.go              |   6 +-
 persistence/shared_sql.go                |  46 +++++-----
 persistence/state.go                     |   2 +-
 persistence/test/application_test.go     |   4 +-
 persistence/test/fisherman_test.go       |   4 +-
 persistence/test/generic_test.go         |   4 +-
 persistence/test/service_node_test.go    |   4 +-
 persistence/test/validator_test.go       |   4 +-
 persistence/types/account.go             |  18 ++--
 persistence/types/base_actor.go          |  19 ++--
 persistence/types/gov.go                 |   3 -
 persistence/types/persistence_genesis.go |   6 +-
 persistence/types/shared_sql.go          |  20 ++--
 persistence/validator.go                 |  10 +-
 shared/docs/PROTOCOL_STATE_HASH.md       | 112 ++++++++++++-----------
 shared/modules/doc/CHANGELOG.md          |  14 +++
 shared/modules/persistence_module.go     |   7 +-
 shared/modules/utility_module.go         |   1 -
 utility/block.go                         |  10 +-
 utility/doc/CHANGELOG.md                 |   5 +
 34 files changed, 294 insertions(+), 199 deletions(-)
 delete mode 100644 .github/CODEOWNERS
 create mode 100644 docs/development/FAQ.md

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
deleted file mode 100644
index 2c67bc701..000000000
--- a/.github/CODEOWNERS
+++ /dev/null
@@ -1,2 +0,0 @@
-# Default Reviewers for all PRs
-*     @pokt-network/engineering-member
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 21f9eb7f9..60287a9e5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -58,4 +58,4 @@ rpc/server.gen.go
 rpc/client.gen.go
 
 # Ignored generated files by build/config/main.go
-build/config/gen*.json
+build/config/gen*.json
\ No newline at end of file
diff --git a/consensus/CHANGELOG.md b/consensus/CHANGELOG.md
index 9a254aaf7..2795635f8 100644
--- a/consensus/CHANGELOG.md
+++ b/consensus/CHANGELOG.md
@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.0.8] - 2022-11-15
+
+- Propagate the `quorumCertificate` on `Block` commit to the `Utility` module
+- Slightly improved error handling of the `utilityContext` lifecycle management
+
 ## [0.0.0.7] - 2022-11-01
 
 - Removed `apphash` and `txResults` from `consensusModule` structure
diff --git a/docs/development/FAQ.md b/docs/development/FAQ.md
new file mode 100644
index 000000000..c1b9e65bb
--- /dev/null
+++ b/docs/development/FAQ.md
@@ -0,0 +1,10 @@
+# FAQ
+
+A list of common issues & resolutions shared by the V1 contributors
+
+## Avoid redundant files from iCloud backup
+
+* **Issue**: when working on MacOS with iCloud backup turned on, redundant files could be generated in GitHub projects. (e.g. `file.go` and `file 2.go`) Details can be found here in [this link](https://stackoverflow.com/a/62387243). 
+* **Solution**: adding `.nosync` as suffix to the workspace folder, e.g. `pocket.nosync`. Alternative, working in a folder that iCloud doesn't touch also works.
+
+_NOTE: Consider turning of the `gofmt` in your IDE to prevent unexpected formatting_
\ No newline at end of file
diff --git a/persistence/CHANGELOG.md b/persistence/CHANGELOG.md
index e893f8919..a22f7a916 100644
--- a/persistence/CHANGELOG.md
+++ b/persistence/CHANGELOG.md
@@ -5,8 +5,20 @@ All notable changes to this module will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+TODO: consolidate `persistence/docs/CHANGELOG` and `persistence/CHANGELOG.md`
+
 ## [Unreleased]
 
+## [0.0.0.8] - 2022-11-15
+
+- Rename `GetBlockHash` to `GetBlockHashAtHeight`
+- Reduce visibility scope of `IndexTransactions` to `indexTransactions`
+- Remove `quorumCertificate` from the local context state
+- Remove `LatestQC` and `SetLatestQC`
+- Remove `Latest` prefix from several functions including related to setting context of the proposal block
+- Added `ReleaseWriteContext` placeholder
+- Replaced `ResetContext` with `Release`
+
 ## [0.0.0.7] - 2022-11-01
 
 - Ported over storing blocks and block components to the Persistence module from Consensus and Utility modules
diff --git a/persistence/account.go b/persistence/account.go
index feac02075..c0ad6311d 100644
--- a/persistence/account.go
+++ b/persistence/account.go
@@ -23,7 +23,7 @@ func (p PostgresContext) GetAccountAmount(address []byte, height int64) (amount
 }
 
 func (p PostgresContext) getAccountAmountStr(address string, height int64) (amount string, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return
 	}
@@ -51,9 +51,9 @@ func (p PostgresContext) SubtractAccountAmount(address []byte, amount string) er
 }
 
 // DISCUSS(team): If we are okay with `GetAccountAmount` return 0 as a default, this function can leverage
-//                `operationAccountAmount` with `*orig = *delta` and make everything much simpler.
+// `operationAccountAmount` with `*orig = *delta` and make everything much simpler.
 func (p PostgresContext) SetAccountAmount(address []byte, amount string) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -80,7 +80,7 @@ func (p *PostgresContext) operationAccountAmount(address []byte, deltaAmount str
 
 // TODO(andrew): remove address param
 func (p PostgresContext) InsertPool(name string, address []byte, amount string) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -95,7 +95,7 @@ func (p PostgresContext) InsertPool(name string, address []byte, amount string)
 }
 
 func (p PostgresContext) GetPoolAmount(name string, height int64) (amount string, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return
 	}
@@ -128,7 +128,7 @@ func (p PostgresContext) SubtractPoolAmount(name string, amount string) error {
 //
 // DISCUSS(team): Do we have a use-case for this function?
 func (p PostgresContext) SetPoolAmount(name string, amount string) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -155,7 +155,7 @@ func (p PostgresContext) GetPoolsUpdated(height int64) ([]*types.Account, error)
 // Helper for shared logic between `getPoolsUpdated` and `getAccountsUpdated` while keeping an explicit
 // external interface.
 func (p *PostgresContext) getPoolOrAccUpdatedInternal(query string) (accounts []*types.Account, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return
 	}
@@ -181,9 +181,8 @@ func (p *PostgresContext) operationPoolOrAccAmount(
 	name, amount string,
 	op func(*big.Int, *big.Int) error,
 	getAmount func(string, int64) (string, error),
-	insert func(name, amount string, height int64) string,
-) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	insert func(name, amount string, height int64) string) error {
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
diff --git a/persistence/application.go b/persistence/application.go
index 23081fd98..010150896 100644
--- a/persistence/application.go
+++ b/persistence/application.go
@@ -2,8 +2,6 @@ package persistence
 
 import (
 	"encoding/hex"
-	"log"
-
 	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/modules"
 )
@@ -13,7 +11,7 @@ func (p PostgresContext) GetAppExists(address []byte, height int64) (exists bool
 }
 
 func (p PostgresContext) GetApp(address []byte, height int64) (operator, publicKey, stakedTokens, maxRelays, outputAddress string, pauseHeight, unstakingHeight int64, chains []string, err error) {
-	actor, err := p.GetActor(types.ApplicationActor, address, height)
+	actor, err := p.getActor(types.ApplicationActor, address, height)
 	if err != nil {
 		return
 	}
@@ -53,16 +51,11 @@ func (p PostgresContext) UpdateApp(address []byte, maxRelays string, stakedAmoun
 }
 
 func (p PostgresContext) GetAppStakeAmount(height int64, address []byte) (string, error) {
-	return p.GetActorStakeAmount(types.ApplicationActor, address, height)
+	return p.getActorStakeAmount(types.ApplicationActor, address, height)
 }
 
 func (p PostgresContext) SetAppStakeAmount(address []byte, stakeAmount string) error {
-	return p.SetActorStakeAmount(types.ApplicationActor, address, stakeAmount)
-}
-
-func (p PostgresContext) DeleteApp(_ []byte) error {
-	log.Println("[DEBUG] DeleteApp is a NOOP")
-	return nil
+	return p.setActorStakeAmount(types.ApplicationActor, address, stakeAmount)
 }
 
 func (p PostgresContext) GetAppsReadyToUnstake(height int64, _ int32) ([]modules.IUnstakingActor, error) {
diff --git a/persistence/block.go b/persistence/block.go
index f6e0657d4..7197269c9 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -18,7 +18,7 @@ const (
 
 // OPTIMIZE(team): get from blockstore or keep in memory
 func (p PostgresContext) GetLatestBlockHeight() (latestHeight uint64, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return 0, err
 	}
@@ -29,7 +29,7 @@ func (p PostgresContext) GetLatestBlockHeight() (latestHeight uint64, err error)
 
 // OPTIMIZE: get from blockstore or keep in cache/memory
 func (p PostgresContext) GetBlockHash(height int64) ([]byte, error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return nil, err
 	}
@@ -106,7 +106,7 @@ func (p *PostgresContext) prepareBlock(quorumCert []byte) (*types.Block, error)
 
 // Inserts the block into the postgres database
 func (p *PostgresContext) insertBlock(block *types.Block) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
diff --git a/persistence/db.go b/persistence/db.go
index ef4151a14..a9baa9ae0 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log"
 
 	"github.com/jackc/pgconn"
 	"github.com/jackc/pgx/v4"
@@ -53,9 +54,10 @@ type PostgresContext struct {
 	quorumCert   []byte
 	blockHash    string // CONSOLIDATE: blockHash / appHash / stateHash
 	blockTxs     [][]byte
+	// txResults    []modules.TxResult // TODO_IN_THIS_COMMIT: FIX THIS. Not indexed by `txIndexer` until commit.
 }
 
-func (pg *PostgresContext) GetCtxAndTx() (context.Context, pgx.Tx, error) {
+func (pg *PostgresContext) getCtxAndTx() (context.Context, pgx.Tx, error) {
 	return context.TODO(), pg.GetTx(), nil
 }
 
@@ -63,23 +65,48 @@ func (pg *PostgresContext) GetTx() pgx.Tx {
 	return pg.tx
 }
 
-func (pg *PostgresContext) GetCtx() (context.Context, error) {
+func (pg *PostgresContext) getCtx() (context.Context, error) {
 	return context.TODO(), nil
 }
 
-// DISCUSS_IN_THIS_COMMIT:
-// 1. Can we remove these Getters/Setters
-// 2. Can we remove `Latest` from these Setter & Getter methods?
-// 3. Can we downscope them to this package only and remove from the interface?
-// 4. If we keep them, is `context.go` more appropriate for these than `db.go`?
-func (p PostgresContext) GetLatestProposerAddr() []byte {
+func (pg *PostgresContext) ResetContext() error {
+	if pg == nil {
+		return nil
+	}
+	tx := pg.GetTx()
+	if tx == nil {
+		return nil
+	}
+	conn := tx.Conn()
+	if conn == nil {
+		return nil
+	}
+	if !conn.IsClosed() {
+		if err := pg.Release(); err != nil {
+			log.Println("[TODO][ERROR] Error releasing write context...", err)
+		}
+	}
+	pg.tx = nil
+	return nil
+}
+
+// DISCUSS: Given that these are context specific setters/getters, is `context.go` a more appropriate location for these than `db.go`?
+func (p PostgresContext) GetProposerAddr() []byte {
 	return p.proposerAddr
 }
 
-func (p PostgresContext) GetLatestBlockTxs() [][]byte {
+func (p PostgresContext) GetBlockTxs() [][]byte {
 	return p.blockTxs
 }
 
+// func (p PostgresContext) GetTxResults() []modules.TxResult {
+// 	return p.txResults
+// }
+
+// func (p *PostgresContext) SetTxResults(txResults []modules.TxResult) {
+// 	p.txResults = txResults
+// }
+
 // TECHDEBT: Implement proper connection pooling
 func connectToDatabase(postgresUrl string, schema string) (*pgx.Conn, error) {
 	ctx := context.TODO()
diff --git a/persistence/debug.go b/persistence/debug.go
index 40ab62c63..bf463ce3f 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -92,7 +92,7 @@ func (m *persistenceModule) clearAllState(_ *debug.DebugMessage) error {
 }
 
 func (p *PostgresContext) clearAllSQLState() error {
-	ctx, clearTx, err := p.GetCtxAndTx()
+	ctx, clearTx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
diff --git a/persistence/docs/CHANGELOG.md b/persistence/docs/CHANGELOG.md
index 47e27c417..b18fd21ee 100644
--- a/persistence/docs/CHANGELOG.md
+++ b/persistence/docs/CHANGELOG.md
@@ -5,8 +5,42 @@ All notable changes to this module will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+TODO: consolidate `persistence/docs/CHANGELOG` and `persistence/CHANGELOG.md`
+
 ## [Unreleased]
 
+## [0.0.0.9] - 2022-11-08
+
+- Changed the following exported functions to lowercase non-exported functions
+- [./pocket/persistence/]
+  - GetActor
+  - GetActorFromRow
+  - GetChainsForActor
+  - SetActorStakeAmount
+  - GetActorStakeAmount
+  - GetCtxAndTx
+  - GetCtx
+  - SetValidatorStakedTokens
+  - GetValidatorStakedTokens
+- [./pocket/persistence/types]
+  - ProtocolActorTableSchema
+  - ProtocolActorChainsTableSchema
+  - SelectChains
+  - ReadyToUnstake
+  - InsertChains
+  - UpdateUnstakingHeight
+  - UpdateStakeAmount
+  - UpdatePausedHeight
+  - UpdateUnstakedHeightIfPausedBefore
+  - AccToAccInterface
+  - TestInsertParams
+  - AccountOrPoolSchema
+  - InsertAcc
+  - SelectBalance
+- [./pocket/persistence/test]
+  - GetGenericActor
+  - NewTestGenericActor
+
 ## [0.0.0.8] - 2022-10-19
 
 - Fixed `ToPersistenceActors()` by filling all structure fields
diff --git a/persistence/fisherman.go b/persistence/fisherman.go
index 5a3105c84..deb079c50 100644
--- a/persistence/fisherman.go
+++ b/persistence/fisherman.go
@@ -12,7 +12,7 @@ func (p PostgresContext) GetFishermanExists(address []byte, height int64) (exist
 }
 
 func (p PostgresContext) GetFisherman(address []byte, height int64) (operator, publicKey, stakedTokens, serviceURL, outputAddress string, pausedHeight, unstakingHeight int64, chains []string, err error) {
-	actor, err := p.GetActor(types.FishermanActor, address, height)
+	actor, err := p.getActor(types.FishermanActor, address, height)
 	operator = actor.Address
 	publicKey = actor.PublicKey
 	stakedTokens = actor.StakedAmount
@@ -49,11 +49,11 @@ func (p PostgresContext) UpdateFisherman(address []byte, serviceURL string, stak
 }
 
 func (p PostgresContext) GetFishermanStakeAmount(height int64, address []byte) (string, error) {
-	return p.GetActorStakeAmount(types.FishermanActor, address, height)
+	return p.getActorStakeAmount(types.FishermanActor, address, height)
 }
 
 func (p PostgresContext) SetFishermanStakeAmount(address []byte, stakeAmount string) error {
-	return p.SetActorStakeAmount(types.FishermanActor, address, stakeAmount)
+	return p.setActorStakeAmount(types.FishermanActor, address, stakeAmount)
 }
 
 func (p PostgresContext) GetFishermenReadyToUnstake(height int64, status int32) ([]modules.IUnstakingActor, error) {
diff --git a/persistence/genesis.go b/persistence/genesis.go
index 0473d2edb..1b396e2c4 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -164,12 +164,10 @@ func (m *persistenceModule) populateGenesisState(state modules.PersistenceGenesi
 }
 
 // TODO(pocket/issues/149): All of the functions below following a structure similar to `GetAll<Actor>`
-//
 //	can easily be refactored and condensed into a single function using a generic type or a common
-//
-// interface.
+//  interface.
 func (p PostgresContext) GetAllAccounts(height int64) (accs []modules.Account, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return nil, err
 	}
@@ -193,7 +191,7 @@ func (p PostgresContext) GetAllAccounts(height int64) (accs []modules.Account, e
 
 // CLEANUP: Consolidate with GetAllAccounts.
 func (p PostgresContext) GetAllPools(height int64) (accs []modules.Account, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return nil, err
 	}
@@ -212,7 +210,7 @@ func (p PostgresContext) GetAllPools(height int64) (accs []modules.Account, err
 }
 
 func (p PostgresContext) GetAllApps(height int64) (apps []modules.Actor, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return nil, err
 	}
@@ -223,7 +221,7 @@ func (p PostgresContext) GetAllApps(height int64) (apps []modules.Actor, err err
 	var actors []*types.Actor
 	for rows.Next() {
 		var actor *types.Actor
-		actor, height, err = p.GetActorFromRow(rows)
+		actor, height, err = p.getActorFromRow(rows)
 		if err != nil {
 			return
 		}
@@ -231,7 +229,7 @@ func (p PostgresContext) GetAllApps(height int64) (apps []modules.Actor, err err
 	}
 	rows.Close()
 	for _, actor := range actors {
-		actorWithChains, err := p.GetChainsForActor(ctx, tx, types.ApplicationActor, actor, height)
+		actorWithChains, err := p.getChainsForActor(ctx, tx, types.ApplicationActor, actor, height)
 		if err != nil {
 			return nil, err
 		}
@@ -241,7 +239,7 @@ func (p PostgresContext) GetAllApps(height int64) (apps []modules.Actor, err err
 }
 
 func (p PostgresContext) GetAllValidators(height int64) (vals []modules.Actor, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return nil, err
 	}
@@ -252,7 +250,7 @@ func (p PostgresContext) GetAllValidators(height int64) (vals []modules.Actor, e
 	var actors []*types.Actor
 	for rows.Next() {
 		var actor *types.Actor
-		actor, height, err = p.GetActorFromRow(rows)
+		actor, height, err = p.getActorFromRow(rows)
 		if err != nil {
 			return
 		}
@@ -260,7 +258,7 @@ func (p PostgresContext) GetAllValidators(height int64) (vals []modules.Actor, e
 	}
 	rows.Close()
 	for _, actor := range actors {
-		actor, err = p.GetChainsForActor(ctx, tx, types.ApplicationActor, actor, height)
+		actor, err = p.getChainsForActor(ctx, tx, types.ApplicationActor, actor, height)
 		if err != nil {
 			return
 		}
@@ -270,7 +268,7 @@ func (p PostgresContext) GetAllValidators(height int64) (vals []modules.Actor, e
 }
 
 func (p PostgresContext) GetAllServiceNodes(height int64) (sn []modules.Actor, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return nil, err
 	}
@@ -281,7 +279,7 @@ func (p PostgresContext) GetAllServiceNodes(height int64) (sn []modules.Actor, e
 	var actors []*types.Actor
 	for rows.Next() {
 		var actor *types.Actor
-		actor, height, err = p.GetActorFromRow(rows)
+		actor, height, err = p.getActorFromRow(rows)
 		if err != nil {
 			return
 		}
@@ -289,7 +287,7 @@ func (p PostgresContext) GetAllServiceNodes(height int64) (sn []modules.Actor, e
 	}
 	rows.Close()
 	for _, actor := range actors {
-		actor, err = p.GetChainsForActor(ctx, tx, types.ServiceNodeActor, actor, height)
+		actor, err = p.getChainsForActor(ctx, tx, types.ServiceNodeActor, actor, height)
 		if err != nil {
 			return
 		}
@@ -299,7 +297,7 @@ func (p PostgresContext) GetAllServiceNodes(height int64) (sn []modules.Actor, e
 }
 
 func (p PostgresContext) GetAllFishermen(height int64) (f []modules.Actor, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return nil, err
 	}
@@ -310,7 +308,7 @@ func (p PostgresContext) GetAllFishermen(height int64) (f []modules.Actor, err e
 	var actors []*types.Actor
 	for rows.Next() {
 		var actor *types.Actor
-		actor, height, err = p.GetActorFromRow(rows)
+		actor, height, err = p.getActorFromRow(rows)
 		if err != nil {
 			return
 		}
@@ -318,7 +316,7 @@ func (p PostgresContext) GetAllFishermen(height int64) (f []modules.Actor, err e
 	}
 	rows.Close()
 	for _, actor := range actors {
-		actor, err = p.GetChainsForActor(ctx, tx, types.FishermanActor, actor, height)
+		actor, err = p.getChainsForActor(ctx, tx, types.FishermanActor, actor, height)
 		if err != nil {
 			return
 		}
diff --git a/persistence/gov.go b/persistence/gov.go
index 09d049143..83a5fbd27 100644
--- a/persistence/gov.go
+++ b/persistence/gov.go
@@ -27,7 +27,7 @@ func (p PostgresContext) GetServiceNodesPerSessionAt(height int64) (int, error)
 }
 
 func (p PostgresContext) InitParams() error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -97,7 +97,7 @@ func (p PostgresContext) setParamOrFlag(name string, value any, enabled *bool) e
 // setParamOrFlag sets a param or a flag.
 // If `enabled` is nil, we are dealing with a param, otherwise it's a flag
 func setParamOrFlag[T types.SupportedParamTypes](p PostgresContext, paramName string, paramValue T, enabled *bool) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -116,7 +116,7 @@ func setParamOrFlag[T types.SupportedParamTypes](p PostgresContext, paramName st
 }
 
 func getParamOrFlag[T int | string | []byte](p PostgresContext, tableName, paramName string, height int64) (i T, enabled bool, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return i, enabled, err
 	}
diff --git a/persistence/service_node.go b/persistence/service_node.go
index bbb537264..e217db649 100644
--- a/persistence/service_node.go
+++ b/persistence/service_node.go
@@ -12,7 +12,7 @@ func (p PostgresContext) GetServiceNodeExists(address []byte, height int64) (exi
 }
 
 func (p PostgresContext) GetServiceNode(address []byte, height int64) (operator, publicKey, stakedTokens, serviceURL, outputAddress string, pausedHeight, unstakingHeight int64, chains []string, err error) {
-	actor, err := p.GetActor(types.ServiceNodeActor, address, height)
+	actor, err := p.getActor(types.ServiceNodeActor, address, height)
 	operator = actor.Address
 	publicKey = actor.PublicKey
 	stakedTokens = actor.StakedAmount
@@ -49,11 +49,11 @@ func (p PostgresContext) UpdateServiceNode(address []byte, serviceURL string, st
 }
 
 func (p PostgresContext) GetServiceNodeStakeAmount(height int64, address []byte) (string, error) {
-	return p.GetActorStakeAmount(types.ServiceNodeActor, address, height)
+	return p.getActorStakeAmount(types.ServiceNodeActor, address, height)
 }
 
 func (p PostgresContext) SetServiceNodeStakeAmount(address []byte, stakeAmount string) error {
-	return p.SetActorStakeAmount(types.ServiceNodeActor, address, stakeAmount)
+	return p.setActorStakeAmount(types.ServiceNodeActor, address, stakeAmount)
 }
 
 func (p PostgresContext) GetServiceNodeCount(chain string, height int64) (int, error) {
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
index 6936d9659..b81e58b04 100644
--- a/persistence/shared_sql.go
+++ b/persistence/shared_sql.go
@@ -32,7 +32,7 @@ func UnstakingHeightToStatus(unstakingHeight int64) int32 {
 }
 
 func (p *PostgresContext) GetExists(actorSchema types.ProtocolActorSchema, address []byte, height int64) (exists bool, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return
 	}
@@ -44,8 +44,8 @@ func (p *PostgresContext) GetExists(actorSchema types.ProtocolActorSchema, addre
 	return
 }
 
-func (p *PostgresContext) GetActorsUpdated(actorSchema types.ProtocolActorSchema, height int64) (actors []*types.Actor, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+func (p *PostgresContext) getActorsUpdated(actorSchema types.ProtocolActorSchema, height int64) (actors []*types.Actor, err error) {
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return
 	}
@@ -72,7 +72,7 @@ func (p *PostgresContext) GetActorsUpdated(actorSchema types.ProtocolActorSchema
 
 	actors = make([]*types.Actor, len(addrs))
 	for i, addr := range addrs {
-		actor, err := p.GetActor(actorSchema, addr, height)
+		actor, err := p.getActor(actorSchema, addr, height)
 		if err != nil {
 			return nil, err
 		}
@@ -82,20 +82,20 @@ func (p *PostgresContext) GetActorsUpdated(actorSchema types.ProtocolActorSchema
 	return
 }
 
-func (p *PostgresContext) GetActor(actorSchema types.ProtocolActorSchema, address []byte, height int64) (actor *types.Actor, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+func (p *PostgresContext) getActor(actorSchema types.ProtocolActorSchema, address []byte, height int64) (actor *types.Actor, err error) {
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return
 	}
-	actor, height, err = p.GetActorFromRow(tx.QueryRow(ctx, actorSchema.GetQuery(hex.EncodeToString(address), height)))
+	actor, height, err = p.getActorFromRow(tx.QueryRow(ctx, actorSchema.GetQuery(hex.EncodeToString(address), height)))
 	if err != nil {
 		return
 	}
 
-	return p.GetChainsForActor(ctx, tx, actorSchema, actor, height)
+	return p.getChainsForActor(ctx, tx, actorSchema, actor, height)
 }
 
-func (p *PostgresContext) GetActorFromRow(row pgx.Row) (actor *types.Actor, height int64, err error) {
+func (p *PostgresContext) getActorFromRow(row pgx.Row) (actor *types.Actor, height int64, err error) {
 	actor = new(types.Actor)
 	err = row.Scan(
 		&actor.Address,
@@ -109,7 +109,7 @@ func (p *PostgresContext) GetActorFromRow(row pgx.Row) (actor *types.Actor, heig
 	return
 }
 
-func (p *PostgresContext) GetChainsForActor(
+func (p *PostgresContext) getChainsForActor(
 	ctx context.Context,
 	tx pgx.Tx,
 	actorSchema types.ProtocolActorSchema,
@@ -142,7 +142,7 @@ func (p *PostgresContext) GetChainsForActor(
 }
 
 func (p *PostgresContext) InsertActor(actorSchema types.ProtocolActorSchema, actor *types.Actor) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -160,7 +160,7 @@ func (p *PostgresContext) InsertActor(actorSchema types.ProtocolActorSchema, act
 }
 
 func (p *PostgresContext) UpdateActor(actorSchema types.ProtocolActorSchema, actor *types.Actor) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -188,7 +188,7 @@ func (p *PostgresContext) UpdateActor(actorSchema types.ProtocolActorSchema, act
 }
 
 func (p *PostgresContext) GetActorsReadyToUnstake(actorSchema types.ProtocolActorSchema, height int64) (actors []modules.IUnstakingActor, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return nil, err
 	}
@@ -215,7 +215,7 @@ func (p *PostgresContext) GetActorsReadyToUnstake(actorSchema types.ProtocolActo
 
 func (p *PostgresContext) GetActorStatus(actorSchema types.ProtocolActorSchema, address []byte, height int64) (int32, error) {
 	var unstakingHeight int64
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return UndefinedStakingStatus, err
 	}
@@ -235,7 +235,7 @@ func (p *PostgresContext) GetActorStatus(actorSchema types.ProtocolActorSchema,
 }
 
 func (p *PostgresContext) SetActorUnstakingHeightAndStatus(actorSchema types.ProtocolActorSchema, address []byte, unstakingHeight int64) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -250,7 +250,7 @@ func (p *PostgresContext) SetActorUnstakingHeightAndStatus(actorSchema types.Pro
 }
 
 func (p *PostgresContext) GetActorPauseHeightIfExists(actorSchema types.ProtocolActorSchema, address []byte, height int64) (pausedHeight int64, err error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return types.DefaultBigInt, err
 	}
@@ -263,7 +263,7 @@ func (p *PostgresContext) GetActorPauseHeightIfExists(actorSchema types.Protocol
 }
 
 func (p PostgresContext) SetActorStatusAndUnstakingHeightIfPausedBefore(actorSchema types.ProtocolActorSchema, pausedBeforeHeight, unstakingHeight int64) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -278,7 +278,7 @@ func (p PostgresContext) SetActorStatusAndUnstakingHeightIfPausedBefore(actorSch
 }
 
 func (p PostgresContext) SetActorPauseHeight(actorSchema types.ProtocolActorSchema, address []byte, pauseHeight int64) error {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -292,8 +292,8 @@ func (p PostgresContext) SetActorPauseHeight(actorSchema types.ProtocolActorSche
 	return err
 }
 
-func (p PostgresContext) SetActorStakeAmount(actorSchema types.ProtocolActorSchema, address []byte, stakeAmount string) error {
-	ctx, tx, err := p.GetCtxAndTx()
+func (p PostgresContext) setActorStakeAmount(actorSchema types.ProtocolActorSchema, address []byte, stakeAmount string) error {
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return err
 	}
@@ -307,7 +307,7 @@ func (p PostgresContext) SetActorStakeAmount(actorSchema types.ProtocolActorSche
 }
 
 func (p PostgresContext) GetActorOutputAddress(actorSchema types.ProtocolActorSchema, operatorAddr []byte, height int64) ([]byte, error) {
-	ctx, tx, err := p.GetCtxAndTx()
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return nil, err
 	}
@@ -320,8 +320,8 @@ func (p PostgresContext) GetActorOutputAddress(actorSchema types.ProtocolActorSc
 	return hex.DecodeString(outputAddr)
 }
 
-func (p PostgresContext) GetActorStakeAmount(actorSchema types.ProtocolActorSchema, address []byte, height int64) (string, error) {
-	ctx, tx, err := p.GetCtxAndTx()
+func (p PostgresContext) getActorStakeAmount(actorSchema types.ProtocolActorSchema, address []byte, height int64) (string, error) {
+	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return "", err
 	}
diff --git a/persistence/state.go b/persistence/state.go
index 87c6f1643..36d2a96a2 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -227,7 +227,7 @@ func (p *PostgresContext) getActorsUpdatedAtHeight(actorType types.ActorType, he
 		return nil, fmt.Errorf("no schema found for actor type: %s", actorType)
 	}
 
-	schemaActors, err := p.GetActorsUpdated(actorSchema, height)
+	schemaActors, err := p.getActorsUpdated(actorSchema, height)
 	if err != nil {
 		return nil, err
 	}
diff --git a/persistence/test/application_test.go b/persistence/test/application_test.go
index 311bc44b1..c1be72291 100644
--- a/persistence/test/application_test.go
+++ b/persistence/test/application_test.go
@@ -14,8 +14,8 @@ import (
 
 func FuzzApplication(f *testing.F) {
 	fuzzSingleProtocolActor(f,
-		NewTestGenericActor(types.ApplicationActor, newTestApp),
-		GetGenericActor(types.ApplicationActor, getTestApp),
+		newTestGenericActor(types.ApplicationActor, newTestApp),
+		getGenericActor(types.ApplicationActor, getTestApp),
 		types.ApplicationActor)
 }
 
diff --git a/persistence/test/fisherman_test.go b/persistence/test/fisherman_test.go
index 2571b2080..11859fde6 100644
--- a/persistence/test/fisherman_test.go
+++ b/persistence/test/fisherman_test.go
@@ -16,8 +16,8 @@ import (
 
 func FuzzFisherman(f *testing.F) {
 	fuzzSingleProtocolActor(f,
-		NewTestGenericActor(types.FishermanActor, newTestFisherman),
-		GetGenericActor(types.FishermanActor, getTestFisherman),
+		newTestGenericActor(types.FishermanActor, newTestFisherman),
+		getGenericActor(types.FishermanActor, getTestFisherman),
 		types.FishermanActor)
 }
 
diff --git a/persistence/test/generic_test.go b/persistence/test/generic_test.go
index 5e454cc84..c58d15889 100644
--- a/persistence/test/generic_test.go
+++ b/persistence/test/generic_test.go
@@ -12,7 +12,7 @@ import (
 
 // TODO(andrew): Be consistent with `GenericParam` and `ActorSpecificParam` throughout the codebase; preferably the latter.
 
-func GetGenericActor[T any](
+func getGenericActor[T any](
 	protocolActorSchema types.ProtocolActorSchema,
 	getActor func(*persistence.PostgresContext, []byte) (T, error),
 ) func(*persistence.PostgresContext, string) (*types.Actor, error) {
@@ -30,7 +30,7 @@ func GetGenericActor[T any](
 	}
 }
 
-func NewTestGenericActor[T any](protocolActorSchema types.ProtocolActorSchema, newActor func() (T, error)) func() (*types.Actor, error) {
+func newTestGenericActor[T any](protocolActorSchema types.ProtocolActorSchema, newActor func() (T, error)) func() (*types.Actor, error) {
 	return func() (*types.Actor, error) {
 		actor, err := newActor()
 		if err != nil {
diff --git a/persistence/test/service_node_test.go b/persistence/test/service_node_test.go
index b0fbb3a0c..51c1e25c9 100644
--- a/persistence/test/service_node_test.go
+++ b/persistence/test/service_node_test.go
@@ -14,8 +14,8 @@ import (
 
 func FuzzServiceNode(f *testing.F) {
 	fuzzSingleProtocolActor(f,
-		NewTestGenericActor(types.ServiceNodeActor, newTestServiceNode),
-		GetGenericActor(types.ServiceNodeActor, getTestServiceNode),
+		newTestGenericActor(types.ServiceNodeActor, newTestServiceNode),
+		getGenericActor(types.ServiceNodeActor, getTestServiceNode),
 		types.ServiceNodeActor)
 }
 
diff --git a/persistence/test/validator_test.go b/persistence/test/validator_test.go
index f376c05ee..f5d5c1d71 100644
--- a/persistence/test/validator_test.go
+++ b/persistence/test/validator_test.go
@@ -14,8 +14,8 @@ import (
 
 func FuzzValidator(f *testing.F) {
 	fuzzSingleProtocolActor(f,
-		NewTestGenericActor(types.ValidatorActor, newTestValidator),
-		GetGenericActor(types.ValidatorActor, getTestValidator),
+		newTestGenericActor(types.ValidatorActor, newTestValidator),
+		getGenericActor(types.ValidatorActor, getTestValidator),
 		types.ValidatorActor)
 }
 
diff --git a/persistence/types/account.go b/persistence/types/account.go
index 07f0aa7d4..8e2feea9a 100644
--- a/persistence/types/account.go
+++ b/persistence/types/account.go
@@ -18,27 +18,27 @@ const (
 )
 
 var (
-	AccountTableSchema = AccountOrPoolSchema(AddressCol, AccountHeightConstraint)
-	PoolTableSchema    = AccountOrPoolSchema(NameCol, PoolHeightConstraint)
+	AccountTableSchema = accountOrPoolSchema(AddressCol, AccountHeightConstraint)
+	PoolTableSchema    = accountOrPoolSchema(NameCol, PoolHeightConstraint)
 )
 
 func GetAccountAmountQuery(address string, height int64) string {
-	return SelectBalance(AddressCol, address, height, AccountTableName)
+	return selectBalance(AddressCol, address, height, AccountTableName)
 }
 
 func InsertAccountAmountQuery(address, amount string, height int64) string {
-	return InsertAcc(AddressCol, address, amount, height, AccountTableName, AccountHeightConstraint)
+	return insertAcc(AddressCol, address, amount, height, AccountTableName, AccountHeightConstraint)
 }
 
 func GetPoolAmountQuery(name string, height int64) string {
-	return SelectBalance(NameCol, name, height, PoolTableName)
+	return selectBalance(NameCol, name, height, PoolTableName)
 }
 
 func InsertPoolAmountQuery(name, amount string, height int64) string {
-	return InsertAcc(NameCol, name, amount, height, PoolTableName, PoolHeightConstraint)
+	return insertAcc(NameCol, name, amount, height, PoolTableName, PoolHeightConstraint)
 }
 
-func AccountOrPoolSchema(mainColName, constraintName string) string {
+func accountOrPoolSchema(mainColName, constraintName string) string {
 	return fmt.Sprintf(`(
 			%s TEXT NOT NULL,
 			%s TEXT NOT NULL,
@@ -48,7 +48,7 @@ func AccountOrPoolSchema(mainColName, constraintName string) string {
 		)`, mainColName, BalanceCol, HeightCol, constraintName, mainColName, HeightCol)
 }
 
-func InsertAcc(actorSpecificParam, actorSpecificParamValue, amount string, height int64, tableName, constraintName string) string {
+func insertAcc(actorSpecificParam, actorSpecificParamValue, amount string, height int64, tableName, constraintName string) string {
 	return fmt.Sprintf(`
 		INSERT INTO %s (%s, balance, height)
 			VALUES ('%s','%s',%d)
@@ -57,7 +57,7 @@ func InsertAcc(actorSpecificParam, actorSpecificParamValue, amount string, heigh
 		`, tableName, actorSpecificParam, actorSpecificParamValue, amount, height, constraintName)
 }
 
-func SelectBalance(actorSpecificParam, actorSpecificParamValue string, height int64, tableName string) string {
+func selectBalance(actorSpecificParam, actorSpecificParamValue string, height int64, tableName string) string {
 	return fmt.Sprintf(`SELECT balance FROM %s WHERE %s='%s' AND height<=%d ORDER BY height DESC LIMIT 1`,
 		tableName, actorSpecificParam, actorSpecificParamValue, height)
 }
diff --git a/persistence/types/base_actor.go b/persistence/types/base_actor.go
index b5e3b2521..a21f65e62 100644
--- a/persistence/types/base_actor.go
+++ b/persistence/types/base_actor.go
@@ -7,7 +7,6 @@ var _ ProtocolActorSchema = &BaseProtocolActorSchema{}
 
 // Implements the ProtocolActorSchema with behaviour that can be embedded (i.e. inherited) by other protocol
 // actors for a share implementation.
-//
 // Note that this implementation assumes the protocol actor is chain dependant, so that behaviour needs
 // to be overridden if the actor (e.g. Validator) is chain independent.
 type BaseProtocolActorSchema struct {
@@ -36,11 +35,11 @@ func (actor *BaseProtocolActorSchema) GetActorSpecificColName() string {
 }
 
 func (actor *BaseProtocolActorSchema) GetTableSchema() string {
-	return ProtocolActorTableSchema(actor.actorSpecificColName, actor.heightConstraintName)
+	return protocolActorTableSchema(actor.actorSpecificColName, actor.heightConstraintName)
 }
 
 func (actor *BaseProtocolActorSchema) GetChainsTableSchema() string {
-	return ProtocolActorChainsTableSchema(actor.chainsHeightConstraintName)
+	return protocolActorChainsTableSchema(actor.chainsHeightConstraintName)
 }
 
 func (actor *BaseProtocolActorSchema) GetUpdatedAtHeightQuery(height int64) string {
@@ -60,7 +59,7 @@ func (actor *BaseProtocolActorSchema) GetExistsQuery(address string, height int6
 }
 
 func (actor *BaseProtocolActorSchema) GetReadyToUnstakeQuery(unstakingHeight int64) string {
-	return ReadyToUnstake(unstakingHeight, actor.tableName)
+	return readyToUnstake(unstakingHeight, actor.tableName)
 }
 
 func (actor *BaseProtocolActorSchema) GetOutputAddressQuery(operatorAddress string, height int64) string {
@@ -80,7 +79,7 @@ func (actor *BaseProtocolActorSchema) GetUnstakingHeightQuery(address string, he
 }
 
 func (actor *BaseProtocolActorSchema) GetChainsQuery(address string, height int64) string {
-	return SelectChains(AllColsSelector, address, height, actor.tableName, actor.chainsTableName)
+	return selectChains(AllColsSelector, address, height, actor.tableName, actor.chainsTableName)
 }
 
 func (actor *BaseProtocolActorSchema) InsertQuery(address, publicKey, stakedTokens, generic, outputAddress string, pausedHeight, unstakingHeight int64, chains []string, height int64) string {
@@ -104,23 +103,23 @@ func (actor *BaseProtocolActorSchema) UpdateQuery(address, stakedTokens, generic
 }
 
 func (actor *BaseProtocolActorSchema) UpdateChainsQuery(address string, chains []string, height int64) string {
-	return InsertChains(address, chains, height, actor.chainsTableName, actor.chainsHeightConstraintName)
+	return insertChains(address, chains, height, actor.chainsTableName, actor.chainsHeightConstraintName)
 }
 
 func (actor *BaseProtocolActorSchema) UpdateUnstakingHeightQuery(address string, unstakingHeight, height int64) string {
-	return UpdateUnstakingHeight(address, actor.actorSpecificColName, unstakingHeight, height, actor.tableName, actor.heightConstraintName)
+	return updateUnstakingHeight(address, actor.actorSpecificColName, unstakingHeight, height, actor.tableName, actor.heightConstraintName)
 }
 
 func (actor *BaseProtocolActorSchema) UpdatePausedHeightQuery(address string, pausedHeight, height int64) string {
-	return UpdatePausedHeight(address, actor.actorSpecificColName, pausedHeight, height, actor.tableName, actor.heightConstraintName)
+	return updatePausedHeight(address, actor.actorSpecificColName, pausedHeight, height, actor.tableName, actor.heightConstraintName)
 }
 
 func (actor *BaseProtocolActorSchema) UpdateUnstakedHeightIfPausedBeforeQuery(pauseBeforeHeight, unstakingHeight, height int64) string {
-	return UpdateUnstakedHeightIfPausedBefore(actor.actorSpecificColName, unstakingHeight, pauseBeforeHeight, height, actor.tableName, actor.heightConstraintName)
+	return updateUnstakedHeightIfPausedBefore(actor.actorSpecificColName, unstakingHeight, pauseBeforeHeight, height, actor.tableName, actor.heightConstraintName)
 }
 
 func (actor *BaseProtocolActorSchema) SetStakeAmountQuery(address string, stakedTokens string, height int64) string {
-	return UpdateStakeAmount(address, actor.actorSpecificColName, stakedTokens, height, actor.tableName, actor.heightConstraintName)
+	return updateStakeAmount(address, actor.actorSpecificColName, stakedTokens, height, actor.tableName, actor.heightConstraintName)
 }
 
 func (actor *BaseProtocolActorSchema) ClearAllQuery() string {
diff --git a/persistence/types/gov.go b/persistence/types/gov.go
index 6a1bcebac..dbfdd9d1b 100644
--- a/persistence/types/gov.go
+++ b/persistence/types/gov.go
@@ -11,7 +11,6 @@ import (
 )
 
 // init initializes a map that contains the metadata extracted from `gov.proto`.
-//
 // Since protobuf files do not change at runtime, it seems efficient to do it here.
 func init() {
 	govParamMetadataMap = parseGovProto()
@@ -59,9 +58,7 @@ var (
 )
 
 // InsertParams generates the SQL INSERT statement given a *genesis.Params
-//
 // It leverages metadata in the form of struct tags (see `parseGovProto` for more information).
-//
 // WARNING: reflections in prod
 func InsertParams(params modules.Params, height int64) string {
 	val := reflect.ValueOf(params)
diff --git a/persistence/types/persistence_genesis.go b/persistence/types/persistence_genesis.go
index 8bcd46a4b..8437faf9b 100644
--- a/persistence/types/persistence_genesis.go
+++ b/persistence/types/persistence_genesis.go
@@ -14,11 +14,11 @@ var _ modules.PersistenceGenesisState = &PersistenceGenesisState{}
 //	not a fan of <module_name>_config/genesis.go would rather just config/genesis.go
 
 func (x *PersistenceGenesisState) GetAccs() []modules.Account {
-	return AccToAccInterface(x.GetAccounts())
+	return accToAccInterface(x.GetAccounts())
 }
 
 func (x *PersistenceGenesisState) GetAccPools() []modules.Account {
-	return AccToAccInterface(x.GetPools())
+	return accToAccInterface(x.GetPools())
 }
 
 func (x *PersistenceGenesisState) GetApps() []modules.Actor {
@@ -50,7 +50,7 @@ func ActorsToActorsInterface(a []*Actor) (actorI []modules.Actor) {
 	return
 }
 
-func AccToAccInterface(a []*Account) (accI []modules.Account) {
+func accToAccInterface(a []*Account) (accI []modules.Account) {
 	for _, acc := range a {
 		accI = append(accI, acc)
 	}
diff --git a/persistence/types/shared_sql.go b/persistence/types/shared_sql.go
index 6cd46c22a..a0b04820a 100644
--- a/persistence/types/shared_sql.go
+++ b/persistence/types/shared_sql.go
@@ -30,7 +30,7 @@ const (
 	HeightCol          = "height"
 )
 
-func ProtocolActorTableSchema(actorSpecificColName, constraintName string) string {
+func protocolActorTableSchema(actorSpecificColName, constraintName string) string {
 	return fmt.Sprintf(`(
 			%s TEXT NOT NULL,
 			%s TEXT NOT NULL,
@@ -59,7 +59,7 @@ func ProtocolActorTableSchema(actorSpecificColName, constraintName string) strin
 		HeightCol)
 }
 
-func ProtocolActorChainsTableSchema(constraintName string) string {
+func protocolActorChainsTableSchema(constraintName string) string {
 	return fmt.Sprintf(`(
 			%s TEXT NOT NULL,
 			%s CHAR(4) NOT NULL,
@@ -88,7 +88,7 @@ func SelectActors(actorSpecificParam string, height int64, tableName string) str
        `, actorSpecificParam, tableName, height)
 }
 
-func SelectChains(selector, address string, height int64, actorTableName, chainsTableName string) string {
+func selectChains(selector, address string, height int64, actorTableName, chainsTableName string) string {
 	return fmt.Sprintf(`SELECT %s FROM %s WHERE address='%s' AND height=(%s);`,
 		selector, chainsTableName, address, Select(HeightCol, address, height, actorTableName))
 }
@@ -102,7 +102,7 @@ func Exists(address string, height int64, tableName string) string {
 //       returns latest/max height for each address
 //   (height, address) IN (SELECT MAX(height), address FROM %s GROUP BY address) ->
 //       ensures the query is acting on max height for the addresses
-func ReadyToUnstake(unstakingHeight int64, tableName string) string {
+func readyToUnstake(unstakingHeight int64, tableName string) string {
 	return fmt.Sprintf(`
 		SELECT address, staked_tokens, output_address
 		FROM %s WHERE unstaking_height=%d
@@ -134,10 +134,10 @@ func Insert(
 	}
 
 	return fmt.Sprintf("WITH baseTableInsert AS (%s)\n%s",
-		insertStatement, InsertChains(actor.Address, actor.Chains, height, chainsTableName, chainsConstraintName))
+		insertStatement, insertChains(actor.Address, actor.Chains, height, chainsTableName, chainsConstraintName))
 }
 
-func InsertChains(address string, chains []string, height int64, tableName, constraintName string) string {
+func insertChains(address string, chains []string, height int64, tableName, constraintName string) string {
 	var buffer bytes.Buffer
 
 	buffer.WriteString(fmt.Sprintf("INSERT INTO %s (address, chain_id, height) VALUES", tableName))
@@ -171,7 +171,7 @@ func Update(address, stakedTokens, actorSpecificParam, actorSpecificParamValue s
 		actorSpecificParam, actorSpecificParam)
 }
 
-func UpdateUnstakingHeight(address, actorSpecificParam string, unstakingHeight, height int64, tableName, constraintName string) string {
+func updateUnstakingHeight(address, actorSpecificParam string, unstakingHeight, height int64, tableName, constraintName string) string {
 	return fmt.Sprintf(`
 		INSERT INTO %s(address, public_key, staked_tokens, %s, output_address, paused_height, unstaking_height, height)
 		(
@@ -186,7 +186,7 @@ func UpdateUnstakingHeight(address, actorSpecificParam string, unstakingHeight,
 		constraintName)
 }
 
-func UpdateStakeAmount(address, actorSpecificParam, stakeAmount string, height int64, tableName, constraintName string) string {
+func updateStakeAmount(address, actorSpecificParam, stakeAmount string, height int64, tableName, constraintName string) string {
 	return fmt.Sprintf(`
 		INSERT INTO %s(address, public_key, staked_tokens, %s, output_address, paused_height, unstaking_height, height)
 		(
@@ -201,7 +201,7 @@ func UpdateStakeAmount(address, actorSpecificParam, stakeAmount string, height i
 		constraintName)
 }
 
-func UpdatePausedHeight(address, actorSpecificParam string, pausedHeight, height int64, tableName, constraintName string) string {
+func updatePausedHeight(address, actorSpecificParam string, pausedHeight, height int64, tableName, constraintName string) string {
 	return fmt.Sprintf(`
 		INSERT INTO %s(address, public_key, staked_tokens, %s, output_address, paused_height, unstaking_height, height)
 		(
@@ -215,7 +215,7 @@ func UpdatePausedHeight(address, actorSpecificParam string, pausedHeight, height
 		tableName, address, height, constraintName)
 }
 
-func UpdateUnstakedHeightIfPausedBefore(actorSpecificParam string, unstakingHeight, pausedBeforeHeight, height int64, tableName, constraintName string) string {
+func updateUnstakedHeightIfPausedBefore(actorSpecificParam string, unstakingHeight, pausedBeforeHeight, height int64, tableName, constraintName string) string {
 	return fmt.Sprintf(`
 		INSERT INTO %s (address, public_key, staked_tokens, %s, output_address, paused_height, unstaking_height, height)
 		(
diff --git a/persistence/validator.go b/persistence/validator.go
index 0e1763fb3..7e2901a50 100644
--- a/persistence/validator.go
+++ b/persistence/validator.go
@@ -12,7 +12,7 @@ func (p PostgresContext) GetValidatorExists(address []byte, height int64) (exist
 }
 
 func (p PostgresContext) GetValidator(address []byte, height int64) (operator, publicKey, stakedTokens, serviceURL, outputAddress string, pausedHeight, unstakingHeight int64, err error) {
-	actor, err := p.GetActor(types.ValidatorActor, address, height)
+	actor, err := p.getActor(types.ValidatorActor, address, height)
 	operator = actor.Address
 	publicKey = actor.PublicKey
 	stakedTokens = actor.StakedAmount
@@ -46,11 +46,11 @@ func (p PostgresContext) UpdateValidator(address []byte, serviceURL string, stak
 }
 
 func (p PostgresContext) GetValidatorStakeAmount(height int64, address []byte) (string, error) {
-	return p.GetActorStakeAmount(types.ValidatorActor, address, height)
+	return p.getActorStakeAmount(types.ValidatorActor, address, height)
 }
 
 func (p PostgresContext) SetValidatorStakeAmount(address []byte, stakeAmount string) error {
-	return p.SetActorStakeAmount(types.ValidatorActor, address, stakeAmount)
+	return p.setActorStakeAmount(types.ValidatorActor, address, stakeAmount)
 }
 
 func (p PostgresContext) GetValidatorsReadyToUnstake(height int64, status int32) ([]modules.IUnstakingActor, error) {
@@ -79,7 +79,7 @@ func (p PostgresContext) SetValidatorPauseHeight(address []byte, height int64) e
 
 // TODO(team): The Get & Update operations need to be made atomic
 // TODO(team): Deprecate this functiona altogether and use UpdateValidator where applicable
-func (p PostgresContext) SetValidatorStakedTokens(address []byte, tokens string) error { //
+func (p PostgresContext) setValidatorStakedTokens(address []byte, tokens string) error {
 	height, err := p.GetHeight()
 	if err != nil {
 		return err
@@ -95,7 +95,7 @@ func (p PostgresContext) SetValidatorStakedTokens(address []byte, tokens string)
 	return p.UpdateValidator(addr, serviceURL, tokens)
 }
 
-func (p PostgresContext) GetValidatorStakedTokens(address []byte, height int64) (tokens string, err error) {
+func (p PostgresContext) getValidatorStakedTokens(address []byte, height int64) (tokens string, err error) {
 	_, _, tokens, _, _, _, _, err = p.GetValidator(address, height)
 	return
 }
diff --git a/shared/docs/PROTOCOL_STATE_HASH.md b/shared/docs/PROTOCOL_STATE_HASH.md
index 17d6d8e59..27cad2d51 100644
--- a/shared/docs/PROTOCOL_STATE_HASH.md
+++ b/shared/docs/PROTOCOL_STATE_HASH.md
@@ -13,7 +13,7 @@ _NOTE: The diagrams below use some [Hotstuff specific](https://arxiv.org/abs/180
 
 ## Context Management
 
-The `Utility` and `Persistence` modules maintain a context (i.e. an ephemeral states) driven by the `Consensus` module that can be released & reverted as a result of various (e.g. lack of Validator consensus) before the state is committed and persisted to disk (i.e. the block is finalized).
+The `Utility` and `Persistence` modules maintain a context (i.e. an ephemeral states) driven by the `Consensus` module that can be `released & reverted` (i.e. the block is invalid / no Validator Consensus reached) or can be `committed & persisted` to disk (i.e. the block is finalized).
 
 On every round of every height:
 
@@ -31,61 +31,64 @@ sequenceDiagram
     participant P as Persistence
 
     %% Handle New Message
-    B-->>C: HandleMessage(msg)
-
-    critical NewRound
-        %% Create Contexts
-        C->>+U: NewContext(height)
-        U->>+P: NewRWContext(height)
-        P->>-U: PersistenceContext
-        U->>U: store context<br>locally
-        activate U
-        deactivate U
-        U->>-C: UtilityContext
-        C->>C: store context<br>locally
-        activate C
-        deactivate C
-
-        %% Apply Block
-        Note over C, P: See 'Block Application'
-    end
+    B-->>C: HandleMessage(NEWROUND)
+
+    %% NEWROUND
+
+    activate C
+    %% Create Contexts
+    C->>+U: NewContext(height)
+    U->>+P: NewRWContext(height)
+    P->>-U: PersistenceContext
+    U->>U: store context<br>locally
+    activate U
+    deactivate U
+    U->>-C: UtilityContext
+    C->>C: store context<br>locally
+    deactivate C
+
+    %% Apply Block
+    Note over C, P: 'Block Application'
 ```
 
-5. The **HotPOKT lifecycle** takes place so Validators achieve consensus (i.e. steps `PRECOMMIT` and `COMMIT`)
-6. The `Consensus` module handle the `DECIDE` message
-7. The final `quorumCertificate` is propagated to the `UtilityContext` on Commit
-8. The final `quorumCertificate` is propagated to the `PersistenceContext` on Commit
-9. The persistence module's internal implementation for [Store Block](../../persistence/docs/PROTOCOL_STATE_HASH.md) must execute.
-10. Both the `UtilityContext` and `PersistenceContext` are released
+---
+
+_The **Proposer** drives the **Validators** to agreement via the **Consensus Lifecycle** (i.e. HotPOKT)_
+
+---
+
+5. The `Consensus` module handles the `DECIDE` message
+6. The final `quorumCertificate` is propagated to the `UtilityContext` & `PersistenceContext` on `Commit`
+7. The persistence module's internal implementation for ['Store Block'](../../persistence/docs/PROTOCOL_STORE_BLOCK.md) must execute.
+8. Both the `UtilityContext` and `PersistenceContext` are released
 
 ```mermaid
 sequenceDiagram
-    title Steps 6-10
+    title Steps 5-8
     participant B as Bus
     participant C as Consensus
     participant U as Utility
     participant P as Persistence
 
     %% Handle New Message
-    B-->>C: HandleMessage(msg)
-
-    critical Decide
-        %% Commit Context
-        C->>+U: Context.Commit(quorumCert)
-        U->>+P: Context.Commit(quorumCert)
-        P->>P: Internal Implementation
-        Note over P: Store Block
-        P->>-U: err_code
-        U->>C: err_code
-        deactivate U
-
-        %% Release Context
-        C->>+U: Context.Release()
-        U->>+P: Context.Release()
-        P->>-U: err_code
-        U->>-C: err_code
-    end
+    B-->>C: HandleMessage(DECIDE)
 
+    activate C
+    %% Commit Context
+    C->>+U: Context.Commit(quorumCert)
+    U->>+P: Context.Commit(quorumCert)
+    P->>P: Internal Implementation
+    Note over P: Store Block
+    P->>-U: err_code
+    U->>C: err_code
+    deactivate U
+
+    %% Release Context
+    C->>+U: Context.Release()
+    U->>+P: Context.Release()
+    P->>-U: err_code
+    U->>-C: err_code
+    deactivate C
 ```
 
 ## Block Application
@@ -141,7 +144,7 @@ sequenceDiagram
 4. Loop over all transactions proposed
 5. Check if the transaction has already been applied to the local state
 6. Perform the CRUD operation(s) corresponding to each transaction
-7. The persistence module's internal implementation for [Updating a State hash](../../persistence/docs/PROTOCOL_STATE_HASH.md) must be triggered
+7. The persistence module's internal implementation for ['Update State Hash'](../../persistence/docs/PROTOCOL_STATE_HASH.md) must be triggered
 8. Validate that the local state hash computed is the same as that proposed
 
 ```mermaid
@@ -153,20 +156,19 @@ sequenceDiagram
 
     loop for each tx in txs
         U->>+P: TransactionExists(txHash)
-        P->>-U: true | false
-        opt if tx is not indexed
-            loop for each operation in tx
-                U->>+P: Get*/Set*/Update*/Insert*
-                P->>-U: err_code
-                U->>U: Validation logic
-                activate U
-                deactivate U
-            end
+        P->>-U: false (does not exist)
+        loop for each operation in tx
+            U->>+P: Get*/Set*/Update*/Insert*
+            P->>-U: err_code
+            U->>U: Validation logic
+            activate U
+            deactivate U
         end
     end
+    %% TODO: Consolidate AppHash and StateHash
     U->>+P: UpdateAppHash()
     P->>P: Internal Implementation
-    Note over P: Update state hash
+    Note over P: Update State Hash
     P->>-U: stateHash
     U->>C: stateHash
 
diff --git a/shared/modules/doc/CHANGELOG.md b/shared/modules/doc/CHANGELOG.md
index 3a47a7671..4312d25c9 100644
--- a/shared/modules/doc/CHANGELOG.md
+++ b/shared/modules/doc/CHANGELOG.md
@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.0.3] - 2022-11-15
+
+PersistenceModule
+
+- Added `ReleaseWriteContext`
+- Consolidated `ResetContext`, `Reset` with `Release`
+- Modified `Commit` to accept a `quorumCert`
+- Removed `Latest` prefix from getters related to the proposal block parameters
+
+UtilityModule
+
+- Changed `CommitPersistenceContext()` to `Commit(quorumCert)`
+- Changed `ReleaseContext` to `Release`
+
 ## [0.0.0.2] - 2022-10-12
 
 - Modified interface for Utility Module `ApplyBlock` and `GetProposalTransactions` to return `TxResults`
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index 44ec0f132..ebc3b3c6c 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -44,7 +44,7 @@ type PersistenceRWContext interface {
 // - Use general purpose parameter methods such as `Set(enum_gov_type, ...)` such as `Set(STAKING_ADJUSTMENT, ...)`
 // - Reference: https://dave.cheney.net/practical-go/presentations/gophercon-israel.html#_prefer_single_method_interfaces
 
-// TOD (#149): convert address and public key to string from bytes
+// TECHDEBT: convert address and public key to string from bytes
 // NOTE: There's not really a use case for a write only interface, but it abstracts and contrasts nicely against the read only context
 type PersistenceWriteContext interface {
 	// Context Operations
@@ -59,7 +59,7 @@ type PersistenceWriteContext interface {
 
 	// Block Operations
 	SetProposalBlock(blockHash string, proposerAddr []byte, quorumCert []byte, transactions [][]byte) error
-	GetLatestBlockTxs() [][]byte              // Returns the transactions set by `SetProposalBlock`
+	GetBlockTxs() [][]byte                    // Returns the transactions set by `SetProposalBlock`
 	ComputeAppHash() ([]byte, error)          // Update the merkle trees, computes the new state hash, and returns in
 	IndexTransaction(txResult TxResult) error // DISCUSS_IN_THIS_COMMIT: How can we remove `TxResult` from the public interface?
 
@@ -122,10 +122,11 @@ type PersistenceReadContext interface {
 	GetHeight() (int64, error) // Returns the height of the context
 	Close() error              // Closes the read context
 
+	// CONSOLIDATE: BlockHash / AppHash / StateHash
 	// Block Queries
 	GetLatestBlockHeight() (uint64, error)         // Returns the height of the latest block in the persistence layer
 	GetBlockHash(height int64) ([]byte, error)     // Returns the app hash corresponding to the height provided
-	GetLatestProposerAddr() []byte                 // Returns the proposer set via `SetProposalBlock`
+	GetProposerAddr() []byte                       // Returns the proposer set via `SetProposalBlock`
 	GetBlocksPerSession(height int64) (int, error) // TECHDEBT(#286): Deprecate this method
 
 	// Indexer Queries
diff --git a/shared/modules/utility_module.go b/shared/modules/utility_module.go
index a628ddc2d..816ab4967 100644
--- a/shared/modules/utility_module.go
+++ b/shared/modules/utility_module.go
@@ -30,7 +30,6 @@ type UtilityContext interface {
 	GetPersistenceContext() PersistenceRWContext
 
 	// Validation operations
-
 	CheckTransaction(tx []byte) error
 }
 
diff --git a/utility/block.go b/utility/block.go
index 9b3eb36fd..1780a6b3e 100644
--- a/utility/block.go
+++ b/utility/block.go
@@ -20,6 +20,7 @@ import (
 	operation that executes at the end of every block.
 */
 
+// TODO: Make sure to call `utility.CheckTransaction`, which calls `persistence.TransactionExists`
 func (u *UtilityContext) CreateAndApplyProposalBlock(proposer []byte, maxTransactionBytes int) ([]byte, [][]byte, error) {
 	lastBlockByzantineVals, err := u.GetLastBlockByzantineValidators()
 	if err != nil {
@@ -82,6 +83,7 @@ func (u *UtilityContext) CreateAndApplyProposalBlock(proposer []byte, maxTransac
 	return appHash, transactions, err
 }
 
+// TODO: Make sure to call `utility.CheckTransaction`, which calls `persistence.TransactionExists`
 // CLEANUP: code re-use ApplyBlock() for CreateAndApplyBlock()
 func (u *UtilityContext) ApplyBlock() (appHash []byte, err error) {
 	lastByzantineValidators, err := u.GetLastBlockByzantineValidators()
@@ -95,7 +97,7 @@ func (u *UtilityContext) ApplyBlock() (appHash []byte, err error) {
 	}
 
 	// deliver txs lifecycle phase
-	for index, transactionProtoBytes := range u.GetPersistenceContext().GetLatestBlockTxs() {
+	for index, transactionProtoBytes := range u.GetPersistenceContext().GetBlockTxs() {
 		tx, err := typesUtil.TransactionFromBytes(transactionProtoBytes)
 		if err != nil {
 			return nil, err
@@ -104,8 +106,8 @@ func (u *UtilityContext) ApplyBlock() (appHash []byte, err error) {
 			return nil, err
 		}
 		// TODO(#346): Currently, the pattern is allowing nil err with an error transaction...
-		//                Should we terminate applyBlock immediately if there's an invalid transaction?
-		//                Or wait until the entire lifecycle is over to evaluate an 'invalid' block
+		//             Should we terminate applyBlock immediately if there's an invalid transaction?
+		//             Or wait until the entire lifecycle is over to evaluate an 'invalid' block
 
 		// Validate and apply the transaction to the Postgres database
 		txResult, err := u.ApplyTransaction(index, tx)
@@ -125,7 +127,7 @@ func (u *UtilityContext) ApplyBlock() (appHash []byte, err error) {
 	}
 
 	// end block lifecycle phase
-	if err := u.EndBlock(u.GetPersistenceContext().GetLatestProposerAddr()); err != nil {
+	if err := u.EndBlock(u.GetPersistenceContext().GetProposerAddr()); err != nil {
 		return nil, err
 	}
 
diff --git a/utility/doc/CHANGELOG.md b/utility/doc/CHANGELOG.md
index 8df4d2c55..551eec1c8 100644
--- a/utility/doc/CHANGELOG.md
+++ b/utility/doc/CHANGELOG.md
@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.0.10] - 2022-11-15
+
+- Propagating the `quorumCertificate` appropriately on block commit
+- Removed `Latest` from getters related to retrieving the context of the proposed block
+
 ## [0.0.0.9] - 2022-11-01
 
 - Remove `TxResult` from the utility module interface (added in TxIndexer integration of transaction indexer (issue-#168) #302)

From c134b82f081f9d335e023af4d2e32fdcd9f53e07 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 16 Nov 2022 10:29:10 -0800
Subject: [PATCH 185/227] Added a weird bug related to errors in the non main
 thread

---
 consensus/consensus_tests/utils_test.go | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 49126c1f7..55ebbc720 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -12,8 +12,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/pokt-network/pocket/shared/codec"
-
 	"github.com/benbjohnson/clock"
 	"github.com/golang/mock/gomock"
 	"github.com/pokt-network/pocket/consensus"
@@ -21,6 +19,7 @@ import (
 	"github.com/pokt-network/pocket/runtime"
 	"github.com/pokt-network/pocket/runtime/test_artifacts"
 	"github.com/pokt-network/pocket/shared"
+	"github.com/pokt-network/pocket/shared/codec"
 	cryptoPocket "github.com/pokt-network/pocket/shared/crypto"
 	"github.com/pokt-network/pocket/shared/debug"
 	"github.com/pokt-network/pocket/shared/modules"
@@ -156,6 +155,7 @@ func CreateTestConsensusPocketNode(
 	return pocketNode
 }
 
+// TODO: Reduce package scope visibility in the consensus test module
 func StartAllTestPocketNodes(t *testing.T, pocketNodes IdToNodeMapping) {
 	for _, pocketNode := range pocketNodes {
 		go pocketNode.Start()
@@ -302,9 +302,11 @@ func basePersistenceMock(t *testing.T, _ modules.EventsChannel) *modulesMock.Moc
 	persistenceMock := modulesMock.NewMockPersistenceModule(ctrl)
 	persistenceContextMock := modulesMock.NewMockPersistenceRWContext(ctrl)
 
+	// TODO_IN_THIS_COMMIT(olshansky): figure out why bugs in the non main go channel block rather than fails
 	persistenceMock.EXPECT().Start().Return(nil).AnyTimes()
 	persistenceMock.EXPECT().SetBus(gomock.Any()).Return().AnyTimes()
 	persistenceMock.EXPECT().NewReadContext(int64(-1)).Return(persistenceContextMock, nil).AnyTimes()
+	persistenceMock.EXPECT().ReleaseWriteContext().Return(nil).AnyTimes()
 
 	// The persistence context should usually be accessed via the utility module within the context
 	// of the consensus module. This one is only used when loading the initial consensus module

From 9ff13eadeb6f6e4272417eedbb2e9d4068befdf9 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 16 Nov 2022 10:38:03 -0800
Subject: [PATCH 186/227] Updated the consensus changelog

---
 consensus/CHANGELOG.md | 8 ++++++++
 consensus/block.go     | 6 +++++-
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/consensus/CHANGELOG.md b/consensus/CHANGELOG.md
index 2795635f8..36d5e9375 100644
--- a/consensus/CHANGELOG.md
+++ b/consensus/CHANGELOG.md
@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.0.9] - 2022-11-16
+
+- Propagate `hightPrepareQC` if available to the block being created
+- Remove `blockProtoBytes` from propagation in `SetProposalBlock`
+- Guarantee that write context is released when refreshing the utility context
+- Use `GetBlockHash(height)` instead of `GetPrevAppHash` to be more explicit
+- Use the real `quorumCert` when preparing a new block
+
 ## [0.0.0.8] - 2022-11-15
 
 - Propagate the `quorumCertificate` on `Block` commit to the `Utility` module
diff --git a/consensus/block.go b/consensus/block.go
index f20566273..53aa4e8af 100644
--- a/consensus/block.go
+++ b/consensus/block.go
@@ -63,7 +63,11 @@ func (m *consensusModule) refreshUtilityContext() error {
 		m.utilityContext = nil
 	}
 
-	m.GetBus().GetPersistenceModule().ReleaseWriteContext()
+	// Only one write context can exist at a time, and the utility context needs to instantiate
+	// a new one to modify the state.
+	if err := m.GetBus().GetPersistenceModule().ReleaseWriteContext(); err != nil {
+		log.Printf("[WARN] Error releasing persistence write context: %v\n", err)
+	}
 
 	utilityContext, err := m.GetBus().GetUtilityModule().NewContext(int64(m.Height))
 	if err != nil {

From 5468ccf249709f3785ed2ff99f430ae8f5755252 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 16 Nov 2022 12:34:00 -0800
Subject: [PATCH 187/227] self review + test for TestGetValidatorUpdateAtHeigh

---
 persistence/CHANGELOG.md                  | 38 +++++++++++++
 persistence/account.go                    |  3 +-
 persistence/block.go                      | 32 ++---------
 persistence/context.go                    |  7 ++-
 persistence/db.go                         | 14 +----
 persistence/debug.go                      |  2 +-
 persistence/docs/PROTOCOL_STATE_HASH.md   | 65 +++++++++++++++++------
 persistence/genesis.go                    |  9 ++--
 persistence/proto/block_persistence.proto |  6 ++-
 persistence/shared_sql.go                 |  2 +-
 persistence/state.go                      | 36 +++++++++++--
 persistence/test/generic_test.go          | 55 ++++++++++++++++++-
 persistence/test/state_test.go            |  4 +-
 persistence/test/validator_test.go        |  9 +++-
 shared/docs/PROTOCOL_STATE_HASH.md        |  8 +--
 15 files changed, 205 insertions(+), 85 deletions(-)

diff --git a/persistence/CHANGELOG.md b/persistence/CHANGELOG.md
index a22f7a916..d5367949a 100644
--- a/persistence/CHANGELOG.md
+++ b/persistence/CHANGELOG.md
@@ -9,6 +9,44 @@ TODO: consolidate `persistence/docs/CHANGELOG` and `persistence/CHANGELOG.md`
 
 ## [Unreleased]
 
+## [0.0.0.9] - 2022-11-16
+
+Core StateHash changes
+
+- Introduced & defined for `block_persistence.proto`
+- On `Commit`, prepare and store a persistence block in the KV Store, SQL Store
+- Replace `IndexTransactions` (plural) to `IndexTransaction` (singular)
+- Implement `ComputeStateHash`
+-
+- Maintaining a list of StateTrees using Celestia’s SMT and badger as the KV store to compute the state hash
+- Implemented ComputeStateHash to update the global state based on:
+  - Validators
+  - Applications
+  - Servicers
+  - Fisherpeople
+  - Accounts
+  - Polols
+  - Transactions
+  - Placeholder for flags & params created
+- Added a benchmarking and a determinism test suite to validate this
+
+Supporting StateHash changes
+
+- Implemented `GetAccountsUpdated`, `GetPoolsUpdated` and `GetActorsUpdated` functions
+- Removed `GetPrevAppHash` and `indexTransactions` functions
+- Removed `blockProtoBytes` and `txResults` from the local state and added `quorumCert`
+- Consolidate all `resetContext` related operations into a single function
+- Implemented `ReleaseWriteContext`
+- Implemented ability to `ClearAllState` and `ResetToGenesis` for debugging & testing purposes
+
+KVStore changes
+
+- Renamed `Put` to `Set`
+- Embedded `smt.MapStore` in the interface containing `Get`, `Set` and `Delete`
+- Implemented `Delete`
+- Modified `GetAll` to return both `keys` and `values`
+- Turned off badger logging options since it’s noisy
+
 ## [0.0.0.8] - 2022-11-15
 
 - Rename `GetBlockHash` to `GetBlockHashAtHeight`
diff --git a/persistence/account.go b/persistence/account.go
index c0ad6311d..63229f4f7 100644
--- a/persistence/account.go
+++ b/persistence/account.go
@@ -152,8 +152,7 @@ func (p PostgresContext) GetPoolsUpdated(height int64) ([]*types.Account, error)
 
 // Joint Pool & Account Helpers
 
-// Helper for shared logic between `getPoolsUpdated` and `getAccountsUpdated` while keeping an explicit
-// external interface.
+// Shared logic between `getPoolsUpdated` & `getAccountsUpdated` to keep explicit external interfaces
 func (p *PostgresContext) getPoolOrAccUpdatedInternal(query string) (accounts []*types.Account, err error) {
 	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
diff --git a/persistence/block.go b/persistence/block.go
index 7197269c9..2b9f6a2de 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -7,13 +7,6 @@ import (
 	"github.com/pokt-network/pocket/persistence/kvstore"
 	"github.com/pokt-network/pocket/persistence/types"
 	"github.com/pokt-network/pocket/shared/codec"
-	"github.com/pokt-network/pocket/shared/crypto"
-)
-
-const (
-	// The order (ascending) is important here since it is used to comprise the hash in the block.
-	// If this changes, the txsHash in the block will differ rendering it invalid.
-	txsOrderInBlockHashDescending = false
 )
 
 // OPTIMIZE(team): get from blockstore or keep in memory
@@ -94,8 +87,8 @@ func (p *PostgresContext) prepareBlock(quorumCert []byte) (*types.Block, error)
 
 	block := &types.Block{
 		Height:            uint64(p.Height),
-		Hash:              p.blockHash,
-		PrevHash:          hex.EncodeToString(prevHash),
+		StateHash:         p.blockHash,
+		PrevStateHash:     hex.EncodeToString(prevHash),
 		ProposerAddress:   p.proposerAddr,
 		QuorumCertificate: quorumCert,
 		TransactionsHash:  txsHash,
@@ -111,7 +104,7 @@ func (p *PostgresContext) insertBlock(block *types.Block) error {
 		return err
 	}
 
-	_, err = tx.Exec(ctx, types.InsertBlockQuery(block.Height, block.Hash, block.ProposerAddress, block.QuorumCertificate))
+	_, err = tx.Exec(ctx, types.InsertBlockQuery(block.Height, block.StateHash, block.ProposerAddress, block.QuorumCertificate))
 	return err
 }
 
@@ -124,25 +117,6 @@ func (p PostgresContext) storeBlock(block *types.Block) error {
 	return p.blockStore.Set(heightToBytes(p.Height), blockBz)
 }
 
-// Returns a digest (a single hash) of all the transactions included in the block.
-// This allows separating the integrity of the transactions from their storage.
-func (p PostgresContext) getTxsHash() (txs []byte, err error) {
-	txResults, err := p.txIndexer.GetByHeight(p.Height, txsOrderInBlockHashDescending)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, txResult := range txResults {
-		txHash, err := txResult.Hash()
-		if err != nil {
-			return nil, err
-		}
-		txs = append(txs, txHash...)
-	}
-
-	return crypto.SHA3Hash(txs), nil
-}
-
 func heightToBytes(height int64) []byte {
 	heightBytes := make([]byte, 8)
 	binary.LittleEndian.PutUint64(heightBytes, uint64(height))
diff --git a/persistence/context.go b/persistence/context.go
index 8707ebb29..68abf05a7 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -14,8 +14,7 @@ func (p PostgresContext) NewSavePoint(bytes []byte) error {
 	return nil
 }
 
-// TODO(#327): When implementing save points and rollbacks, make sure that `prepareBlock`,
-// `insertBlock`, and `storeBlock` are all atomic.
+// TECHDEBT(#327): Guarantee atomicity betweens `prepareBlock`, `insertBlock` and `storeBlock` for save points & rollbacks.
 func (p PostgresContext) RollbackToSavePoint(bytes []byte) error {
 	log.Println("TODO: RollbackToSavePoint not fully implemented")
 	return p.GetTx().Rollback(context.TODO())
@@ -42,9 +41,9 @@ func (p *PostgresContext) ComputeAppHash() ([]byte, error) {
 	return p.updateMerkleTrees()
 }
 
-// TECHDEBT: Make sure these operations are atomic
+// TECHDEBT(#327): Make sure these operations are atomic
 func (p PostgresContext) Commit(quorumCert []byte) error {
-	log.Printf("About to commit context at height %d.\n", p.Height)
+	log.Printf("About to commit block & context at height %d.\n", p.Height)
 
 	// Create a persistence block proto
 	block, err := p.prepareBlock(quorumCert)
diff --git a/persistence/db.go b/persistence/db.go
index a9baa9ae0..64c619fe8 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -47,14 +47,12 @@ type PostgresContext struct {
 	txIndexer  indexer.TxIndexer
 	stateTrees *stateTrees
 
-	// DISCUSS_IN_THIS_COMMIT:
-	// 1. Could/should we rename these to proposalXX?
-	// 2. Could/should we move these to the utilityContext?
+	// IMPROVE: Could/should we rename these to proposalXX?
+	// DISCUSS: Could/should we move these to the utilityContext?
 	proposerAddr []byte
 	quorumCert   []byte
 	blockHash    string // CONSOLIDATE: blockHash / appHash / stateHash
 	blockTxs     [][]byte
-	// txResults    []modules.TxResult // TODO_IN_THIS_COMMIT: FIX THIS. Not indexed by `txIndexer` until commit.
 }
 
 func (pg *PostgresContext) getCtxAndTx() (context.Context, pgx.Tx, error) {
@@ -99,14 +97,6 @@ func (p PostgresContext) GetBlockTxs() [][]byte {
 	return p.blockTxs
 }
 
-// func (p PostgresContext) GetTxResults() []modules.TxResult {
-// 	return p.txResults
-// }
-
-// func (p *PostgresContext) SetTxResults(txResults []modules.TxResult) {
-// 	p.txResults = txResults
-// }
-
 // TECHDEBT: Implement proper connection pooling
 func connectToDatabase(postgresUrl string, schema string) (*pgx.Conn, error) {
 	ctx := context.TODO()
diff --git a/persistence/debug.go b/persistence/debug.go
index bf463ce3f..546c7fdb6 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -28,7 +28,7 @@ func (m *persistenceModule) HandleDebugMessage(debugMessage *debug.DebugMessage)
 		if err := m.clearAllState(debugMessage); err != nil {
 			return err
 		}
-	// Clears all the state (SQL DB, KV Stores, Trees, etc) to the tate specified in the genesis file provided
+	// Resets all the state (SQL DB, KV Stores, Trees, etc) to the tate specified in the genesis file provided
 	case debug.DebugMessageAction_DEBUG_PERSISTENCE_RESET_TO_GENESIS:
 		if err := m.clearAllState(debugMessage); err != nil {
 			return err
diff --git a/persistence/docs/PROTOCOL_STATE_HASH.md b/persistence/docs/PROTOCOL_STATE_HASH.md
index ac0f3dc83..cefdb02a0 100644
--- a/persistence/docs/PROTOCOL_STATE_HASH.md
+++ b/persistence/docs/PROTOCOL_STATE_HASH.md
@@ -1,17 +1,44 @@
-DO_NOT_REVIEW_THIS_YET
+# State Hash <!-- omit in toc -->
 
-# AppHash <!-- omit in toc -->
+This document describes the `Persistence` module's internal implementation of how the state hash is computed. Specifically, it defines the **'Compute State Hash'** flow in the shared architectural state hash flow defined [here](../../shared/docs/PROTOCOL_STATE_HASH.md).
 
-This document describes the persistence module internal implementation of how the state hash is updated. Specifically, what happens once the `UpdateStateHash` function in [persistence module interface](../../shared/modules/persistence_module.go) is called.
+Alternative implementation of the persistence module are free to choose their own **State Storage** engines (SQL, KV stores, etc) or their own **State Commitment** paradigms (Merkle Trees, Vector Commitments, etc), but the output hash **must** remain identical.
 
-## Update State Hash
+- [Introduction](#introduction)
+- [Data Types](#data-types)
+  - [Block Proto](#block-proto)
+  - [Trees](#trees)
+  - [Transactions Hash (?? TODO_IN_THIS_COMMIT ??)](#transactions-hash--todo_in_this_commit-)
+- [Transactions hash](#transactions-hash)
+- [Compute State Hash](#compute-state-hash)
+- [Store Block (i.e. Commit)](#store-block-ie-commit)
+
+## Introduction
+
+The state hash is a single 256 bit digest that takes a snapshot of the world state at any committed height. It is needed to guarantee to guarantee the integrity, and is what is references when building a _chain_ in any _blockchain_.
+
+This document defines how Pocket V1 takes a snapshot of its world state. An introduction to the requirements, types and uses of hashes in blockchain systems is outside the scope of this document.
+
+## Data Types
+
+### Block Proto
+
+persistence/proto/block_persistence.proto
+
+### Trees
+
+### Transactions Hash (?? TODO_IN_THIS_COMMIT ??)
+
+## Transactions hash
+
+## Compute State Hash
 
 This flow shows the interaction between the PostgresDB and MerkleTrees to compute the state hash.
 
 ```mermaid
 sequenceDiagram
     participant P as Persistence Module
-    participant PP as Persistence (SQLDatabase)
+    participant PP as Persistence (SQLDatabase)****
     participant PM as Persistence (MerkleTree)
 
     loop for each protocol actor type
@@ -30,24 +57,30 @@ sequenceDiagram
     deactivate P
 ```
 
-## Store Block
+## Store Block (i.e. Commit)
+
+When the `Commit(quorumCert)` function is invoke, the current context is committed to disk. The `PersistenceContext` does the following:
 
-This flow shows the interaction between the PostgresDB and Key-Value Store to compute the state hash.
+1. Read data from its own in memory state
+2. Prepare a instance of the `Block` proto & serialize it
+3. Insert the `Block` into the `BlockStore`
+4. Insert the `Block` into the SQL Store
 
 ```mermaid
 sequenceDiagram
-    %% autonumber
     participant P as Persistence
-    participant PP as Persistence (PostgresDB)
-    participant PK as Persistence (Key-Value Store)
+    participant PSQL as Persistence (SQL Store)
+    participant PKV as Persistence (Key-Value Store)
 
+    P->>P: prepare & serialize block proto
     activate P
-    P->>P: reap stored transactions
-    P->>P: prepare, serialize <br> & store block
     deactivate P
 
-    P->>+PP: insertBlock(height, serialized(block))
-    PP->>-P: result, err_code
-    P->>+PK: Put(height, serialized(block))
-    PK->>-P: result, err_code
+    %% Insert into the SQL store
+    P->>+PSQL: Insert(height, block)
+    PSQL->>-P: result, err_code
+
+    %% Insert into the Block Store (i.e. Key-Value store)
+    P->>+PKV: Put(height, block)
+    PKV->>-P: result, err_code
 ```
diff --git a/persistence/genesis.go b/persistence/genesis.go
index 1b396e2c4..ba384eafd 100644
--- a/persistence/genesis.go
+++ b/persistence/genesis.go
@@ -10,7 +10,7 @@ import (
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
-// DISCUSS: Should we make this return an error and let the caller decide if it should log a fatal error?
+// CONSIDERATION: Should this return an error and let the caller decide if it should log a fatal error?
 func (m *persistenceModule) populateGenesisState(state modules.PersistenceGenesisState) {
 	log.Println("Populating genesis state...")
 
@@ -150,15 +150,12 @@ func (m *persistenceModule) populateGenesisState(state modules.PersistenceGenesi
 		log.Fatalf("an error occurred updating the app hash during genesis: %s", err.Error())
 	}
 
-	// TODO_IN_THIS_COMMIT: Figure out what these values for genesis should be
-	genesisQuorumCert := []byte("placeholderQuorumCert")
-	genesisProposer := []byte("placeholderProposer")
-	if err := rwContext.SetProposalBlock(hex.EncodeToString(appHash), genesisProposer, genesisQuorumCert, nil); err != nil {
+	if err := rwContext.SetProposalBlock(hex.EncodeToString(appHash), nil, nil, nil); err != nil {
 		log.Fatalf("an error occurred setting the proposal block during genesis: %s", err.Error())
 	}
 
 	// This update the DB, blockstore, and commits the state
-	if err = rwContext.Commit(genesisQuorumCert); err != nil {
+	if err = rwContext.Commit(nil); err != nil {
 		log.Fatalf("error committing genesis state to DB %s ", err.Error())
 	}
 }
diff --git a/persistence/proto/block_persistence.proto b/persistence/proto/block_persistence.proto
index 71b1645ae..70af7faf0 100644
--- a/persistence/proto/block_persistence.proto
+++ b/persistence/proto/block_persistence.proto
@@ -5,9 +5,11 @@ option go_package = "github.com/pokt-network/pocket/persistence/types";
 
 message Block {
     uint64 height = 1;
-    string hash = 2;
-    string prevHash = 3; // The hash of the block at height-1
+    string stateHash = 2;
+    string prevStateHash = 3; // The stateHash of the block at height-1
     bytes proposerAddress = 4; // The proposer of this block
     bytes quorumCertificate = 5; // The quorum certificate containing signature from 2/3+ validators at height
+    // DISCUSS_IN_THIS_COMMIT: I don't think `transactionsHash` is even needed since it is captured
+    // within the `hash` via the `transactionTree`.
     bytes transactionsHash = 6; // The hash of all the translactions in the block
 }
\ No newline at end of file
diff --git a/persistence/shared_sql.go b/persistence/shared_sql.go
index b81e58b04..49c54770b 100644
--- a/persistence/shared_sql.go
+++ b/persistence/shared_sql.go
@@ -44,7 +44,7 @@ func (p *PostgresContext) GetExists(actorSchema types.ProtocolActorSchema, addre
 	return
 }
 
-func (p *PostgresContext) getActorsUpdated(actorSchema types.ProtocolActorSchema, height int64) (actors []*types.Actor, err error) {
+func (p *PostgresContext) GetActorsUpdated(actorSchema types.ProtocolActorSchema, height int64) (actors []*types.Actor, err error) {
 	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
 		return
diff --git a/persistence/state.go b/persistence/state.go
index 36d2a96a2..5e1edfa93 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -10,6 +10,7 @@ import (
 	"github.com/celestiaorg/smt"
 	"github.com/pokt-network/pocket/persistence/kvstore"
 	"github.com/pokt-network/pocket/persistence/types"
+	"github.com/pokt-network/pocket/shared/crypto"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -26,7 +27,7 @@ type stateTrees struct {
 
 // A list of Merkle Trees used to maintain the state hash.
 const (
-	// VERY IMPORTANT: The order in which these trees are defined is important and strict. It implicitly
+	// IMPORTANT: The order in which these trees are defined is important and strict. It implicitly
 	// defines the index of the root hash each independent as they are concatenated together
 	// to generate the state hash.
 
@@ -49,6 +50,12 @@ const (
 	numMerkleTrees
 )
 
+const (
+	// IMPORTANT: The order, ascending, is critical since it defines the integrity of `transactionsHash`.
+	// If this changes, the `transactionsHash`` in the block will differ, rendering it invalid.
+	txsOrderInBlockHashDescending = false
+)
+
 var merkleTreeToString = map[merkleTree]string{
 	appMerkleTree:         "app",
 	valMerkleTree:         "val",
@@ -190,6 +197,27 @@ func (p *PostgresContext) updateMerkleTrees() ([]byte, error) {
 	return stateHash[:], nil
 }
 
+// Transactions Hash Helpers
+
+// Returns a digest (a single hash) of all the transactions included in the block.
+// This allows separating the integrity of the transactions from their storage.
+func (p PostgresContext) getTxsHash() (txs []byte, err error) {
+	txResults, err := p.txIndexer.GetByHeight(p.Height, txsOrderInBlockHashDescending)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, txResult := range txResults {
+		txHash, err := txResult.Hash()
+		if err != nil {
+			return nil, err
+		}
+		txs = append(txs, txHash...)
+	}
+
+	return crypto.SHA3Hash(txs), nil
+}
+
 // Actor Tree Helpers
 
 func (p *PostgresContext) updateActorsTree(actorType types.ActorType) error {
@@ -227,7 +255,7 @@ func (p *PostgresContext) getActorsUpdatedAtHeight(actorType types.ActorType, he
 		return nil, fmt.Errorf("no schema found for actor type: %s", actorType)
 	}
 
-	schemaActors, err := p.getActorsUpdated(actorSchema, height)
+	schemaActors, err := p.GetActorsUpdated(actorSchema, height)
 	if err != nil {
 		return nil, err
 	}
@@ -320,11 +348,11 @@ func (p *PostgresContext) updateTransactionsTree() error {
 }
 
 func (p *PostgresContext) updateParamsTree() error {
-	// TODO_IN_NEXT_COMMIT(olshansky): Implement me
+	// TODO(core starter task): Implement `updateParamsTree`
 	return nil
 }
 
 func (p *PostgresContext) updateFlagsTree() error {
-	// TODO_IN_NEXT_COMMIT(olshansky): Implement me
+	// TODO(core starter task): Implement `updateParamsTree`
 	return nil
 }
diff --git a/persistence/test/generic_test.go b/persistence/test/generic_test.go
index c58d15889..cb4555f04 100644
--- a/persistence/test/generic_test.go
+++ b/persistence/test/generic_test.go
@@ -2,10 +2,11 @@ package test
 
 import (
 	"encoding/hex"
-	"github.com/pokt-network/pocket/persistence/types"
 	"reflect"
 	"testing"
 
+	"github.com/pokt-network/pocket/persistence/types"
+
 	"github.com/pokt-network/pocket/persistence"
 	"github.com/stretchr/testify/require"
 )
@@ -150,6 +151,58 @@ func getTestGetSetStakeAmountTest[T any](
 	require.Equal(t, newStakeAmount, stakeAmountAfter, "unexpected status")
 }
 
+func getAllActorsUpdatedAtHeightTest[T any](
+	t *testing.T,
+	createAndInsertTestActor func(*persistence.PostgresContext) (*T, error),
+	getActorsUpdated func(*persistence.PostgresContext, int64) ([]*T, error),
+	numActorsInTestGenesis int,
+) {
+	db := NewTestPostgresContext(t, 0)
+
+	// Check num actors in genesis
+	accs, err := getActorsUpdated(db, 0)
+	require.NoError(t, err)
+	require.Equal(t, numActorsInTestGenesis, len(accs))
+
+	// Insert a new actor at height 0
+	_, err = createAndInsertTestActor(db)
+	require.NoError(t, err)
+
+	// Verify that num actors incremented by 1
+	accs, err = getActorsUpdated(db, 0)
+	require.NoError(t, err)
+	require.Equal(t, numActorsInTestGenesis+1, len(accs))
+
+	// Close context at height 0 without committing new Pool
+	require.NoError(t, db.Close())
+	// start a new context at height 1
+	db = NewTestPostgresContext(t, 1)
+
+	// Verify that num actors at height 0 is genesis because the new one was not committed
+	accs, err = getActorsUpdated(db, 0)
+	require.NoError(t, err)
+	require.Equal(t, numActorsInTestGenesis, len(accs))
+
+	// Insert a new actor at height 1
+	_, err = createAndInsertTestActor(db)
+	require.NoError(t, err)
+
+	// Verify that num actors updated height 1 is 1
+	accs, err = getActorsUpdated(db, 1)
+	require.NoError(t, err)
+	require.Equal(t, 1, len(accs))
+
+	// Commit & close the context at height 1
+	require.NoError(t, db.Commit(nil))
+	// start a new context at height 2
+	db = NewTestPostgresContext(t, 2)
+
+	// Verify only 1 actor was updated at height 1
+	accs, err = getActorsUpdated(db, 1)
+	require.NoError(t, err)
+	require.Equal(t, 1, len(accs))
+}
+
 func getActorValues(_ types.ProtocolActorSchema, actorValue reflect.Value) *types.Actor {
 	chains := make([]string, 0)
 	if actorValue.FieldByName("Chains").Kind() != 0 {
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index 35d53533d..031f07807 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -112,9 +112,9 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 		var block types.Block
 		err = codec.GetCodec().Unmarshal(blockBz, &block)
 		require.NoError(t, err)
-		require.Equal(t, expectedAppHash, block.Hash) // verify block hash
+		require.Equal(t, expectedAppHash, block.StateHash) // verify block hash
 		if i > 0 {
-			require.Equal(t, encodedAppHash[i-1], block.PrevHash) // verify chain chain
+			require.Equal(t, encodedAppHash[i-1], block.PrevStateHash) // verify chain chain
 		}
 	}
 }
diff --git a/persistence/test/validator_test.go b/persistence/test/validator_test.go
index f5d5c1d71..0293a1108 100644
--- a/persistence/test/validator_test.go
+++ b/persistence/test/validator_test.go
@@ -24,6 +24,13 @@ func TestGetSetValidatorStakeAmount(t *testing.T) {
 	getTestGetSetStakeAmountTest(t, db, createAndInsertDefaultTestValidator, db.GetValidatorStakeAmount, db.SetValidatorStakeAmount, 1)
 }
 
+func TestGetValidatorUpdateAtHeight(t *testing.T) {
+	getValidatorsUpdatedFunc := func(db *persistence.PostgresContext, height int64) ([]*types.Actor, error) {
+		return db.GetActorsUpdated(types.ValidatorActor, height)
+	}
+	getAllActorsUpdatedAtHeightTest(t, createAndInsertDefaultTestValidator, getValidatorsUpdatedFunc, 5)
+}
+
 func TestInsertValidatorAndExists(t *testing.T) {
 	db := NewTestPostgresContext(t, 0)
 
@@ -50,7 +57,7 @@ func TestInsertValidatorAndExists(t *testing.T) {
 
 	exists, err = db.GetValidatorExists(addrBz2, 0)
 	require.NoError(t, err)
-	require.False(t, exists, "actor that should not exist at previous height validatorears to")
+	require.False(t, exists, "actor that should not exist at previous height does")
 	exists, err = db.GetValidatorExists(addrBz2, 1)
 	require.NoError(t, err)
 	require.True(t, exists, "actor that should exist at current height does not")
diff --git a/shared/docs/PROTOCOL_STATE_HASH.md b/shared/docs/PROTOCOL_STATE_HASH.md
index 27cad2d51..bbae98c30 100644
--- a/shared/docs/PROTOCOL_STATE_HASH.md
+++ b/shared/docs/PROTOCOL_STATE_HASH.md
@@ -144,7 +144,7 @@ sequenceDiagram
 4. Loop over all transactions proposed
 5. Check if the transaction has already been applied to the local state
 6. Perform the CRUD operation(s) corresponding to each transaction
-7. The persistence module's internal implementation for ['Update State Hash'](../../persistence/docs/PROTOCOL_STATE_HASH.md) must be triggered
+7. The persistence module's internal implementation for ['Compute State Hash'](../../persistence/docs/PROTOCOL_STATE_HASH.md) must be triggered
 8. Validate that the local state hash computed is the same as that proposed
 
 ```mermaid
@@ -166,12 +166,12 @@ sequenceDiagram
         end
     end
     %% TODO: Consolidate AppHash and StateHash
-    U->>+P: UpdateAppHash()
+    U->>+P: ComputeAppHash()
     P->>P: Internal Implementation
-    Note over P: Update State Hash
+    Note over P: Compute State Hash
     P->>-U: stateHash
     U->>C: stateHash
 
-    %% Validate the updated hash
+    %% Validate the computed hash
     C->>C: Compare local hash<br>against proposed hash
 ```

From 069084c27bd82140dec699d3be7b08a71f189a6f Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 16 Nov 2022 12:39:53 -0800
Subject: [PATCH 188/227] Added unit tests for all the actor retriverals

---
 persistence/test/application_test.go  | 7 +++++++
 persistence/test/fisherman_test.go    | 7 +++++++
 persistence/test/service_node_test.go | 7 +++++++
 persistence/test/validator_test.go    | 2 +-
 4 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/persistence/test/application_test.go b/persistence/test/application_test.go
index c1be72291..87357a91d 100644
--- a/persistence/test/application_test.go
+++ b/persistence/test/application_test.go
@@ -19,6 +19,13 @@ func FuzzApplication(f *testing.F) {
 		types.ApplicationActor)
 }
 
+func TestGetApplicationsUpdatedAtHeight(t *testing.T) {
+	getApplicationsUpdatedFunc := func(db *persistence.PostgresContext, height int64) ([]*types.Actor, error) {
+		return db.GetActorsUpdated(types.ApplicationActor, height)
+	}
+	getAllActorsUpdatedAtHeightTest(t, createAndInsertDefaultTestApp, getApplicationsUpdatedFunc, 1)
+}
+
 func TestInsertAppAndExists(t *testing.T) {
 	db := NewTestPostgresContext(t, 0)
 
diff --git a/persistence/test/fisherman_test.go b/persistence/test/fisherman_test.go
index 11859fde6..a22f7f9fe 100644
--- a/persistence/test/fisherman_test.go
+++ b/persistence/test/fisherman_test.go
@@ -26,6 +26,13 @@ func TestGetSetFishermanStakeAmount(t *testing.T) {
 	getTestGetSetStakeAmountTest(t, db, createAndInsertDefaultTestFisherman, db.GetFishermanStakeAmount, db.SetFishermanStakeAmount, 1)
 }
 
+func TestGetFishermanUpdatedAtHeight(t *testing.T) {
+	getFishermanUpdatedFunc := func(db *persistence.PostgresContext, height int64) ([]*types.Actor, error) {
+		return db.GetActorsUpdated(types.FishermanActor, height)
+	}
+	getAllActorsUpdatedAtHeightTest(t, createAndInsertDefaultTestFisherman, getFishermanUpdatedFunc, 1)
+}
+
 func TestInsertFishermanAndExists(t *testing.T) {
 	db := NewTestPostgresContext(t, 0)
 
diff --git a/persistence/test/service_node_test.go b/persistence/test/service_node_test.go
index 51c1e25c9..4e3f7e28b 100644
--- a/persistence/test/service_node_test.go
+++ b/persistence/test/service_node_test.go
@@ -24,6 +24,13 @@ func TestGetSetServiceNodeStakeAmount(t *testing.T) {
 	getTestGetSetStakeAmountTest(t, db, createAndInsertDefaultTestServiceNode, db.GetServiceNodeStakeAmount, db.SetServiceNodeStakeAmount, 1)
 }
 
+func TestGetServiceNodeUpdatedAtHeight(t *testing.T) {
+	getServiceNodeUpdatedFunc := func(db *persistence.PostgresContext, height int64) ([]*types.Actor, error) {
+		return db.GetActorsUpdated(types.ServiceNodeActor, height)
+	}
+	getAllActorsUpdatedAtHeightTest(t, createAndInsertDefaultTestServiceNode, getServiceNodeUpdatedFunc, 1)
+}
+
 func TestInsertServiceNodeAndExists(t *testing.T) {
 	db := NewTestPostgresContext(t, 0)
 
diff --git a/persistence/test/validator_test.go b/persistence/test/validator_test.go
index 0293a1108..86ce0db18 100644
--- a/persistence/test/validator_test.go
+++ b/persistence/test/validator_test.go
@@ -24,7 +24,7 @@ func TestGetSetValidatorStakeAmount(t *testing.T) {
 	getTestGetSetStakeAmountTest(t, db, createAndInsertDefaultTestValidator, db.GetValidatorStakeAmount, db.SetValidatorStakeAmount, 1)
 }
 
-func TestGetValidatorUpdateAtHeight(t *testing.T) {
+func TestGetValidatorUpdatedAtHeight(t *testing.T) {
 	getValidatorsUpdatedFunc := func(db *persistence.PostgresContext, height int64) ([]*types.Actor, error) {
 		return db.GetActorsUpdated(types.ValidatorActor, height)
 	}

From 609c47fe74cf6aa5d10560adbe81eccf84cd5993 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 16 Nov 2022 12:47:02 -0800
Subject: [PATCH 189/227] Fixed ShowLatestBlockInStore

---
 persistence/CHANGELOG.md       | 2 ++
 persistence/debug.go           | 6 +++---
 persistence/test/block_test.go | 2 +-
 runtime/test_artifacts/util.go | 5 ++---
 shared/node.go                 | 3 ++-
 5 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/persistence/CHANGELOG.md b/persistence/CHANGELOG.md
index d5367949a..8bd56b11b 100644
--- a/persistence/CHANGELOG.md
+++ b/persistence/CHANGELOG.md
@@ -38,6 +38,8 @@ Supporting StateHash changes
 - Consolidate all `resetContext` related operations into a single function
 - Implemented `ReleaseWriteContext`
 - Implemented ability to `ClearAllState` and `ResetToGenesis` for debugging & testing purposes
+- Added unit tests for all of the supporting SQL functions implemented
+- Some improvements in unit test preparation & cleanup (limited to this PR's functionality)
 
 KVStore changes
 
diff --git a/persistence/debug.go b/persistence/debug.go
index 546c7fdb6..b983fca5c 100644
--- a/persistence/debug.go
+++ b/persistence/debug.go
@@ -41,9 +41,9 @@ func (m *persistenceModule) HandleDebugMessage(debugMessage *debug.DebugMessage)
 	return nil
 }
 
+// IMPROVE: Add an iterator to the `kvstore` and use that instead
 func (m *persistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
-	// TODO: Add an iterator to the `kvstore` and use that instead
-	height := m.GetBus().GetConsensusModule().CurrentHeight()
+	height := m.GetBus().GetConsensusModule().CurrentHeight() - 1
 	blockBytes, err := m.GetBlockStore().Get(heightToBytes(int64(height)))
 	if err != nil {
 		log.Printf("Error getting block %d from block store: %s \n", height, err)
@@ -59,7 +59,7 @@ func (m *persistenceModule) showLatestBlockInStore(_ *debug.DebugMessage) {
 	log.Printf("Block at height %d: %+v \n", height, block)
 }
 
-// TODO: Make sure this is atomic
+// TECHDEBT: Make sure this is atomic
 func (m *persistenceModule) clearAllState(_ *debug.DebugMessage) error {
 	ctx, err := m.NewRWContext(-1)
 	if err != nil {
diff --git a/persistence/test/block_test.go b/persistence/test/block_test.go
index c92f09d3c..bd92779c6 100644
--- a/persistence/test/block_test.go
+++ b/persistence/test/block_test.go
@@ -6,7 +6,7 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestGetBlockHash(t *testing.T) {
+func TestGetBlockStateHash(t *testing.T) {
 	db := NewTestPostgresContext(t, 0)
 
 	// Cannot get prev hash at height 0
diff --git a/runtime/test_artifacts/util.go b/runtime/test_artifacts/util.go
index f692b253e..4a91c3aa7 100644
--- a/runtime/test_artifacts/util.go
+++ b/runtime/test_artifacts/util.go
@@ -95,6 +95,5 @@ func CleanupPostgresDocker(_ *testing.M, pool *dockertest.Pool, resource *docker
 	}
 }
 
-func CleanupTest(u utility.UtilityContext) {
-	// CLEANUP: Remove this since it's no longer used or necessary.
-}
+// CLEANUP: Remove this since it's no longer used or necessary.
+func CleanupTest(u utility.UtilityContext) {}
diff --git a/shared/node.go b/shared/node.go
index 92463f904..f4b2147b5 100644
--- a/shared/node.go
+++ b/shared/node.go
@@ -178,7 +178,8 @@ func (node *Node) handleDebugEvent(anyMessage *anypb.Any) error {
 		return node.GetBus().GetConsensusModule().HandleDebugMessage(&debugMessage)
 	// Persistence Debug
 	case debug.DebugMessageAction_DEBUG_SHOW_LATEST_BLOCK_IN_STORE:
-		fallthrough
+		return node.GetBus().GetPersistenceModule().HandleDebugMessage(&debugMessage)
+	// Default Debug
 	default:
 		log.Printf("Debug message: %s \n", debugMessage.Message)
 	}

From dcb99e8249805a8b144ff084da21433e6fa9fe5b Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 21 Nov 2022 17:48:36 -0800
Subject: [PATCH 190/227] Temp changes

---
 persistence/docs/PROTOCOL_STATE_HASH.md | 56 +++++++++++++++++++------
 persistence/state.go                    |  7 +++-
 2 files changed, 50 insertions(+), 13 deletions(-)

diff --git a/persistence/docs/PROTOCOL_STATE_HASH.md b/persistence/docs/PROTOCOL_STATE_HASH.md
index cefdb02a0..fb04beddd 100644
--- a/persistence/docs/PROTOCOL_STATE_HASH.md
+++ b/persistence/docs/PROTOCOL_STATE_HASH.md
@@ -5,7 +5,7 @@ This document describes the `Persistence` module's internal implementation of ho
 Alternative implementation of the persistence module are free to choose their own **State Storage** engines (SQL, KV stores, etc) or their own **State Commitment** paradigms (Merkle Trees, Vector Commitments, etc), but the output hash **must** remain identical.
 
 - [Introduction](#introduction)
-- [Data Types](#data-types)
+- [Components & Data Types](#components--data-types)
   - [Block Proto](#block-proto)
   - [Trees](#trees)
   - [Transactions Hash (?? TODO_IN_THIS_COMMIT ??)](#transactions-hash--todo_in_this_commit-)
@@ -19,7 +19,15 @@ The state hash is a single 256 bit digest that takes a snapshot of the world sta
 
 This document defines how Pocket V1 takes a snapshot of its world state. An introduction to the requirements, types and uses of hashes in blockchain systems is outside the scope of this document.
 
-## Data Types
+## Components & Data Types
+
+| Component | Data Type | Implementation Option Examples | Implementation Selected | Examples | Use Case |
+
+| Block message | Serialization Code | Amino, Protobuf, Thrift | Protobuf | Block protobuf | Serialized and inserted into the Block Store |
+| Block Store | Key Value Store | LevelDB, BadgerDB,  | |
+| SQL Tables | SQL Database / Engine | MySQL, SQLite, PostgreSQL | Account SQL Table, Tra |
+| Merkle Trees | Sparse Merkle Trie backed by Key-Value Store | Celestia's SMT variation of Libra's JMT | Account SMT, Transactions SMT, etc... |
+| Tx Indexer | Key Value Store |
 
 ### Block Proto
 
@@ -27,6 +35,25 @@ persistence/proto/block_persistence.proto
 
 ### Trees
 
+- Sparse Merkle Tree
+- KV Store
+
+appMerkleTree
+valMerkleTree
+fishMerkleTree
+serviceNodeMerkleTree
+
+    //
+
+accountMerkleTree
+poolMerkleTree
+
+    //
+
+transactionsMerkleTree
+paramsMerkleTree
+flagsMerkleTree
+
 ### Transactions Hash (?? TODO_IN_THIS_COMMIT ??)
 
 ## Transactions hash
@@ -35,21 +62,26 @@ persistence/proto/block_persistence.proto
 
 This flow shows the interaction between the PostgresDB and MerkleTrees to compute the state hash.
 
+_Note: `GetRecordsUpdatedAtHeight` is an abstraction for retrieving all the records from the corresponding SQL tables depending on the type of record (Actors, Transactions, Params, etc...)_
+
+1. Loop over all of the merkle tree types
+2. GetRecordsUpdatedAtHeight
+
 ```mermaid
 sequenceDiagram
-    participant P as Persistence Module
-    participant PP as Persistence (SQLDatabase)****
-    participant PM as Persistence (MerkleTree)
+    participant P as Persistence
+    participant PSQL as Persistence (SQL Store)
+    participant PKV as Persistence (Key-Value Store)
 
-    loop for each protocol actor type
-        P->>+PP: GetActorsUpdated(height)
-        PP->>-P: actors
+    loop for each merkle tree type
+        P->>+PSQL: GetRecordsUpdatedAtHeight(height)
+        PSQL->>-P: records
         loop for each state tree
-            P->>+PM: Update(addr, serialized(actor))
-            PM->>-P: result, err_code
+            P->>+PKV: Update(addr, serialized(actor))
+            PKV->>-P: result, err_code
         end
-        P->>+PM: GetRoot()
-        PM->>-P: rootHash
+        P->>+PKV: GetRoot()
+        PKV->>-P: rootHash
     end
 
     P->>P: stateHash = hash(aggregated(rootHashes))
diff --git a/persistence/state.go b/persistence/state.go
index 5e1edfa93..465e2ec5d 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -184,6 +184,10 @@ func (p *PostgresContext) updateMerkleTrees() ([]byte, error) {
 		}
 	}
 
+	return p.getStateHash(), nil
+}
+
+func (p *PostgresContext) getStateHash() []byte {
 	// Get the root of each Merkle Tree
 	roots := make([][]byte, 0)
 	for tree := merkleTree(0); tree < numMerkleTrees; tree++ {
@@ -194,7 +198,8 @@ func (p *PostgresContext) updateMerkleTrees() ([]byte, error) {
 	rootsConcat := bytes.Join(roots, []byte{})
 	stateHash := sha256.Sum256(rootsConcat)
 
-	return stateHash[:], nil
+	// Convert the array to a slice and return it
+	return stateHash[:]
 }
 
 // Transactions Hash Helpers

From aca2b234fd86720b6078f77f33cf466d25974198 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 21 Nov 2022 19:16:26 -0800
Subject: [PATCH 191/227] Improve diagram for high vs locked QC

---
 consensus/debugging.go             |  1 +
 consensus/hotstuff_leader.go       |  5 ++---
 consensus/module.go                |  4 +++-
 consensus/pacemaker.go             |  2 +-
 shared/docs/PROTOCOL_STATE_HASH.md | 10 ++++++++--
 5 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/consensus/debugging.go b/consensus/debugging.go
index 4646a9919..4cf015ebf 100644
--- a/consensus/debugging.go
+++ b/consensus/debugging.go
@@ -96,6 +96,7 @@ type paceMakerDebug struct {
 	manualMode                bool
 	debugTimeBetweenStepsMsec uint64
 
+	// IMPROVE: Consider renaming to `previousRoundQC`
 	quorumCertificate *typesCons.QuorumCertificate
 }
 
diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 16bc9a306..324639187 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -52,6 +52,7 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *consensusM
 	// TECHDEBT: How do we properly validate `highPrepareQC` here?
 	highPrepareQC := m.findHighQC(m.messagePool[NewRound])
 
+	// TODO: Add test to make sure same block is not applied twice if round is interrupted after being 'Applied'.
 	// TODO: Add more unit tests for these checks...
 	if m.shouldPrepareNewBlock(highPrepareQC) {
 		// Leader prepares a new block if `highPrepareQC` is not applicable
@@ -63,10 +64,8 @@ func (handler *HotstuffLeaderMessageHandler) HandleNewRoundMessage(m *consensusM
 		}
 		m.Block = block
 	} else {
-		// DISCUSS: Do we need to call `validateProposal` here?
 		// Leader acts like a replica if `highPrepareQC` is not `nil`
-		// TODO(olshansky): Add test to make sure same block is not applied twice if round is interrrupted.
-		// been 'Applied'
+		// TODO: Do we need to call `validateProposal` here similar to how replicas does it
 		if err := m.applyBlock(highPrepareQC.Block); err != nil {
 			m.nodeLogError(typesCons.ErrApplyBlock.Error(), err)
 			m.paceMaker.InterruptRound()
diff --git a/consensus/module.go b/consensus/module.go
index e6c8636b4..f8b52d1f4 100644
--- a/consensus/module.go
+++ b/consensus/module.go
@@ -50,6 +50,7 @@ type consensusModule struct {
 	//    TODO(#315):  Move the statefulness of `TxResult` to the persistence module
 	TxResults []modules.TxResult // The current block applied transaction results / voted on; it has not been committed to finality
 
+	// IMPROVE: Consider renaming `highPrepareQC` to simply `prepareQC`
 	highPrepareQC *typesCons.QuorumCertificate // Highest QC for which replica voted PRECOMMIT
 	lockedQC      *typesCons.QuorumCertificate // Highest QC for which replica voted COMMIT
 
@@ -71,7 +72,8 @@ type consensusModule struct {
 	// DEPRECATE: Remove later when we build a shared/proper/injected logger
 	logPrefix string
 
-	// TECHDEBT: Move this over to use the txIndexer
+	// TECHDEBT: Rename this to `consensusMessagePool` or something similar
+	//           and reconsider if an in-memory map is the best approach
 	messagePool map[typesCons.HotstuffStep][]*typesCons.HotstuffMessage
 }
 
diff --git a/consensus/pacemaker.go b/consensus/pacemaker.go
index 203b43cdf..45a6839e7 100644
--- a/consensus/pacemaker.go
+++ b/consensus/pacemaker.go
@@ -233,7 +233,7 @@ func (p *paceMaker) startNextView(qc *typesCons.QuorumCertificate, forceNextView
 		p.consensusMod.utilityContext = nil
 	}
 
-	// TODO(olshansky): This if structure for debug purposes only; think of a way to externalize it...
+	// TECHDEBT: This if structure for debug purposes only; think of a way to externalize it from the main consensus flow...
 	if p.manualMode && !forceNextView {
 		p.quorumCertificate = qc
 		return
diff --git a/shared/docs/PROTOCOL_STATE_HASH.md b/shared/docs/PROTOCOL_STATE_HASH.md
index 327acdae2..4e8328f2f 100644
--- a/shared/docs/PROTOCOL_STATE_HASH.md
+++ b/shared/docs/PROTOCOL_STATE_HASH.md
@@ -103,13 +103,19 @@ graph TD
     C[Am I the leader?] --> |Yes| D
     C[Am I the leader?] --> |No| Z
 
-    D[Did I get any prepareQCs?] --> |Find highest valid PrepareQC| E
+    D[Did I get any prepareQCs?] --> |Find highest valid prepareQC| E
     D[Did I get any prepareQCs?] --> |No| Z
 
     E[Am I ahead of highPrepareQC?] --> |Yes| G
     E[Am I ahead of highPrepareQC?] --> |No| Z
 
-    G[CreateAndApplyProposalBlock]
+    G[Do I have a lockedQC] --> |No| H
+    G[Do I have a lockedQC] --> |Yes| I
+
+    I[Is highPrepareQC.view > lockedQC.view] --> |"No<br>(lockedQC.block)"| Z
+    I[Is highPrepareQC.view > lockedQC.view] --> |"Yes<br>(highPrepareQC.block)"| Z
+
+    H[CreateAndApplyProposalBlock]
     Z[ApplyBlock]
 ```
 

From e7f624e3e7ff11372e06897a816e486563d15d00 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sun, 27 Nov 2022 14:46:19 -0800
Subject: [PATCH 192/227] Olshansky self-review; round 3

---
 consensus/CHANGELOG.md                    |  4 ++--
 consensus/consensus_tests/utils_test.go   |  7 +++----
 persistence/CHANGELOG.md                  | 13 ++++++-------
 persistence/block.go                      |  4 ++--
 persistence/context.go                    | 22 ++++------------------
 persistence/db.go                         |  4 ++--
 persistence/docs/PROTOCOL_STATE_HASH.md   |  6 +++---
 persistence/kvstore/kvstore.go            |  1 -
 persistence/proto/block_persistence.proto |  3 +--
 persistence/state.go                      |  4 ++--
 persistence/test/benchmark_state_test.go  |  3 ++-
 persistence/test/state_test.go            | 16 +++++++++-------
 runtime/test_artifacts/generator.go       |  1 +
 shared/CHANGELOG.md                       | 15 ++++++++++++++-
 shared/docs/PROTOCOL_STATE_HASH.md        |  2 --
 shared/modules/doc/CHANGELOG.md           |  9 +++++++++
 shared/modules/persistence_module.go      |  2 +-
 utility/doc/CHANGELOG.md                  |  4 ++++
 utility/test/module_test.go               |  4 ++--
 19 files changed, 67 insertions(+), 57 deletions(-)

diff --git a/consensus/CHANGELOG.md b/consensus/CHANGELOG.md
index 36d5e9375..31cdb36bd 100644
--- a/consensus/CHANGELOG.md
+++ b/consensus/CHANGELOG.md
@@ -7,9 +7,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.0.0.9] - 2022-11-16
+## [0.0.0.9] - 2022-11-27
 
-- Propagate `hightPrepareQC` if available to the block being created
+- Propagate `highPrepareQC` if available to the block being created
 - Remove `blockProtoBytes` from propagation in `SetProposalBlock`
 - Guarantee that write context is released when refreshing the utility context
 - Use `GetBlockHash(height)` instead of `GetPrevAppHash` to be more explicit
diff --git a/consensus/consensus_tests/utils_test.go b/consensus/consensus_tests/utils_test.go
index 520fbe7b0..8fe54c90b 100644
--- a/consensus/consensus_tests/utils_test.go
+++ b/consensus/consensus_tests/utils_test.go
@@ -141,8 +141,8 @@ func CreateTestConsensusPocketNode(
 	utilityMock := baseUtilityMock(t, testChannel)
 	telemetryMock := baseTelemetryMock(t, testChannel)
 	loggerMock := baseLoggerMock(t, testChannel)
-  rpcMock := baseRpcMock(t, testChannel)
-  
+	rpcMock := baseRpcMock(t, testChannel)
+
 	bus, err := shared.CreateBus(runtimeMgr, persistenceMock, p2pMock, utilityMock, consensusMod.(modules.ConsensusModule), telemetryMock, loggerMock, rpcMock)
 
 	require.NoError(t, err)
@@ -157,7 +157,7 @@ func CreateTestConsensusPocketNode(
 	return pocketNode
 }
 
-// TODO: Reduce package scope visibility in the consensus test module
+// CLEANUP: Reduce package scope visibility in the consensus test module
 func StartAllTestPocketNodes(t *testing.T, pocketNodes IdToNodeMapping) {
 	for _, pocketNode := range pocketNodes {
 		go pocketNode.Start()
@@ -305,7 +305,6 @@ func basePersistenceMock(t *testing.T, _ modules.EventsChannel) *modulesMock.Moc
 	persistenceMock := modulesMock.NewMockPersistenceModule(ctrl)
 	persistenceContextMock := modulesMock.NewMockPersistenceRWContext(ctrl)
 
-	// TODO_IN_THIS_COMMIT(olshansky): figure out why bugs in the non main go channel block rather than fails
 	persistenceMock.EXPECT().Start().Return(nil).AnyTimes()
 	persistenceMock.EXPECT().SetBus(gomock.Any()).Return().AnyTimes()
 	persistenceMock.EXPECT().NewReadContext(int64(-1)).Return(persistenceContextMock, nil).AnyTimes()
diff --git a/persistence/CHANGELOG.md b/persistence/CHANGELOG.md
index 8bd56b11b..7e878a823 100644
--- a/persistence/CHANGELOG.md
+++ b/persistence/CHANGELOG.md
@@ -9,25 +9,24 @@ TODO: consolidate `persistence/docs/CHANGELOG` and `persistence/CHANGELOG.md`
 
 ## [Unreleased]
 
-## [0.0.0.9] - 2022-11-16
+## [0.0.0.9] - 2022-11-27
 
 Core StateHash changes
 
 - Introduced & defined for `block_persistence.proto`
+  - A persistence specific protobuf for the Block stored in the BlockStore
 - On `Commit`, prepare and store a persistence block in the KV Store, SQL Store
 - Replace `IndexTransactions` (plural) to `IndexTransaction` (singular)
-- Implement `ComputeStateHash`
--
 - Maintaining a list of StateTrees using Celestia’s SMT and badger as the KV store to compute the state hash
-- Implemented ComputeStateHash to update the global state based on:
+- Implemented `ComputeStateHash` to update the global state based on:
   - Validators
   - Applications
   - Servicers
-  - Fisherpeople
+  - Fisherman
   - Accounts
-  - Polols
+  - Pools
   - Transactions
-  - Placeholder for flags & params created
+  - Added a placeholder for `params` and `flags`
 - Added a benchmarking and a determinism test suite to validate this
 
 Supporting StateHash changes
diff --git a/persistence/block.go b/persistence/block.go
index 2b9f6a2de..5452f3e39 100644
--- a/persistence/block.go
+++ b/persistence/block.go
@@ -9,7 +9,7 @@ import (
 	"github.com/pokt-network/pocket/shared/codec"
 )
 
-// OPTIMIZE(team): get from blockstore or keep in memory
+// OPTIMIZE: evaluate if it's faster to get this from the blockstore (or cache) than the SQL engine
 func (p PostgresContext) GetLatestBlockHeight() (latestHeight uint64, err error) {
 	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
@@ -20,7 +20,7 @@ func (p PostgresContext) GetLatestBlockHeight() (latestHeight uint64, err error)
 	return
 }
 
-// OPTIMIZE: get from blockstore or keep in cache/memory
+// OPTIMIZE: evaluate if it's  faster to get this from the blockstore (or cache) than the SQL engine
 func (p PostgresContext) GetBlockHash(height int64) ([]byte, error) {
 	ctx, tx, err := p.getCtxAndTx()
 	if err != nil {
diff --git a/persistence/context.go b/persistence/context.go
index 68abf05a7..6642c9540 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -1,6 +1,6 @@
 package persistence
 
-// TECHDEBT: Figure out why the receivers here aren't pointers?
+// TECHDEBT: Look into whether the receivers of `PostgresContext` could/should be pointers?
 
 import (
 	"context"
@@ -21,23 +21,8 @@ func (p PostgresContext) RollbackToSavePoint(bytes []byte) error {
 }
 
 func (p *PostgresContext) ComputeAppHash() ([]byte, error) {
-	// !!! DISCUSS_IN_THIS_COMMIT !!!
-
-	// `PostgresContext` contains a `blockHash` in its state set by `SetProposalBlock`.
-	// The caller of `ComputeAppHash` is responsible (given the context) to compare
-	// the return hash with the proposed hash (if that is the case).
-
-	// Situations:
-	// 	1. What if `p.updateMerkleTrees()` != `p.blockHash` && `p.blockHash` != nil?
-	// 	2. Do we set `p.blockHash` =`p.updateMerkleTrees()` if it's nil?
-	// 	3. In `SetProposalBlock`,
-
-	// Future work: Need to implement rollback of the trees (i.e. key-value stores) alongside the SQL DB transaction.
-
-	// 1. Should we compare the `appHash` returned from `updateMerkleTrees`?
-	// 2. Should this update the internal state of the context?
-	// Idea: If `p.blockHash` is nil => update it
-	//       If `p.blockHash` is nil => compare it with the return value of `updateMerkleTrees` and error if different
+	// IMPROVE(#361): Guarantee the integrity of the state
+	//                Full details in the thread from the PR review: https://github.com/pokt-network/pocket/pull/285/files?show-viewed-files=true&file-filters%5B%5D=#r1033002640
 	return p.updateMerkleTrees()
 }
 
@@ -90,6 +75,7 @@ func (p PostgresContext) Close() error {
 	return p.conn.Close(context.TODO())
 }
 
+// INVESTIGATE(#361): Revisit if is used correctly in the context of the lifecycle of a persistenceContext and a utilityContext
 func (p PostgresContext) IndexTransaction(txResult modules.TxResult) error {
 	return p.txIndexer.Index(txResult)
 }
diff --git a/persistence/db.go b/persistence/db.go
index 64c619fe8..2f0d7cb1b 100644
--- a/persistence/db.go
+++ b/persistence/db.go
@@ -41,14 +41,14 @@ type PostgresContext struct {
 	conn   *pgx.Conn
 	tx     pgx.Tx
 
-	// TECHDEBT: These three values are pointers to objects maintained by the PersistenceModule,
+	// TECHDEBT(#361): These three values are pointers to objects maintained by the PersistenceModule,
 	// so there should be a better way to access them (via the bus?) rather than embedding here.
 	blockStore kvstore.KVStore
 	txIndexer  indexer.TxIndexer
 	stateTrees *stateTrees
 
+	// DISCUSS(#361): Could/should we move these to the utilityContext?
 	// IMPROVE: Could/should we rename these to proposalXX?
-	// DISCUSS: Could/should we move these to the utilityContext?
 	proposerAddr []byte
 	quorumCert   []byte
 	blockHash    string // CONSOLIDATE: blockHash / appHash / stateHash
diff --git a/persistence/docs/PROTOCOL_STATE_HASH.md b/persistence/docs/PROTOCOL_STATE_HASH.md
index fb04beddd..caea0ec49 100644
--- a/persistence/docs/PROTOCOL_STATE_HASH.md
+++ b/persistence/docs/PROTOCOL_STATE_HASH.md
@@ -5,10 +5,10 @@ This document describes the `Persistence` module's internal implementation of ho
 Alternative implementation of the persistence module are free to choose their own **State Storage** engines (SQL, KV stores, etc) or their own **State Commitment** paradigms (Merkle Trees, Vector Commitments, etc), but the output hash **must** remain identical.
 
 - [Introduction](#introduction)
-- [Components & Data Types](#components--data-types)
+- [Components \& Data Types](#components--data-types)
   - [Block Proto](#block-proto)
   - [Trees](#trees)
-  - [Transactions Hash (?? TODO_IN_THIS_COMMIT ??)](#transactions-hash--todo_in_this_commit-)
+  - [Transactions Hash (?? TODO\_IN\_THIS\_COMMIT ??)](#transactions-hash--todo_in_this_commit-)
 - [Transactions hash](#transactions-hash)
 - [Compute State Hash](#compute-state-hash)
 - [Store Block (i.e. Commit)](#store-block-ie-commit)
@@ -24,7 +24,7 @@ This document defines how Pocket V1 takes a snapshot of its world state. An intr
 | Component | Data Type | Implementation Option Examples | Implementation Selected | Examples | Use Case |
 
 | Block message | Serialization Code | Amino, Protobuf, Thrift | Protobuf | Block protobuf | Serialized and inserted into the Block Store |
-| Block Store | Key Value Store | LevelDB, BadgerDB,  | |
+| Block Store | Key Value Store | LevelDB, BadgerDB, | |
 | SQL Tables | SQL Database / Engine | MySQL, SQLite, PostgreSQL | Account SQL Table, Tra |
 | Merkle Trees | Sparse Merkle Trie backed by Key-Value Store | Celestia's SMT variation of Libra's JMT | Account SMT, Transactions SMT, etc... |
 | Tx Indexer | Key Value Store |
diff --git a/persistence/kvstore/kvstore.go b/persistence/kvstore/kvstore.go
index 1d172ef23..f0a2d7976 100644
--- a/persistence/kvstore/kvstore.go
+++ b/persistence/kvstore/kvstore.go
@@ -87,7 +87,6 @@ func (store *badgerKVStore) Get(key []byte) ([]byte, error) {
 	return value, nil
 }
 
-// TODO_IN_THIS_COMMIT: Add tests for this new function
 func (store *badgerKVStore) Delete(key []byte) error {
 	tx := store.db.NewTransaction(true)
 	defer tx.Discard()
diff --git a/persistence/proto/block_persistence.proto b/persistence/proto/block_persistence.proto
index 70af7faf0..40b52f91e 100644
--- a/persistence/proto/block_persistence.proto
+++ b/persistence/proto/block_persistence.proto
@@ -9,7 +9,6 @@ message Block {
     string prevStateHash = 3; // The stateHash of the block at height-1
     bytes proposerAddress = 4; // The proposer of this block
     bytes quorumCertificate = 5; // The quorum certificate containing signature from 2/3+ validators at height
-    // DISCUSS_IN_THIS_COMMIT: I don't think `transactionsHash` is even needed since it is captured
-    // within the `hash` via the `transactionTree`.
+    // INVESTIGATE(#361): Decide if we neeed `transactionsHash` given that it is capture in the `transactionsTree`.
     bytes transactionsHash = 6; // The hash of all the translactions in the block
 }
\ No newline at end of file
diff --git a/persistence/state.go b/persistence/state.go
index 465e2ec5d..f2cc65417 100644
--- a/persistence/state.go
+++ b/persistence/state.go
@@ -353,11 +353,11 @@ func (p *PostgresContext) updateTransactionsTree() error {
 }
 
 func (p *PostgresContext) updateParamsTree() error {
-	// TODO(core starter task): Implement `updateParamsTree`
+	// TODO(#361): Create a core starter task to implement this
 	return nil
 }
 
 func (p *PostgresContext) updateFlagsTree() error {
-	// TODO(core starter task): Implement `updateParamsTree`
+	// TODO(#361): Create a core starter task to implement this
 	return nil
 }
diff --git a/persistence/test/benchmark_state_test.go b/persistence/test/benchmark_state_test.go
index 73e2e0a20..b4ce68f02 100644
--- a/persistence/test/benchmark_state_test.go
+++ b/persistence/test/benchmark_state_test.go
@@ -25,6 +25,7 @@ var isModifierRe = regexp.MustCompile(`^(Insert|Set|Add|Subtract)`) // Add Updat
 
 // INVESTIGATE: This benchmark can be used to experiment with different Merkle Tree implementations
 // and key-value stores.
+// IMPROVE(#361): Improve the output of this benchmark to be more informative and human readable.
 func BenchmarkStateHash(b *testing.B) {
 	log.SetOutput(ioutil.Discard)
 	defer log.SetOutput(os.Stderr)
@@ -70,7 +71,7 @@ func BenchmarkStateHash(b *testing.B) {
 					db.IndexTransaction(modules.TxResult(getRandomTxResult(height)))
 				}
 				db.ComputeAppHash()
-				db.Commit([]byte("TODOquorumCert"))
+				db.Commit([]byte("placeholder"))
 				db.Release()
 			}
 		})
diff --git a/persistence/test/state_test.go b/persistence/test/state_test.go
index 031f07807..f344f46ae 100644
--- a/persistence/test/state_test.go
+++ b/persistence/test/state_test.go
@@ -119,10 +119,10 @@ func TestStateHash_DeterministicStateWhenUpdatingAppStake(t *testing.T) {
 	}
 }
 
+// This unit test generates random transactions and creates random state changes, but checks
+// that replaying them will result in the same state hash, guaranteeing the integrity of the
+// state hash.
 func TestStateHash_ReplayingRandomTransactionsIsDeterministic(t *testing.T) {
-	t.Cleanup(clearAllState)
-	clearAllState()
-
 	testCases := []struct {
 		numHeights      int64
 		numTxsPerHeight int
@@ -130,7 +130,7 @@ func TestStateHash_ReplayingRandomTransactionsIsDeterministic(t *testing.T) {
 		numReplays      int
 	}{
 		{1, 2, 1, 3},
-		// {10, 2, 5, 5},
+		{10, 2, 5, 5},
 	}
 
 	for _, testCase := range testCases {
@@ -140,6 +140,9 @@ func TestStateHash_ReplayingRandomTransactionsIsDeterministic(t *testing.T) {
 		numReplays := testCase.numReplays
 
 		t.Run(fmt.Sprintf("ReplayingRandomTransactionsIsDeterministic(%d;%d,%d,%d", numHeights, numTxsPerHeight, numOpsPerTx, numReplays), func(t *testing.T) {
+			t.Cleanup(clearAllState)
+			clearAllState()
+
 			replayableBlocks := make([]*TestReplayableBlock, numHeights)
 
 			for height := int64(0); height < int64(numHeights); height++ {
@@ -197,12 +200,11 @@ func TestStateHash_ReplayingRandomTransactionsIsDeterministic(t *testing.T) {
 }
 
 func TestStateHash_TreeUpdatesAreIdempotent(t *testing.T) {
-	// TODO_IN_THIS_COMMIT: Running the same oepration at the same height should not result in a
-	// a different hash because the final state is still the same.
+	// ADDTEST(#361): Create an issue dedicated to increasing the test coverage for state hashes
 }
 
 func TestStateHash_TreeUpdatesNegativeTestCase(t *testing.T) {
-	// TODO_IN_NEXT_COMMIT: Implement me
+	// ADDTEST(#361): Create an issue dedicated to increasing the test coverage for state hashes
 }
 
 func verifyReplayableBlocks(t *testing.T, replayableBlocks []*TestReplayableBlock) {
diff --git a/runtime/test_artifacts/generator.go b/runtime/test_artifacts/generator.go
index 43d544b20..313e4028f 100644
--- a/runtime/test_artifacts/generator.go
+++ b/runtime/test_artifacts/generator.go
@@ -27,6 +27,7 @@ import (
 //       refactored. Alternatively, the seed would need to be passed via the runtime manager.
 //       To avoid these large scale changes, this is a temporary approach to enable deterministic
 //       key generation.
+// IMPROVE(#361): Design a better way to generate deterministic keys for testing.
 const PrivateKeySeedEnv = "DEFAULT_PRIVATE_KEY_SEED"
 
 var privateKeySeed int
diff --git a/shared/CHANGELOG.md b/shared/CHANGELOG.md
index 02d7d1b2c..68d2c4c42 100644
--- a/shared/CHANGELOG.md
+++ b/shared/CHANGELOG.md
@@ -7,7 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.0.3] - 2022-11-14
+## [0.0.0.4] - 2022-11-27
+
+Debug:
+
+- `ResetToGenesis` - Added the ability to reset the state to genesis
+- `ClearState` - Added the ability to clear the state completely (height 0 without genesis data)
+
+Configs:
+
+- Updated the test generator to produce deterministic keys
+- Added `trees_store_dir` to persistence configs
+- Updated `LocalNet` configs to have an empty `tx_indexer_path` and `trees_store_dir`
+
+## [0.0.0.3] - 2022-11-14
 
 ### [#353](https://github.com/pokt-network/pocket/pull/353) Remove topic from messaging
 
diff --git a/shared/docs/PROTOCOL_STATE_HASH.md b/shared/docs/PROTOCOL_STATE_HASH.md
index 55f6d8ff6..1300df563 100644
--- a/shared/docs/PROTOCOL_STATE_HASH.md
+++ b/shared/docs/PROTOCOL_STATE_HASH.md
@@ -1,7 +1,5 @@
 # State Hash <!-- omit in toc -->
 
-TODO_IN_THIS_COMMIT: Make the appropriate updates necessary to the flow based on discussion items
-
 This document describes the cross-module communication using the interfaces in [../shared/modules](../shared/modules) to compute a new state hash. See module specific documentation & implementation details inside each module respectively.
 
 - [Context Management](#context-management)
diff --git a/shared/modules/doc/CHANGELOG.md b/shared/modules/doc/CHANGELOG.md
index 4312d25c9..60098dd4d 100644
--- a/shared/modules/doc/CHANGELOG.md
+++ b/shared/modules/doc/CHANGELOG.md
@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.0.4] - 2022-11-27
+
+- Removed `GetPrevHash` and just using `GetBlockHash` instead
+- Removed `blockProtoBz` from `SetProposalBlock` interface
+- Removed `GetLatestBlockTxs` and `SetLatestTxResults` in exchange for `IndexTransaction`
+- Removed `SetTxResults`
+- Renamed `UpdateAppHash` to `ComputeStateHash`
+- Removed some getters related to the proposal block (`GetBlockTxs`, `GetBlockHash`, etc…)
+
 ## [0.0.0.3] - 2022-11-15
 
 PersistenceModule
diff --git a/shared/modules/persistence_module.go b/shared/modules/persistence_module.go
index 7595c381e..af10ac3de 100644
--- a/shared/modules/persistence_module.go
+++ b/shared/modules/persistence_module.go
@@ -61,7 +61,7 @@ type PersistenceWriteContext interface {
 	SetProposalBlock(blockHash string, proposerAddr []byte, quorumCert []byte, transactions [][]byte) error
 	GetBlockTxs() [][]byte                    // Returns the transactions set by `SetProposalBlock`
 	ComputeAppHash() ([]byte, error)          // Update the merkle trees, computes the new state hash, and returns in
-	IndexTransaction(txResult TxResult) error // DISCUSS_IN_THIS_COMMIT: How can we remove `TxResult` from the public interface?
+	IndexTransaction(txResult TxResult) error // TODO(#361): Look into an approach to remove `TxResult` from shared interfaces
 
 	// Pool Operations
 	AddPoolAmount(name string, amount string) error
diff --git a/utility/doc/CHANGELOG.md b/utility/doc/CHANGELOG.md
index 551eec1c8..3c4609ea6 100644
--- a/utility/doc/CHANGELOG.md
+++ b/utility/doc/CHANGELOG.md
@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.0.11] - 2022-11-27
+
+- Minor lifecycle changes needed to supported the implementation of `ComputeAppHash` as a replacement for `GetAppHash` in #285
+
 ## [0.0.0.10] - 2022-11-15
 
 - Propagating the `quorumCertificate` appropriately on block commit
diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index 60b6842a6..c4d7354bd 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -63,8 +63,8 @@ func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext
 	require.NoError(t, err)
 
 	// TECHDEBT: Move the internal of cleanup into a separate function and call this in the
-	// beginning of every test. This is an issue because if we call `NewTestingUtilityContext` more
-	// than once in a single test, we create unnecessary calls to clean.
+	// beginning of every test. This (the current implementation) is an issue because if we call
+	// `NewTestingUtilityContext` more than once in a single test, we create unnecessary calls to clean.
 	t.Cleanup(func() {
 		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
 		require.NoError(t, testPersistenceMod.HandleDebugMessage(&messaging.DebugMessage{

From f23651d3d5806fae7805f80af9fd54a75cbaa53c Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sun, 27 Nov 2022 15:21:11 -0800
Subject: [PATCH 193/227] Update persistence/docs/PROTOCOL_STATE_HASH.md

---
 persistence/docs/PROTOCOL_STATE_HASH.md | 89 ++++++++++++++-----------
 1 file changed, 51 insertions(+), 38 deletions(-)

diff --git a/persistence/docs/PROTOCOL_STATE_HASH.md b/persistence/docs/PROTOCOL_STATE_HASH.md
index caea0ec49..0e4c99767 100644
--- a/persistence/docs/PROTOCOL_STATE_HASH.md
+++ b/persistence/docs/PROTOCOL_STATE_HASH.md
@@ -5,67 +5,71 @@ This document describes the `Persistence` module's internal implementation of ho
 Alternative implementation of the persistence module are free to choose their own **State Storage** engines (SQL, KV stores, etc) or their own **State Commitment** paradigms (Merkle Trees, Vector Commitments, etc), but the output hash **must** remain identical.
 
 - [Introduction](#introduction)
-- [Components \& Data Types](#components--data-types)
+- [Data Types](#data-types)
+  - [Infrastructural Components](#infrastructural-components)
   - [Block Proto](#block-proto)
   - [Trees](#trees)
-  - [Transactions Hash (?? TODO\_IN\_THIS\_COMMIT ??)](#transactions-hash--todo_in_this_commit-)
-- [Transactions hash](#transactions-hash)
 - [Compute State Hash](#compute-state-hash)
-- [Store Block (i.e. Commit)](#store-block-ie-commit)
+- [Store Block (Commit)](#store-block-commit)
 
 ## Introduction
 
-The state hash is a single 256 bit digest that takes a snapshot of the world state at any committed height. It is needed to guarantee to guarantee the integrity, and is what is references when building a _chain_ in any _blockchain_.
+The state hash is a single 256 bit digest that takes a snapshot of the world state at any committed height. It is needed to guarantee and prove the integrity of the world state, and is what's referenced in every block header when building any _blockchain_.
 
 This document defines how Pocket V1 takes a snapshot of its world state. An introduction to the requirements, types and uses of hashes in blockchain systems is outside the scope of this document.
 
-## Components & Data Types
+## Data Types
 
-| Component | Data Type | Implementation Option Examples | Implementation Selected | Examples | Use Case |
+### Infrastructural Components
 
-| Block message | Serialization Code | Amino, Protobuf, Thrift | Protobuf | Block protobuf | Serialized and inserted into the Block Store |
-| Block Store | Key Value Store | LevelDB, BadgerDB, | |
-| SQL Tables | SQL Database / Engine | MySQL, SQLite, PostgreSQL | Account SQL Table, Tra |
-| Merkle Trees | Sparse Merkle Trie backed by Key-Value Store | Celestia's SMT variation of Libra's JMT | Account SMT, Transactions SMT, etc... |
-| Tx Indexer | Key Value Store |
+| Component             | Data Type                             | Implementation Options - Examples                      | Implementation Selected - Current | Example             | Use Case                                                                         |
+| --------------------- | ------------------------------------- | ------------------------------------------------------ | --------------------------------- | ------------------- | -------------------------------------------------------------------------------- |
+| Data Tables           | SQL Database / Engine                 | MySQL, SQLite, PostgreSQL                              | PostgresSQL                       | Validator SQL Table | Validating & updating information when applying a transaction                    |
+| Merkle Trees          | Merkle Trie backed by Key-Value Store | Celestia's SMT, Libra's JMT, Cosmos' IAVL, Verkle Tree | Celestia's SMT                    | Fisherman Trie      | Maintains the state of all account based trees                                   |
+| Blocks                | Serialization Codec                   | Amino, Protobuf, Thrift, Avro                          | Protobuf                          | Block protobuf      | Serialized and inserted into the Block Store                                     |
+| Objects (e.g. Actors) | Serialization Codec                   | Amino, Protobuf, Thrift, Avro                          | Protobuf                          | Servicer protobuf   | Serialized and inserted into the corresponding Tree                              |
+| Block Store           | Key Value Store                       | LevelDB, BadgerDB, RocksDB, BoltDB                     | BadgerDb                          | Block Store         | Maintains a key-value store of the blockchain blocks                             |
+| Transaction Indexer   | Key Value Store                       | LevelDB, BadgerDB, RocksDB, BoltDB                     | BadgerDB                          | Tx Indexer          | Indexes transactions in different ways for fast queries, presence checks, etc... |
 
 ### Block Proto
 
-persistence/proto/block_persistence.proto
+The block protobuf that is serialized and store in the block store can be found in `persistence/proto/block_persistence.proto`. This proto contains the `stateHash` along with the corresponding height.
 
 ### Trees
 
-- Sparse Merkle Tree
-- KV Store
+An individual Merkle Tree is created for each type of actor, record or data type. Each of these is backed by its own key-value store.
 
-appMerkleTree
-valMerkleTree
-fishMerkleTree
-serviceNodeMerkleTree
+**Actor Merkle Trees**:
 
-    //
+- Applications
+- Validators
+- Fisherman
+- ServiceNodes
 
-accountMerkleTree
-poolMerkleTree
+**Account Merkle Trees**:
 
-    //
+- Accounts
+- Pools
 
-transactionsMerkleTree
-paramsMerkleTree
-flagsMerkleTree
+**Data Merkle Trees**
 
-### Transactions Hash (?? TODO_IN_THIS_COMMIT ??)
-
-## Transactions hash
+- Transactions
+- Parameters
+- Flags
 
 ## Compute State Hash
 
-This flow shows the interaction between the PostgresDB and MerkleTrees to compute the state hash.
-
 _Note: `GetRecordsUpdatedAtHeight` is an abstraction for retrieving all the records from the corresponding SQL tables depending on the type of record (Actors, Transactions, Params, etc...)_
 
+This flow shows the interaction between the `PostgresDB` and `MerkleTrees` listed above to compute the state hash. Assuming the process of applying a proposal block to the current context (i.e. the uncommited SQL state) is done, the following steps compute the hash of the new world state.
+
 1. Loop over all of the merkle tree types
-2. GetRecordsUpdatedAtHeight
+2. Use `GetRecordsUpdatedAtHeight` to retrieve all the records updated at the context's height
+3. Serialize each record using the corresponding underlying protobuf
+4. Insert the serialized record into the corresponding tree (which is back by a key-value store)
+5. Compute the root hash of each tree
+6. Aggregate all the root hashes by concatenating them together
+7. Compute the new `stateHash` by taking a hash of the concatenated hash list
 
 ```mermaid
 sequenceDiagram
@@ -74,29 +78,32 @@ sequenceDiagram
     participant PKV as Persistence (Key-Value Store)
 
     loop for each merkle tree type
-        P->>+PSQL: GetRecordsUpdatedAtHeight(height)
+        P->>+PSQL: GetRecordsUpdatedAtHeight(height, recordType)
         PSQL->>-P: records
         loop for each state tree
-            P->>+PKV: Update(addr, serialized(actor))
+            P->>+PKV: Update(addr, serialize(record))
             PKV->>-P: result, err_code
         end
         P->>+PKV: GetRoot()
         PKV->>-P: rootHash
     end
 
-    P->>P: stateHash = hash(aggregated(rootHashes))
+    P->>P: stateHash = hash(concat(rootHashes))
     activate P
     deactivate P
 ```
 
-## Store Block (i.e. Commit)
+_IMPORTANT: The order in which the `rootHashes` are concatenated is based on the definition in which the trees are ordered in within `state.go`._
+
+## Store Block (Commit)
 
-When the `Commit(quorumCert)` function is invoke, the current context is committed to disk. The `PersistenceContext` does the following:
+When the `Commit(quorumCert)` function is invoked, the current context is committed to disk. The `PersistenceContext` does the following:
 
-1. Read data from its own in memory state
+1. Read data from the persistence context's in-memory state
 2. Prepare a instance of the `Block` proto & serialize it
 3. Insert the `Block` into the `BlockStore`
 4. Insert the `Block` into the SQL Store
+5. Commit the context's SQL transaction to disk
 
 ```mermaid
 sequenceDiagram
@@ -115,4 +122,10 @@ sequenceDiagram
     %% Insert into the Block Store (i.e. Key-Value store)
     P->>+PKV: Put(height, block)
     PKV->>-P: result, err_code
+
+    %% Commit the SQL transaction
+    P->>+PSQL: Commit(SQL Tx to disk)
+    PSQL->>-P: result, err_code
 ```
+
+_TODO: If an error occurs at any step, all of the operations must be reverted in an atomic manner._

From 2d4717bdfdcf985a6a7824a3173d62865cfaa25e Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Sun, 27 Nov 2022 15:28:36 -0800
Subject: [PATCH 194/227] Rename finalQC to commitQC

---
 shared/docs/PROTOCOL_STATE_HASH.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/shared/docs/PROTOCOL_STATE_HASH.md b/shared/docs/PROTOCOL_STATE_HASH.md
index 4e8328f2f..f66368437 100644
--- a/shared/docs/PROTOCOL_STATE_HASH.md
+++ b/shared/docs/PROTOCOL_STATE_HASH.md
@@ -56,7 +56,7 @@ _The **Proposer** drives the **Validators** to agreement via the **Consensus Lif
 ---
 
 5. The `Consensus` module handles the `DECIDE` message
-6. The final `quorumCertificate` is propagated to the `UtilityContext` & `PersistenceContext` on `Commit`
+6. The `commitQC` is propagated to the `UtilityContext` & `PersistenceContext` on `Commit`
 7. The persistence module's internal implementation for ['Store Block'](../../persistence/docs/PROTOCOL_STORE_BLOCK.md) must execute.
 8. Both the `UtilityContext` and `PersistenceContext` are released
 

From 9bdadb060a76dbeee54a2752233a9743d6851662 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 28 Nov 2022 13:51:49 -0800
Subject: [PATCH 195/227] Import fix

---
 consensus/hotstuff_leader.go | 2 --
 1 file changed, 2 deletions(-)

diff --git a/consensus/hotstuff_leader.go b/consensus/hotstuff_leader.go
index 5e8a90959..6c749e6a0 100644
--- a/consensus/hotstuff_leader.go
+++ b/consensus/hotstuff_leader.go
@@ -4,8 +4,6 @@ import (
 	"encoding/hex"
 	"unsafe"
 
-	"github.com/pokt-network/pocket/shared/codec"
-
 	consensusTelemetry "github.com/pokt-network/pocket/consensus/telemetry"
 	typesCons "github.com/pokt-network/pocket/consensus/types"
 	"github.com/pokt-network/pocket/shared/codec"

From 4225cee5e5eaf464d3f10ef47a1d309abda8e44a Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 28 Nov 2022 16:17:08 -0800
Subject: [PATCH 196/227] Documentation clarifications per code review

---
 p2p/raintree/peers_manager_test.go        | 8 ++++----
 persistence/context.go                    | 2 +-
 persistence/docs/PROTOCOL_STATE_HASH.md   | 9 ++++++++-
 persistence/proto/block_persistence.proto | 4 ++--
 4 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/p2p/raintree/peers_manager_test.go b/p2p/raintree/peers_manager_test.go
index 4d37bbf71..b836c16c8 100644
--- a/p2p/raintree/peers_manager_test.go
+++ b/p2p/raintree/peers_manager_test.go
@@ -100,7 +100,7 @@ func BenchmarkAddrBookUpdates(b *testing.B) {
 	// the test will add this arbitrary number of addresses after the initial initialization (done via NewRainTreeNetwork)
 	// this is to add extra subsequent work that -should- grow linearly and it's actually going to test AddressBook updates
 	// not simply initializations.
-	numAddressessToBeAdded := 1000
+	numAddressesToBeAdded := 1000
 
 	for _, testCase := range testCases {
 		n := testCase.numNodes
@@ -115,7 +115,7 @@ func BenchmarkAddrBookUpdates(b *testing.B) {
 			require.Equal(b, n, len(peersManagerStateView.addrBookMap))
 			require.Equal(b, testCase.numExpectedLevels, int(peersManagerStateView.maxNumLevels))
 
-			for i := 0; i < numAddressessToBeAdded; i++ {
+			for i := 0; i < numAddressesToBeAdded; i++ {
 				newAddr, err := crypto.GenerateAddress()
 				require.NoError(b, err)
 				network.AddPeerToAddrBook(&types.NetworkPeer{Address: newAddr})
@@ -123,8 +123,8 @@ func BenchmarkAddrBookUpdates(b *testing.B) {
 
 			peersManagerStateView = network.peersManager.getNetworkView()
 
-			require.Equal(b, n+numAddressessToBeAdded, len(peersManagerStateView.addrList))
-			require.Equal(b, n+numAddressessToBeAdded, len(peersManagerStateView.addrBookMap))
+			require.Equal(b, n+numAddressesToBeAdded, len(peersManagerStateView.addrList))
+			require.Equal(b, n+numAddressesToBeAdded, len(peersManagerStateView.addrBookMap))
 		})
 	}
 }
diff --git a/persistence/context.go b/persistence/context.go
index 72ff98d97..764979da5 100644
--- a/persistence/context.go
+++ b/persistence/context.go
@@ -26,7 +26,7 @@ func (p PostgresContext) RollbackToSavePoint(bytes []byte) error {
 
 func (p *PostgresContext) ComputeAppHash() ([]byte, error) {
 	// IMPROVE(#361): Guarantee the integrity of the state
-	//                Full details in the thread from the PR review: https://github.com/pokt-network/pocket/pull/285/files?show-viewed-files=true&file-filters%5B%5D=#r1033002640
+	//                Full details in the thread from the PR review: https://github.com/pokt-network/pocket/pull/285#discussion_r1018471719
 	return p.updateMerkleTrees()
 }
 
diff --git a/persistence/docs/PROTOCOL_STATE_HASH.md b/persistence/docs/PROTOCOL_STATE_HASH.md
index 0e4c99767..e6e0ba069 100644
--- a/persistence/docs/PROTOCOL_STATE_HASH.md
+++ b/persistence/docs/PROTOCOL_STATE_HASH.md
@@ -11,6 +11,7 @@ Alternative implementation of the persistence module are free to choose their ow
   - [Trees](#trees)
 - [Compute State Hash](#compute-state-hash)
 - [Store Block (Commit)](#store-block-commit)
+- [Failed Commitments](#failed-commitments)
 
 ## Introduction
 
@@ -39,6 +40,8 @@ The block protobuf that is serialized and store in the block store can be found
 
 An individual Merkle Tree is created for each type of actor, record or data type. Each of these is backed by its own key-value store.
 
+Note that the order in which the trees are defined (found in `persistence/state.go`) is important since it determines how the state hash is computed. _TODO(#361): Consider specifying the oder in a `.proto` `enum` rather than a `.go` `iota`._
+
 **Actor Merkle Trees**:
 
 - Applications
@@ -61,7 +64,7 @@ An individual Merkle Tree is created for each type of actor, record or data type
 
 _Note: `GetRecordsUpdatedAtHeight` is an abstraction for retrieving all the records from the corresponding SQL tables depending on the type of record (Actors, Transactions, Params, etc...)_
 
-This flow shows the interaction between the `PostgresDB` and `MerkleTrees` listed above to compute the state hash. Assuming the process of applying a proposal block to the current context (i.e. the uncommited SQL state) is done, the following steps compute the hash of the new world state.
+This flow shows the interaction between the `PostgresDB` and `MerkleTrees` listed above to compute the state hash. Assuming the process of applying a proposal block to the current context (i.e. the uncommitted SQL state) is done, the following steps compute the hash of the new world state.
 
 1. Loop over all of the merkle tree types
 2. Use `GetRecordsUpdatedAtHeight` to retrieve all the records updated at the context's height
@@ -129,3 +132,7 @@ sequenceDiagram
 ```
 
 _TODO: If an error occurs at any step, all of the operations must be reverted in an atomic manner._
+
+## Failed Commitments
+
+TODO: Failed commitments and the implementation of rollbacks is tracked in #327 and #329.
diff --git a/persistence/proto/block_persistence.proto b/persistence/proto/block_persistence.proto
index 40b52f91e..4be306137 100644
--- a/persistence/proto/block_persistence.proto
+++ b/persistence/proto/block_persistence.proto
@@ -9,6 +9,6 @@ message Block {
     string prevStateHash = 3; // The stateHash of the block at height-1
     bytes proposerAddress = 4; // The proposer of this block
     bytes quorumCertificate = 5; // The quorum certificate containing signature from 2/3+ validators at height
-    // INVESTIGATE(#361): Decide if we neeed `transactionsHash` given that it is capture in the `transactionsTree`.
-    bytes transactionsHash = 6; // The hash of all the translactions in the block
+    // INVESTIGATE(#361): Decide if we need `transactionsHash` given that it is captured in the `transactionsTree`.
+    bytes transactionsHash = 6; // The hash of all the transactions in the block
 }
\ No newline at end of file

From 1943737986665be16800b80f68a8a4a554d9c8ca Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 28 Nov 2022 19:23:07 -0800
Subject: [PATCH 197/227] Try fixing CleanupTest for remote tests

---
 runtime/test_artifacts/util.go | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/runtime/test_artifacts/util.go b/runtime/test_artifacts/util.go
index 4a91c3aa7..7069521d4 100644
--- a/runtime/test_artifacts/util.go
+++ b/runtime/test_artifacts/util.go
@@ -95,5 +95,7 @@ func CleanupPostgresDocker(_ *testing.M, pool *dockertest.Pool, resource *docker
 	}
 }
 
-// CLEANUP: Remove this since it's no longer used or necessary.
-func CleanupTest(u utility.UtilityContext) {}
+// CLEANUP: Remove this since it's no longer used or necessary but make sure remote tests are still passing
+func CleanupTest(u utility.UtilityContext) {
+	u.Release()
+}

From 1e382c67634213a1428e5b062c3ff17f4d1e3022 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 28 Nov 2022 19:52:01 -0800
Subject: [PATCH 198/227] Do not merge this - testing workflow

---
 Makefile | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/Makefile b/Makefile
index 684319f4b..487c0d2b0 100644
--- a/Makefile
+++ b/Makefile
@@ -306,13 +306,15 @@ test_all: # generate_mocks
 .PHONY: test_all_with_json
 ## Run all go unit tests, output results in json file
 test_all_with_json: generate_rpc_openapi # generate_mocks
-	go test -p 1 -json ./... > test_results.json
+	go test -p=1 -count=1 -json ./utility/... > test_results.json
+# go test -p 1 -json ./... > test_results.json
 
 .PHONY: test_all_with_coverage
 ## Run all go unit tests, output results & coverage into files
 test_all_with_coverage: generate_rpc_openapi # generate_mocks
-	go test -p 1 -v ./... -covermode=count -coverprofile=coverage.out
-	go tool cover -func=coverage.out -o=coverage.out
+	go test -p=1 -v -count=1 ./utility/... > test_results.json
+# go test -p 1 -v ./... -covermode=count -coverprofile=coverage.out
+# go tool cover -func=coverage.out -o=coverage.out
 
 .PHONY: test_race
 ## Identify all unit tests that may result in race conditions

From cc362e4ad4863fe3d60970ddda5e9192ae80bd5f Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Mon, 28 Nov 2022 20:45:35 -0800
Subject: [PATCH 199/227] Update make test_all_with_coverage

---
 Makefile | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Makefile b/Makefile
index 487c0d2b0..d7442ac51 100644
--- a/Makefile
+++ b/Makefile
@@ -306,13 +306,13 @@ test_all: # generate_mocks
 .PHONY: test_all_with_json
 ## Run all go unit tests, output results in json file
 test_all_with_json: generate_rpc_openapi # generate_mocks
-	go test -p=1 -count=1 -json ./utility/... > test_results.json
+	go test -v -p=1 -json -count=1 ./... -run TestUtilityContext_SubtractAccountAmount > test_results.json
 # go test -p 1 -json ./... > test_results.json
 
 .PHONY: test_all_with_coverage
 ## Run all go unit tests, output results & coverage into files
 test_all_with_coverage: generate_rpc_openapi # generate_mocks
-	go test -p=1 -v -count=1 ./utility/... > test_results.json
+	go test -v -p=1 -json -count=1 ./... -run TestUtilityContext_SubtractAccountAmount > test_results.json
 # go test -p 1 -v ./... -covermode=count -coverprofile=coverage.out
 # go tool cover -func=coverage.out -o=coverage.out
 

From f959553ecd5c3fee14dbebb15e1bce9a666dae03 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 29 Nov 2022 08:50:03 -0800
Subject: [PATCH 200/227] Test all TestUtilityContext

---
 Makefile | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Makefile b/Makefile
index d7442ac51..97dabb7eb 100644
--- a/Makefile
+++ b/Makefile
@@ -306,13 +306,13 @@ test_all: # generate_mocks
 .PHONY: test_all_with_json
 ## Run all go unit tests, output results in json file
 test_all_with_json: generate_rpc_openapi # generate_mocks
-	go test -v -p=1 -json -count=1 ./... -run TestUtilityContext_SubtractAccountAmount > test_results.json
+	go test -v -p=1 -json -count=1 ./... -run TestUtilityContext > test_results.json
 # go test -p 1 -json ./... > test_results.json
 
 .PHONY: test_all_with_coverage
 ## Run all go unit tests, output results & coverage into files
 test_all_with_coverage: generate_rpc_openapi # generate_mocks
-	go test -v -p=1 -json -count=1 ./... -run TestUtilityContext_SubtractAccountAmount > test_results.json
+	go test -v -p=1 -json -count=1 ./... -run TestUtilityContext > test_results.json
 # go test -p 1 -v ./... -covermode=count -coverprofile=coverage.out
 # go tool cover -func=coverage.out -o=coverage.out
 

From fcd54ffd8a4eb99a07a56030c8c54fdec9fdd82f Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 29 Nov 2022 08:54:49 -0800
Subject: [PATCH 201/227] Fix temporary test_all_with_coverage

---
 Makefile | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/Makefile b/Makefile
index 97dabb7eb..926808fc6 100644
--- a/Makefile
+++ b/Makefile
@@ -307,14 +307,12 @@ test_all: # generate_mocks
 ## Run all go unit tests, output results in json file
 test_all_with_json: generate_rpc_openapi # generate_mocks
 	go test -v -p=1 -json -count=1 ./... -run TestUtilityContext > test_results.json
-# go test -p 1 -json ./... > test_results.json
 
 .PHONY: test_all_with_coverage
 ## Run all go unit tests, output results & coverage into files
 test_all_with_coverage: generate_rpc_openapi # generate_mocks
-	go test -v -p=1 -json -count=1 ./... -run TestUtilityContext > test_results.json
-# go test -p 1 -v ./... -covermode=count -coverprofile=coverage.out
-# go tool cover -func=coverage.out -o=coverage.out
+	go test -p 1 -v -count=1 ./... -run TestUtilityContext -covermode=count -coverprofile=coverage.out
+	go tool cover -func=coverage.out -o=coverage.out
 
 .PHONY: test_race
 ## Identify all unit tests that may result in race conditions

From e3f32a0f1a4ad06addca01f59a489c4d82567dbc Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 29 Nov 2022 09:05:46 -0800
Subject: [PATCH 202/227] Only test TestUtilityContext_HandleMessage

---
 Makefile | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Makefile b/Makefile
index 926808fc6..bb17dfccb 100644
--- a/Makefile
+++ b/Makefile
@@ -306,12 +306,12 @@ test_all: # generate_mocks
 .PHONY: test_all_with_json
 ## Run all go unit tests, output results in json file
 test_all_with_json: generate_rpc_openapi # generate_mocks
-	go test -v -p=1 -json -count=1 ./... -run TestUtilityContext > test_results.json
+	go test -v -p=1 -json -count=1 ./... -run TestUtilityContext_HandleMessage > test_results.json
 
 .PHONY: test_all_with_coverage
 ## Run all go unit tests, output results & coverage into files
 test_all_with_coverage: generate_rpc_openapi # generate_mocks
-	go test -p 1 -v -count=1 ./... -run TestUtilityContext -covermode=count -coverprofile=coverage.out
+	go test -p 1 -v -count=1 ./... -run TestUtilityContext_HandleMessage -covermode=count -coverprofile=coverage.out
 	go tool cover -func=coverage.out -o=coverage.out
 
 .PHONY: test_race

From bc36d30f6110c5826742f9cd6b70c1cfb5e4ef37 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 29 Nov 2022 11:08:02 -0800
Subject: [PATCH 203/227] Added IMPROVE

---
 Makefile | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Makefile b/Makefile
index bb17dfccb..35b576807 100644
--- a/Makefile
+++ b/Makefile
@@ -8,6 +8,8 @@ CWD ?= CURRENT_WORKING_DIRECTIONRY_NOT_SUPPLIED
 #		                        seconds, and fail if any additional messages are received.
 EXTRA_MSG_FAIL ?= false
 
+# IMPROVE: Add `-shuffle=on` to the `go test` command to randomize the order in which tests are run.
+
 # An easy way to turn off verbose test output for some of the test targets. For example
 #  `$ make test_persistence` by default enables verbose testing
 #  `VERBOSE_TEST="" make test_persistence` is an easy way to run the same tests without verbose output

From f7065bca73041db8293494db44ab1b91b3bf04c9 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 29 Nov 2022 15:55:12 -0800
Subject: [PATCH 204/227] Update expiration to 20 mins

---
 runtime/test_artifacts/util.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/runtime/test_artifacts/util.go b/runtime/test_artifacts/util.go
index 7069521d4..79a2953cb 100644
--- a/runtime/test_artifacts/util.go
+++ b/runtime/test_artifacts/util.go
@@ -65,7 +65,7 @@ func SetupPostgresDocker() (*dockertest.Pool, *dockertest.Resource, string) {
 		}
 	}()
 
-	resource.Expire(120) // Tell docker to hard kill the container in 120 seconds
+	resource.Expire(1200) // Tell docker to hard kill the container in 120 seconds
 
 	poolRetryChan := make(chan struct{}, 1)
 	retryConnectFn := func() error {

From 1953ad4d3938b91a6598d283ada750fbf8d62772 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 29 Nov 2022 16:37:42 -0800
Subject: [PATCH 205/227] Don't run fisherman tests

---
 Makefile                    | 2 +-
 utility/test/actor_test.go  | 5 +++--
 utility/test/module_test.go | 5 ++++-
 3 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/Makefile b/Makefile
index 35b576807..dda46db2a 100644
--- a/Makefile
+++ b/Makefile
@@ -308,7 +308,7 @@ test_all: # generate_mocks
 .PHONY: test_all_with_json
 ## Run all go unit tests, output results in json file
 test_all_with_json: generate_rpc_openapi # generate_mocks
-	go test -v -p=1 -json -count=1 ./... -run TestUtilityContext_HandleMessage > test_results.json
+	go test -v -p=1 -count=1 -json ./... -run TestUtilityContext_HandleMessage > test_results.json
 
 .PHONY: test_all_with_coverage
 ## Run all go unit tests, output results & coverage into files
diff --git a/utility/test/actor_test.go b/utility/test/actor_test.go
index f8064fa1e..dcb5c49c2 100644
--- a/utility/test/actor_test.go
+++ b/utility/test/actor_test.go
@@ -67,8 +67,10 @@ func TestUtilityContext_HandleMessageEditStake(t *testing.T) {
 		t.Run(fmt.Sprintf("%s.HandleMessageEditStake", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
 			actor := getFirstActor(t, ctx, actorType)
+
 			addrBz, err := hex.DecodeString(actor.GetAddress())
 			require.NoError(t, err)
+
 			msg := &typesUtil.MessageEditStake{
 				Address:   addrBz,
 				Chains:    defaults.DefaultChains,
@@ -76,7 +78,6 @@ func TestUtilityContext_HandleMessageEditStake(t *testing.T) {
 				Signer:    addrBz,
 				ActorType: actorType,
 			}
-
 			msgChainsEdited := proto.Clone(msg).(*typesUtil.MessageEditStake)
 			msgChainsEdited.Chains = defaultTestingChainsEdited
 
@@ -107,8 +108,8 @@ func TestUtilityContext_HandleMessageEditStake(t *testing.T) {
 func TestUtilityContext_HandleMessageUnpause(t *testing.T) {
 	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.HandleMessageUnpause", actorType.String()), func(t *testing.T) {
-
 			ctx := NewTestingUtilityContext(t, 1)
+
 			var err error
 			switch actorType {
 			case typesUtil.ActorType_Validator:
diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index c4d7354bd..c238f1b5b 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -2,6 +2,7 @@ package test
 
 import (
 	"encoding/hex"
+	"fmt"
 	"math/big"
 	"os"
 	"testing"
@@ -39,7 +40,7 @@ var persistenceDbUrl string
 var actorTypes = []utilTypes.ActorType{
 	utilTypes.ActorType_App,
 	utilTypes.ActorType_ServiceNode,
-	utilTypes.ActorType_Fisherman,
+	// utilTypes.ActorType_Fisherman,
 	utilTypes.ActorType_Validator,
 }
 
@@ -57,6 +58,7 @@ func TestMain(m *testing.M) {
 
 func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext {
 	// IMPROVE: Avoid creating a new persistence module with every test
+	fmt.Println("OLSH 1")
 	testPersistenceMod := newTestPersistenceModule(t, persistenceDbUrl)
 
 	persistenceContext, err := testPersistenceMod.NewRWContext(height)
@@ -66,6 +68,7 @@ func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext
 	// beginning of every test. This (the current implementation) is an issue because if we call
 	// `NewTestingUtilityContext` more than once in a single test, we create unnecessary calls to clean.
 	t.Cleanup(func() {
+		fmt.Println("OLSH 2")
 		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
 		require.NoError(t, testPersistenceMod.HandleDebugMessage(&messaging.DebugMessage{
 			Action:  messaging.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,

From 5a22570b168b4dfeb8f998e5be46f38c4e4df204 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 29 Nov 2022 16:49:40 -0800
Subject: [PATCH 206/227] Cleanup whitespace while inspecting tests

---
 utility/test/actor_test.go  | 53 +++++++++++++++++++++++++++----------
 utility/test/block_test.go  |  6 +++--
 utility/test/module_test.go |  3 ---
 3 files changed, 43 insertions(+), 19 deletions(-)

diff --git a/utility/test/actor_test.go b/utility/test/actor_test.go
index dcb5c49c2..25215b6a6 100644
--- a/utility/test/actor_test.go
+++ b/utility/test/actor_test.go
@@ -57,6 +57,7 @@ func TestUtilityContext_HandleMessageStake(t *testing.T) {
 			require.Equal(t, defaults.DefaultStakeAmountString, actor.GetStakedAmount(), "incorrect actor stake amount")
 			require.Equal(t, typesUtil.HeightNotUsed, actor.GetUnstakingHeight(), "incorrect actor unstaking height")
 			require.Equal(t, outputAddress.String(), actor.GetOutput(), "incorrect actor output address")
+
 			test_artifacts.CleanupTest(ctx)
 		})
 	}
@@ -99,7 +100,6 @@ func TestUtilityContext_HandleMessageEditStake(t *testing.T) {
 			err = ctx.HandleEditStakeMessage(msgAmountEdited)
 			require.NoError(t, err, "handle edit stake message")
 
-			actor = getActorByAddr(t, ctx, addrBz, actorType)
 			test_artifacts.CleanupTest(ctx)
 		})
 	}
@@ -128,6 +128,7 @@ func TestUtilityContext_HandleMessageUnpause(t *testing.T) {
 			actor := getFirstActor(t, ctx, actorType)
 			addrBz, err := hex.DecodeString(actor.GetAddress())
 			require.NoError(t, err)
+
 			err = ctx.SetActorPauseHeight(actorType, addrBz, 1)
 			require.NoError(t, err, "error setting pause height")
 
@@ -145,6 +146,7 @@ func TestUtilityContext_HandleMessageUnpause(t *testing.T) {
 
 			actor = getActorByAddr(t, ctx, addrBz, actorType)
 			require.Equal(t, int64(-1), actor.GetPausedHeight())
+
 			test_artifacts.CleanupTest(ctx)
 		})
 	}
@@ -154,6 +156,7 @@ func TestUtilityContext_HandleMessageUnstake(t *testing.T) {
 	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.HandleMessageUnstake", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)
+
 			var err error
 			switch actorType {
 			case typesUtil.ActorType_App:
@@ -172,6 +175,7 @@ func TestUtilityContext_HandleMessageUnstake(t *testing.T) {
 			actor := getFirstActor(t, ctx, actorType)
 			addrBz, err := hex.DecodeString(actor.GetAddress())
 			require.NoError(t, err)
+
 			msg := &typesUtil.MessageUnstake{
 				Address:   addrBz,
 				Signer:    addrBz,
@@ -183,6 +187,7 @@ func TestUtilityContext_HandleMessageUnstake(t *testing.T) {
 
 			actor = getActorByAddr(t, ctx, addrBz, actorType)
 			require.Equal(t, defaultUnstaking, actor.GetUnstakingHeight(), "actor should be unstaking")
+
 			test_artifacts.CleanupTest(ctx)
 		})
 	}
@@ -192,10 +197,11 @@ func TestUtilityContext_BeginUnstakingMaxPaused(t *testing.T) {
 	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.BeginUnstakingMaxPaused", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)
-
 			actor := getFirstActor(t, ctx, actorType)
+
 			addrBz, err := hex.DecodeString(actor.GetAddress())
 			require.NoError(t, err)
+
 			switch actorType {
 			case typesUtil.ActorType_App:
 				err = ctx.Context.SetParam(typesUtil.AppMaxPauseBlocksParamName, 0)
@@ -219,6 +225,7 @@ func TestUtilityContext_BeginUnstakingMaxPaused(t *testing.T) {
 			status, err := ctx.GetActorStatus(actorType, addrBz)
 			require.NoError(t, err)
 			require.Equal(t, int32(typesUtil.StakeStatus_Unstaking), status, "actor should be unstaking")
+
 			test_artifacts.CleanupTest(ctx)
 		})
 	}
@@ -255,8 +262,8 @@ func TestUtilityContext_CalculateUnstakingHeight(t *testing.T) {
 
 			unstakingHeight, err := ctx.GetUnstakingHeight(actorType)
 			require.NoError(t, err)
-
 			require.Equal(t, unstakingBlocks, unstakingHeight, "unexpected unstaking height")
+
 			test_artifacts.CleanupTest(ctx)
 		})
 	}
@@ -270,8 +277,10 @@ func TestUtilityContext_GetExists(t *testing.T) {
 			actor := getFirstActor(t, ctx, actorType)
 			randAddr, err := crypto.GenerateAddress()
 			require.NoError(t, err)
+
 			addrBz, err := hex.DecodeString(actor.GetAddress())
 			require.NoError(t, err)
+
 			exists, err := ctx.GetActorExists(actorType, addrBz)
 			require.NoError(t, err)
 			require.True(t, exists, "actor that should exist does not")
@@ -279,6 +288,7 @@ func TestUtilityContext_GetExists(t *testing.T) {
 			exists, err = ctx.GetActorExists(actorType, randAddr)
 			require.NoError(t, err)
 			require.False(t, exists, "actor that shouldn't exist does")
+
 			test_artifacts.CleanupTest(ctx)
 		})
 	}
@@ -292,10 +302,11 @@ func TestUtilityContext_GetOutputAddress(t *testing.T) {
 			actor := getFirstActor(t, ctx, actorType)
 			addrBz, err := hex.DecodeString(actor.GetAddress())
 			require.NoError(t, err)
+
 			outputAddress, err := ctx.GetActorOutputAddress(actorType, addrBz)
 			require.NoError(t, err)
-
 			require.Equal(t, actor.GetOutput(), hex.EncodeToString(outputAddress), "unexpected output address")
+
 			test_artifacts.CleanupTest(ctx)
 		})
 	}
@@ -305,11 +316,12 @@ func TestUtilityContext_GetPauseHeightIfExists(t *testing.T) {
 	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.GetPauseHeightIfExists", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
-
 			pauseHeight := int64(100)
 			actor := getFirstActor(t, ctx, actorType)
+
 			addrBz, err := hex.DecodeString(actor.GetAddress())
 			require.NoError(t, err)
+
 			err = ctx.SetActorPauseHeight(actorType, addrBz, pauseHeight)
 			require.NoError(t, err, "error setting actor pause height")
 
@@ -322,6 +334,7 @@ func TestUtilityContext_GetPauseHeightIfExists(t *testing.T) {
 
 			_, err = ctx.GetPauseHeight(actorType, randAddr)
 			require.Error(t, err, "non existent actor should error")
+
 			test_artifacts.CleanupTest(ctx)
 		})
 	}
@@ -331,22 +344,24 @@ func TestUtilityContext_GetMessageEditStakeSignerCandidates(t *testing.T) {
 	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.GetMessageEditStakeSignerCandidates", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
-
 			actor := getFirstActor(t, ctx, actorType)
+
 			addrBz, err := hex.DecodeString(actor.GetAddress())
 			require.NoError(t, err)
+
 			msgEditStake := &typesUtil.MessageEditStake{
 				Address:   addrBz,
 				Chains:    defaults.DefaultChains,
 				Amount:    defaults.DefaultStakeAmountString,
 				ActorType: actorType,
 			}
-
 			candidates, err := ctx.GetMessageEditStakeSignerCandidates(msgEditStake)
 			require.NoError(t, err)
+
 			require.Equal(t, len(candidates), 2, "unexpected number of candidates")
 			require.Equal(t, actor.GetOutput(), hex.EncodeToString(candidates[0]), "incorrect output candidate")
 			require.Equal(t, actor.GetAddress(), hex.EncodeToString(candidates[1]), "incorrect addr candidate")
+
 			test_artifacts.CleanupTest(ctx)
 		})
 	}
@@ -356,20 +371,22 @@ func TestUtilityContext_GetMessageUnpauseSignerCandidates(t *testing.T) {
 	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.GetMessageUnpauseSignerCandidates", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
-
 			actor := getFirstActor(t, ctx, actorType)
+
 			addrBz, err := hex.DecodeString(actor.GetAddress())
 			require.NoError(t, err)
+
 			msg := &typesUtil.MessageUnpause{
 				Address:   addrBz,
 				ActorType: actorType,
 			}
-
 			candidates, err := ctx.GetMessageUnpauseSignerCandidates(msg)
 			require.NoError(t, err)
+
 			require.Equal(t, len(candidates), 2, "unexpected number of candidates")
 			require.Equal(t, actor.GetOutput(), hex.EncodeToString(candidates[0]), "incorrect output candidate")
 			require.Equal(t, actor.GetAddress(), hex.EncodeToString(candidates[1]), "incorrect addr candidate")
+
 			test_artifacts.CleanupTest(ctx)
 		})
 	}
@@ -379,19 +396,22 @@ func TestUtilityContext_GetMessageUnstakeSignerCandidates(t *testing.T) {
 	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.GetMessageUnstakeSignerCandidates", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
-
 			actor := getFirstActor(t, ctx, actorType)
+
 			addrBz, err := hex.DecodeString(actor.GetAddress())
 			require.NoError(t, err)
+
 			msg := &typesUtil.MessageUnstake{
 				Address:   addrBz,
 				ActorType: actorType,
 			}
 			candidates, err := ctx.GetMessageUnstakeSignerCandidates(msg)
 			require.NoError(t, err)
+
 			require.Equal(t, len(candidates), 2, "unexpected number of candidates")
 			require.Equal(t, actor.GetOutput(), hex.EncodeToString(candidates[0]), "incorrect output candidate")
 			require.Equal(t, actor.GetAddress(), hex.EncodeToString(candidates[1]), "incorrect addr candidate")
+
 			test_artifacts.CleanupTest(ctx)
 		})
 	}
@@ -404,8 +424,10 @@ func TestUtilityContext_UnstakePausedBefore(t *testing.T) {
 
 			actor := getFirstActor(t, ctx, actorType)
 			require.Equal(t, actor.GetUnstakingHeight(), int64(-1), "wrong starting status")
+
 			addrBz, err := hex.DecodeString(actor.GetAddress())
 			require.NoError(t, err)
+
 			err = ctx.SetActorPauseHeight(actorType, addrBz, 0)
 			require.NoError(t, err, "error setting actor pause height")
 
@@ -448,6 +470,7 @@ func TestUtilityContext_UnstakePausedBefore(t *testing.T) {
 			}
 			require.NoError(t, err, "error getting unstaking blocks")
 			require.Equal(t, unstakingBlocks+1, actor.GetUnstakingHeight(), "incorrect unstaking height")
+
 			test_artifacts.CleanupTest(ctx)
 		})
 	}
@@ -458,7 +481,7 @@ func TestUtilityContext_UnstakeActorsThatAreReady(t *testing.T) {
 		t.Run(fmt.Sprintf("%s.UnstakeActorsThatAreReady", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)
 
-			poolName := ""
+			var poolName string
 			var err1, err2 error
 			switch actorType {
 			case typesUtil.ActorType_App:
@@ -480,11 +503,11 @@ func TestUtilityContext_UnstakeActorsThatAreReady(t *testing.T) {
 			default:
 				t.Fatalf("unexpected actor type %s", actorType.String())
 			}
+			require.NoError(t, err1, "error setting unstaking blocks")
+			require.NoError(t, err2, "error setting max pause blocks")
 
 			err := ctx.SetPoolAmount(poolName, big.NewInt(math.MaxInt64))
 			require.NoError(t, err)
-			require.NoError(t, err1, "error setting unstaking blocks")
-			require.NoError(t, err2, "error setting max pause blocks")
 
 			actors := getAllTestingActors(t, ctx, actorType)
 			for _, actor := range actors {
@@ -499,7 +522,6 @@ func TestUtilityContext_UnstakeActorsThatAreReady(t *testing.T) {
 			require.NoError(t, err, "error setting actor pause before")
 
 			accountAmountsBefore := make([]*big.Int, 0)
-
 			for _, actor := range actors {
 				// get the output address account amount before the 'unstake'
 				outputAddressString := actor.GetOutput()
@@ -522,12 +544,15 @@ func TestUtilityContext_UnstakeActorsThatAreReady(t *testing.T) {
 				outputAddressString := actor.GetOutput()
 				outputAddress, err := hex.DecodeString(outputAddressString)
 				require.NoError(t, err)
+
 				outputAccountAmount, err := ctx.GetAccountAmount(outputAddress)
 				require.NoError(t, err)
+
 				// ensure the stake amount went to the output address
 				outputAccountAmountDelta := new(big.Int).Sub(outputAccountAmount, accountAmountsBefore[i])
 				require.Equal(t, outputAccountAmountDelta, defaults.DefaultStakeAmount)
 			}
+
 			// ensure the staking pool is `# of readyToUnstake actors * default stake` less than before the unstake
 			poolAmountAfter, err := ctx.GetPoolAmount(poolName)
 			require.NoError(t, err)
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index 332610822..5fb1ab5fa 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -108,8 +108,10 @@ func TestUtilityContext_BeginUnstakingMaxPausedActors(t *testing.T) {
 				t.Fatalf("unexpected actor type %s", actorType.String())
 			}
 			require.NoError(t, err)
+
 			addrBz, er := hex.DecodeString(actor.GetAddress())
 			require.NoError(t, er)
+
 			err = ctx.SetActorPauseHeight(actorType, addrBz, 0)
 			require.NoError(t, err)
 
@@ -166,6 +168,7 @@ func TestUtilityContext_UnstakeValidatorsActorsThatAreReady(t *testing.T) {
 	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.UnstakeValidatorsActorsThatAreReady", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)
+
 			var poolName string
 			switch actorType {
 			case typesUtil.ActorType_App:
@@ -179,8 +182,8 @@ func TestUtilityContext_UnstakeValidatorsActorsThatAreReady(t *testing.T) {
 			default:
 				t.Fatalf("unexpected actor type %s", actorType.String())
 			}
-
 			ctx.SetPoolAmount(poolName, big.NewInt(math.MaxInt64))
+
 			err := ctx.Context.SetParam(typesUtil.AppUnstakingBlocksParamName, 0)
 			require.NoError(t, err)
 
@@ -207,7 +210,6 @@ func TestUtilityContext_UnstakeValidatorsActorsThatAreReady(t *testing.T) {
 
 			// TODO: We need to better define what 'deleted' really is in the postgres world.
 			// We might not need to 'unstakeActorsThatAreReady' if we are already filtering by unstakingHeight
-
 			test_artifacts.CleanupTest(ctx)
 		})
 	}
diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index c238f1b5b..54d943770 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -2,7 +2,6 @@ package test
 
 import (
 	"encoding/hex"
-	"fmt"
 	"math/big"
 	"os"
 	"testing"
@@ -58,7 +57,6 @@ func TestMain(m *testing.M) {
 
 func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext {
 	// IMPROVE: Avoid creating a new persistence module with every test
-	fmt.Println("OLSH 1")
 	testPersistenceMod := newTestPersistenceModule(t, persistenceDbUrl)
 
 	persistenceContext, err := testPersistenceMod.NewRWContext(height)
@@ -68,7 +66,6 @@ func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext
 	// beginning of every test. This (the current implementation) is an issue because if we call
 	// `NewTestingUtilityContext` more than once in a single test, we create unnecessary calls to clean.
 	t.Cleanup(func() {
-		fmt.Println("OLSH 2")
 		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
 		require.NoError(t, testPersistenceMod.HandleDebugMessage(&messaging.DebugMessage{
 			Action:  messaging.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,

From 14ee5b1d4b959a8488f613895d64171dfae50837 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 29 Nov 2022 17:00:21 -0800
Subject: [PATCH 207/227] Only keep 1 actor type in utility tests

---
 utility/test/module_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index 54d943770..d538b8693 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -38,9 +38,9 @@ var (
 var persistenceDbUrl string
 var actorTypes = []utilTypes.ActorType{
 	utilTypes.ActorType_App,
-	utilTypes.ActorType_ServiceNode,
+	// utilTypes.ActorType_ServiceNode,
 	// utilTypes.ActorType_Fisherman,
-	utilTypes.ActorType_Validator,
+	// utilTypes.ActorType_Validator,
 }
 
 func NewTestingMempool(_ *testing.T) utilTypes.Mempool {

From dbd2a90564b18cc7da52bb1a094ac2b51ce70e75 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 29 Nov 2022 17:16:39 -0800
Subject: [PATCH 208/227] Add back service node during testing

---
 utility/test/module_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index d538b8693..41644a9c4 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -38,7 +38,7 @@ var (
 var persistenceDbUrl string
 var actorTypes = []utilTypes.ActorType{
 	utilTypes.ActorType_App,
-	// utilTypes.ActorType_ServiceNode,
+	utilTypes.ActorType_ServiceNode,
 	// utilTypes.ActorType_Fisherman,
 	// utilTypes.ActorType_Validator,
 }

From f56a10ae53ea4b96a0ea7d7e91513dd852348f8a Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 29 Nov 2022 17:33:08 -0800
Subject: [PATCH 209/227] Adding back the validator

---
 runtime/test_artifacts/util.go | 2 +-
 utility/test/module_test.go    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/runtime/test_artifacts/util.go b/runtime/test_artifacts/util.go
index 79a2953cb..c66b66cff 100644
--- a/runtime/test_artifacts/util.go
+++ b/runtime/test_artifacts/util.go
@@ -65,7 +65,7 @@ func SetupPostgresDocker() (*dockertest.Pool, *dockertest.Resource, string) {
 		}
 	}()
 
-	resource.Expire(1200) // Tell docker to hard kill the container in 120 seconds
+	resource.Expire(1200) // Tell docker to hard kill the container in 20 minutes
 
 	poolRetryChan := make(chan struct{}, 1)
 	retryConnectFn := func() error {
diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index 41644a9c4..54d943770 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -40,7 +40,7 @@ var actorTypes = []utilTypes.ActorType{
 	utilTypes.ActorType_App,
 	utilTypes.ActorType_ServiceNode,
 	// utilTypes.ActorType_Fisherman,
-	// utilTypes.ActorType_Validator,
+	utilTypes.ActorType_Validator,
 }
 
 func NewTestingMempool(_ *testing.T) utilTypes.Mempool {

From 2eea86b8e33f67217d619641808e9e5448d50aa8 Mon Sep 17 00:00:00 2001
From: Dmitry Knyazev <okdas@users.noreply.github.com>
Date: Tue, 29 Nov 2022 17:55:21 -0800
Subject: [PATCH 210/227] [Quick CI change] Run tests once (#365)

Update main pipeline to run tests once
---
 .github/workflows/main.yml | 30 ++++++++++++++++++++++--------
 1 file changed, 22 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 0dbaded3e..a242b0aea 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -50,14 +50,34 @@ jobs:
         run: make install_cli_deps
       - name: generate protobufs, RPC server, RPC client and mocks
         run: make protogen_local && make mockgen && make generate_rpc_openapi
-      - name: run all tests
-        run: make test_all_with_json
+      - name: Create coverage report and run tests
+        # Not utilizing makefile target here to make use of pipefail bash feature.
+        run: |
+          set -euo pipefail
+          go test -p 1 -json ./... -covermode=count -coverprofile=coverage.out | tee test_results.json | jq
+      - name: Output test failures
+        # Makes it easier to find failed tests so no need to scroll through the whole log.
+        if: ${{ failure() && env.TARGET_GOLANG_VERSION == matrix.go }}
+        run: cat test_results.json | jq 'select(.Action == "fail")'
+      - name: Upload test results
+        if: ${{ always() && env.TARGET_GOLANG_VERSION == matrix.go }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: test-results
+          path: |
+            test_results.json
       - name: Annotate tests on GitHub
         # Only annotate if the test failed on target version to avoid duplicated annotations on GitHub.
         if: ${{ always() && env.TARGET_GOLANG_VERSION == matrix.go }}
         uses: guyarb/golang-test-annotations@v0.5.1
         with:
           test-results: test_results.json
+      - name: Prepare code coverage report
+        if: ${{ always() && env.TARGET_GOLANG_VERSION == matrix.go }}
+        run: go tool cover -func=coverage.out -o=coverage.out
+      - name: Upload coverage to Codecov
+        if: ${{ always() && env.TARGET_GOLANG_VERSION == matrix.go }}
+        uses: codecov/codecov-action@v3
       - name: Run golangci-lint
         # Only run if the test failed on target version to avoid duplicated annotations on GitHub.
         if: ${{ always() && env.TARGET_GOLANG_VERSION == matrix.go }}
@@ -65,12 +85,6 @@ jobs:
         with:
           # only-new-issues: true
           args: --issues-exit-code=0 # TODO: Remove this once we fix all the issues.
-      - name: create coverage report
-        if: ${{ always() && env.TARGET_GOLANG_VERSION == matrix.go }}
-        run: make test_all_with_coverage
-      - name: Upload coverage to Codecov
-        if: ${{ always() && env.TARGET_GOLANG_VERSION == matrix.go }}
-        uses: codecov/codecov-action@v3
 
   # TODO(@okdas): reuse artifacts built by the previous job instead
   # of going through the build process in container build job again

From 7a732d3e44e9f90c43741a777d1fafdb414a7c98 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 29 Nov 2022 17:58:01 -0800
Subject: [PATCH 211/227] Add back fisherman tests

---
 utility/test/module_test.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index 54d943770..391f196c3 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -39,7 +39,7 @@ var persistenceDbUrl string
 var actorTypes = []utilTypes.ActorType{
 	utilTypes.ActorType_App,
 	utilTypes.ActorType_ServiceNode,
-	// utilTypes.ActorType_Fisherman,
+	utilTypes.ActorType_Fisherman,
 	utilTypes.ActorType_Validator,
 }
 
@@ -68,7 +68,8 @@ func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext
 	t.Cleanup(func() {
 		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
 		require.NoError(t, testPersistenceMod.HandleDebugMessage(&messaging.DebugMessage{
-			Action:  messaging.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
+			// Action:  messaging.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
+			Action:  messaging.DebugMessageAction_DEBUG_PERSISTENCE_RESET_TO_GENESIS,
 			Message: nil,
 		}))
 	})

From 7422aa56edcba40130df4de6374ff6da7c9ed77b Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 29 Nov 2022 18:20:50 -0800
Subject: [PATCH 212/227] Fisherman tests only

---
 utility/test/module_test.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index 391f196c3..220d76c7c 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -37,10 +37,10 @@ var (
 
 var persistenceDbUrl string
 var actorTypes = []utilTypes.ActorType{
-	utilTypes.ActorType_App,
-	utilTypes.ActorType_ServiceNode,
+	// utilTypes.ActorType_App,
+	// utilTypes.ActorType_ServiceNode,
 	utilTypes.ActorType_Fisherman,
-	utilTypes.ActorType_Validator,
+	// utilTypes.ActorType_Validator,
 }
 
 func NewTestingMempool(_ *testing.T) utilTypes.Mempool {

From 7dbc3bcf1ba1f70483e33c170d6ba79f4d6dfabb Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 29 Nov 2022 18:38:21 -0800
Subject: [PATCH 213/227] make test_all_with_json_coverage

---
 .github/workflows/main.yml     |  2 +-
 Makefile                       | 14 ++++----------
 runtime/test_artifacts/util.go |  4 +---
 utility/test/module_test.go    |  6 +++---
 4 files changed, 9 insertions(+), 17 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index a242b0aea..b5b89faad 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -54,7 +54,7 @@ jobs:
         # Not utilizing makefile target here to make use of pipefail bash feature.
         run: |
           set -euo pipefail
-          go test -p 1 -json ./... -covermode=count -coverprofile=coverage.out | tee test_results.json | jq
+          make test_all_with_json_coverage
       - name: Output test failures
         # Makes it easier to find failed tests so no need to scroll through the whole log.
         if: ${{ failure() && env.TARGET_GOLANG_VERSION == matrix.go }}
diff --git a/Makefile b/Makefile
index dda46db2a..31a150037 100644
--- a/Makefile
+++ b/Makefile
@@ -305,16 +305,10 @@ generate_cli_commands_docs:
 test_all: # generate_mocks
 	go test -p 1 -count=1 ./...
 
-.PHONY: test_all_with_json
-## Run all go unit tests, output results in json file
-test_all_with_json: generate_rpc_openapi # generate_mocks
-	go test -v -p=1 -count=1 -json ./... -run TestUtilityContext_HandleMessage > test_results.json
-
-.PHONY: test_all_with_coverage
-## Run all go unit tests, output results & coverage into files
-test_all_with_coverage: generate_rpc_openapi # generate_mocks
-	go test -p 1 -v -count=1 ./... -run TestUtilityContext_HandleMessage -covermode=count -coverprofile=coverage.out
-	go tool cover -func=coverage.out -o=coverage.out
+.PHONY: test_all_with_json_coverage
+## Run all go unit tests, output results & coverage into json & coverage files
+test_all_with_json_coverage: generate_rpc_openapi # generate_mocks
+	go test -p 1 -json ./... -covermode=count -coverprofile=coverage.out -run TestUtilityContext_HandleMessage | tee test_results.json | jq
 
 .PHONY: test_race
 ## Identify all unit tests that may result in race conditions
diff --git a/runtime/test_artifacts/util.go b/runtime/test_artifacts/util.go
index c66b66cff..381adc193 100644
--- a/runtime/test_artifacts/util.go
+++ b/runtime/test_artifacts/util.go
@@ -96,6 +96,4 @@ func CleanupPostgresDocker(_ *testing.M, pool *dockertest.Pool, resource *docker
 }
 
 // CLEANUP: Remove this since it's no longer used or necessary but make sure remote tests are still passing
-func CleanupTest(u utility.UtilityContext) {
-	u.Release()
-}
+func CleanupTest(u utility.UtilityContext) {}
diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index 220d76c7c..391f196c3 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -37,10 +37,10 @@ var (
 
 var persistenceDbUrl string
 var actorTypes = []utilTypes.ActorType{
-	// utilTypes.ActorType_App,
-	// utilTypes.ActorType_ServiceNode,
+	utilTypes.ActorType_App,
+	utilTypes.ActorType_ServiceNode,
 	utilTypes.ActorType_Fisherman,
-	// utilTypes.ActorType_Validator,
+	utilTypes.ActorType_Validator,
 }
 
 func NewTestingMempool(_ *testing.T) utilTypes.Mempool {

From c7eba2d91a4e995cee674b03685fc33ddd2e9e24 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Tue, 29 Nov 2022 18:51:05 -0800
Subject: [PATCH 214/227] Alternative method to loading genesis state

---
 persistence/module.go | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/persistence/module.go b/persistence/module.go
index a3fc5285b..535020641 100644
--- a/persistence/module.go
+++ b/persistence/module.go
@@ -106,7 +106,9 @@ func (*persistenceModule) Create(runtimeMgr modules.RuntimeMgr) (modules.Module,
 	} else if shouldHydrateGenesis {
 		m.populateGenesisState(persistenceGenesis) // fatal if there's an error
 	} else {
-		log.Println("Loading state from previous state...")
+		// This configurations will connect to the SQL database and key-value stores specified
+		// in the configurations and connected to those.
+		log.Println("Loading state from disk...")
 	}
 
 	return m, nil
@@ -239,8 +241,15 @@ func (m *persistenceModule) shouldHydrateGenesisDb() (bool, error) {
 	}
 	defer checkContext.Close()
 
-	if _, err = checkContext.GetLatestBlockHeight(); err != nil {
+	blockHeight, err := checkContext.GetLatestBlockHeight()
+	if err != nil {
 		return true, nil
 	}
+
+	if blockHeight == 0 {
+		m.clearAllState(nil)
+		return true, nil
+	}
+
 	return false, nil
 }

From ec05e05bd394ed0320b018b5caea89d0e285273c Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 30 Nov 2022 07:09:52 -0800
Subject: [PATCH 215/227] Remove TestUtilityContext_HandleMessage

---
 Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index 31a150037..9ae99f784 100644
--- a/Makefile
+++ b/Makefile
@@ -308,7 +308,7 @@ test_all: # generate_mocks
 .PHONY: test_all_with_json_coverage
 ## Run all go unit tests, output results & coverage into json & coverage files
 test_all_with_json_coverage: generate_rpc_openapi # generate_mocks
-	go test -p 1 -json ./... -covermode=count -coverprofile=coverage.out -run TestUtilityContext_HandleMessage | tee test_results.json | jq
+	go test -p 1 -json ./... -covermode=count -coverprofile=coverage.out | tee test_results.json | jq
 
 .PHONY: test_race
 ## Identify all unit tests that may result in race conditions

From 67421745f5810449ce3871eada61290c86bb4369 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 30 Nov 2022 10:52:29 -0800
Subject: [PATCH 216/227] Revert makefile use in workflow

---
 .github/workflows/main.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index b5b89faad..a242b0aea 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -54,7 +54,7 @@ jobs:
         # Not utilizing makefile target here to make use of pipefail bash feature.
         run: |
           set -euo pipefail
-          make test_all_with_json_coverage
+          go test -p 1 -json ./... -covermode=count -coverprofile=coverage.out | tee test_results.json | jq
       - name: Output test failures
         # Makes it easier to find failed tests so no need to scroll through the whole log.
         if: ${{ failure() && env.TARGET_GOLANG_VERSION == matrix.go }}

From bfc30db20b0c90a5214accf491c8712aeeebe3c4 Mon Sep 17 00:00:00 2001
From: Dmitry Knyazev <okdas@users.noreply.github.com>
Date: Wed, 30 Nov 2022 12:50:49 -0800
Subject: [PATCH 217/227] Update main.yml

---
 .github/workflows/main.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index a242b0aea..27d290844 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -91,6 +91,9 @@ jobs:
   # - figure out how to handle musl/alpine case if we want to support it
   build-images:
     runs-on: ubuntu-latest
+    needs: test-multiple-go-versions
+    # Until we have developer environments, we don't need the images built on other that main branches.
+    if: github.ref == 'refs/heads/main'
     strategy:
       matrix:
         # Build dev & prod images

From a8ff1438f55a1af6759d2f53c06a26c7465ed148 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 30 Nov 2022 11:31:09 -0800
Subject: [PATCH 218/227] Fix comment

---
 consensus/state_sync/state_sync.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/consensus/state_sync/state_sync.go b/consensus/state_sync/state_sync.go
index 5ca419853..fac579bee 100644
--- a/consensus/state_sync/state_sync.go
+++ b/consensus/state_sync/state_sync.go
@@ -6,7 +6,7 @@ import (
 	"github.com/pokt-network/pocket/shared/modules"
 )
 
-TODO(#362): Update the interface so it can be easily integrated with the app specific bus
+// TODO(#362): Update the interface so it can be easily integrated with the app specific bus
 type StateSyncModule interface {
 	modules.Module
 

From a2110221e72143c24d0f081322636de907337805 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 30 Nov 2022 12:56:51 -0800
Subject: [PATCH 219/227] Only 2 protocol actors being tested

---
 Makefile                    | 2 +-
 utility/test/module_test.go | 5 ++---
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/Makefile b/Makefile
index 9ae99f784..601f3778e 100644
--- a/Makefile
+++ b/Makefile
@@ -308,7 +308,7 @@ test_all: # generate_mocks
 .PHONY: test_all_with_json_coverage
 ## Run all go unit tests, output results & coverage into json & coverage files
 test_all_with_json_coverage: generate_rpc_openapi # generate_mocks
-	go test -p 1 -json ./... -covermode=count -coverprofile=coverage.out | tee test_results.json | jq
+	go test -p 1 -json ./... -covermode=count -coverprofile=coverage.out -run TestUtilityContext_HandleMessageStake | tee test_results.json | jq
 
 .PHONY: test_race
 ## Identify all unit tests that may result in race conditions
diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index 391f196c3..127be54bf 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -37,8 +37,8 @@ var (
 
 var persistenceDbUrl string
 var actorTypes = []utilTypes.ActorType{
-	utilTypes.ActorType_App,
-	utilTypes.ActorType_ServiceNode,
+	// utilTypes.ActorType_App,
+	// utilTypes.ActorType_ServiceNode,
 	utilTypes.ActorType_Fisherman,
 	utilTypes.ActorType_Validator,
 }
@@ -68,7 +68,6 @@ func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext
 	t.Cleanup(func() {
 		require.NoError(t, testPersistenceMod.ReleaseWriteContext())
 		require.NoError(t, testPersistenceMod.HandleDebugMessage(&messaging.DebugMessage{
-			// Action:  messaging.DebugMessageAction_DEBUG_PERSISTENCE_CLEAR_STATE,
 			Action:  messaging.DebugMessageAction_DEBUG_PERSISTENCE_RESET_TO_GENESIS,
 			Message: nil,
 		}))

From dbb8c182f28dd9e91d1470087e212f57d1536ddf Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 30 Nov 2022 13:03:42 -0800
Subject: [PATCH 220/227] Update main.yml

---
 .github/workflows/main.yml | 2 +-
 Makefile                   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 27d290844..c031b978f 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -54,7 +54,7 @@ jobs:
         # Not utilizing makefile target here to make use of pipefail bash feature.
         run: |
           set -euo pipefail
-          go test -p 1 -json ./... -covermode=count -coverprofile=coverage.out | tee test_results.json | jq
+          go test -p 1 -json ./... -covermode=count -coverprofile=coverage.out -run TestUtilityContext_HandleMessageStake | tee test_results.json | jq
       - name: Output test failures
         # Makes it easier to find failed tests so no need to scroll through the whole log.
         if: ${{ failure() && env.TARGET_GOLANG_VERSION == matrix.go }}
diff --git a/Makefile b/Makefile
index 601f3778e..9ae99f784 100644
--- a/Makefile
+++ b/Makefile
@@ -308,7 +308,7 @@ test_all: # generate_mocks
 .PHONY: test_all_with_json_coverage
 ## Run all go unit tests, output results & coverage into json & coverage files
 test_all_with_json_coverage: generate_rpc_openapi # generate_mocks
-	go test -p 1 -json ./... -covermode=count -coverprofile=coverage.out -run TestUtilityContext_HandleMessageStake | tee test_results.json | jq
+	go test -p 1 -json ./... -covermode=count -coverprofile=coverage.out | tee test_results.json | jq
 
 .PHONY: test_race
 ## Identify all unit tests that may result in race conditions

From a2d401dd45e0670e01d4bb393a717a4891590e62 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 30 Nov 2022 13:06:29 -0800
Subject: [PATCH 221/227] Test TestUtilityContext remote

---
 .github/workflows/main.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index c031b978f..b54ab65b6 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -54,7 +54,7 @@ jobs:
         # Not utilizing makefile target here to make use of pipefail bash feature.
         run: |
           set -euo pipefail
-          go test -p 1 -json ./... -covermode=count -coverprofile=coverage.out -run TestUtilityContext_HandleMessageStake | tee test_results.json | jq
+          go test -p 1 -json ./... -covermode=count -coverprofile=coverage.out -run TestUtilityContext | tee test_results.json | jq
       - name: Output test failures
         # Makes it easier to find failed tests so no need to scroll through the whole log.
         if: ${{ failure() && env.TARGET_GOLANG_VERSION == matrix.go }}

From 30b1156d8267180b94d16aa5e8e6e1e74c5fbf5a Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 30 Nov 2022 13:08:41 -0800
Subject: [PATCH 222/227] Trying out this solution:
 https://stackoverflow.com/a/73561510/768439

---
 utility/test/actor_test.go | 42 +++++++++++++++++++++++++-------------
 utility/test/block_test.go |  6 ++++--
 2 files changed, 32 insertions(+), 16 deletions(-)

diff --git a/utility/test/actor_test.go b/utility/test/actor_test.go
index 25215b6a6..129fd091d 100644
--- a/utility/test/actor_test.go
+++ b/utility/test/actor_test.go
@@ -21,7 +21,8 @@ import (
 // CLEANUP: Move `App` specific tests to `app_test.go`
 
 func TestUtilityContext_HandleMessageStake(t *testing.T) {
-	for _, actorType := range actorTypes {
+	for _, at := range actorTypes {
+		actorType := at
 		t.Run(fmt.Sprintf("%s.HandleMessageStake", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
 
@@ -64,7 +65,8 @@ func TestUtilityContext_HandleMessageStake(t *testing.T) {
 }
 
 func TestUtilityContext_HandleMessageEditStake(t *testing.T) {
-	for _, actorType := range actorTypes {
+	for _, at := range actorTypes {
+		actorType := at
 		t.Run(fmt.Sprintf("%s.HandleMessageEditStake", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
 			actor := getFirstActor(t, ctx, actorType)
@@ -106,7 +108,8 @@ func TestUtilityContext_HandleMessageEditStake(t *testing.T) {
 }
 
 func TestUtilityContext_HandleMessageUnpause(t *testing.T) {
-	for _, actorType := range actorTypes {
+	for _, at := range actorTypes {
+		actorType := at
 		t.Run(fmt.Sprintf("%s.HandleMessageUnpause", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)
 
@@ -153,7 +156,8 @@ func TestUtilityContext_HandleMessageUnpause(t *testing.T) {
 }
 
 func TestUtilityContext_HandleMessageUnstake(t *testing.T) {
-	for _, actorType := range actorTypes {
+	for _, at := range actorTypes {
+		actorType := at
 		t.Run(fmt.Sprintf("%s.HandleMessageUnstake", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)
 
@@ -194,7 +198,8 @@ func TestUtilityContext_HandleMessageUnstake(t *testing.T) {
 }
 
 func TestUtilityContext_BeginUnstakingMaxPaused(t *testing.T) {
-	for _, actorType := range actorTypes {
+	for _, at := range actorTypes {
+		actorType := at
 		t.Run(fmt.Sprintf("%s.BeginUnstakingMaxPaused", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)
 			actor := getFirstActor(t, ctx, actorType)
@@ -241,7 +246,8 @@ func TestUtilityContext_CalculateMaxAppRelays(t *testing.T) {
 }
 
 func TestUtilityContext_CalculateUnstakingHeight(t *testing.T) {
-	for _, actorType := range actorTypes {
+	for _, at := range actorTypes {
+		actorType := at
 		t.Run(fmt.Sprintf("%s.CalculateUnstakingHeight", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
 			var unstakingBlocks int64
@@ -270,7 +276,8 @@ func TestUtilityContext_CalculateUnstakingHeight(t *testing.T) {
 }
 
 func TestUtilityContext_GetExists(t *testing.T) {
-	for _, actorType := range actorTypes {
+	for _, at := range actorTypes {
+		actorType := at
 		t.Run(fmt.Sprintf("%s.GetExists", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
 
@@ -295,7 +302,8 @@ func TestUtilityContext_GetExists(t *testing.T) {
 }
 
 func TestUtilityContext_GetOutputAddress(t *testing.T) {
-	for _, actorType := range actorTypes {
+	for _, at := range actorTypes {
+		actorType := at
 		t.Run(fmt.Sprintf("%s.GetOutputAddress", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
 
@@ -313,7 +321,8 @@ func TestUtilityContext_GetOutputAddress(t *testing.T) {
 }
 
 func TestUtilityContext_GetPauseHeightIfExists(t *testing.T) {
-	for _, actorType := range actorTypes {
+	for _, at := range actorTypes {
+		actorType := at
 		t.Run(fmt.Sprintf("%s.GetPauseHeightIfExists", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
 			pauseHeight := int64(100)
@@ -341,7 +350,8 @@ func TestUtilityContext_GetPauseHeightIfExists(t *testing.T) {
 }
 
 func TestUtilityContext_GetMessageEditStakeSignerCandidates(t *testing.T) {
-	for _, actorType := range actorTypes {
+	for _, at := range actorTypes {
+		actorType := at
 		t.Run(fmt.Sprintf("%s.GetMessageEditStakeSignerCandidates", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
 			actor := getFirstActor(t, ctx, actorType)
@@ -368,7 +378,8 @@ func TestUtilityContext_GetMessageEditStakeSignerCandidates(t *testing.T) {
 }
 
 func TestUtilityContext_GetMessageUnpauseSignerCandidates(t *testing.T) {
-	for _, actorType := range actorTypes {
+	for _, at := range actorTypes {
+		actorType := at
 		t.Run(fmt.Sprintf("%s.GetMessageUnpauseSignerCandidates", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
 			actor := getFirstActor(t, ctx, actorType)
@@ -393,7 +404,8 @@ func TestUtilityContext_GetMessageUnpauseSignerCandidates(t *testing.T) {
 }
 
 func TestUtilityContext_GetMessageUnstakeSignerCandidates(t *testing.T) {
-	for _, actorType := range actorTypes {
+	for _, at := range actorTypes {
+		actorType := at
 		t.Run(fmt.Sprintf("%s.GetMessageUnstakeSignerCandidates", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
 			actor := getFirstActor(t, ctx, actorType)
@@ -418,7 +430,8 @@ func TestUtilityContext_GetMessageUnstakeSignerCandidates(t *testing.T) {
 }
 
 func TestUtilityContext_UnstakePausedBefore(t *testing.T) {
-	for _, actorType := range actorTypes {
+	for _, at := range actorTypes {
+		actorType := at
 		t.Run(fmt.Sprintf("%s.UnstakePausedBefore", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)
 
@@ -477,7 +490,8 @@ func TestUtilityContext_UnstakePausedBefore(t *testing.T) {
 }
 
 func TestUtilityContext_UnstakeActorsThatAreReady(t *testing.T) {
-	for _, actorType := range actorTypes {
+	for _, at := range actorTypes {
+		actorType := at
 		t.Run(fmt.Sprintf("%s.UnstakeActorsThatAreReady", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)
 
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index 5fb1ab5fa..f5ee87c11 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -89,7 +89,8 @@ func TestUtilityContext_BeginBlock(t *testing.T) {
 }
 
 func TestUtilityContext_BeginUnstakingMaxPausedActors(t *testing.T) {
-	for _, actorType := range actorTypes {
+	for _, at := range actorTypes {
+		actorType := at
 		t.Run(fmt.Sprintf("%s.BeginUnstakingMaxPausedActors", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)
 			actor := getFirstActor(t, ctx, actorType)
@@ -165,7 +166,8 @@ func TestUtilityContext_EndBlock(t *testing.T) {
 }
 
 func TestUtilityContext_UnstakeValidatorsActorsThatAreReady(t *testing.T) {
-	for _, actorType := range actorTypes {
+	for _, at := range actorTypes {
+		actorType := at
 		t.Run(fmt.Sprintf("%s.UnstakeValidatorsActorsThatAreReady", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)
 

From d9fbe741ffc193c300405ed64b3dfc0ca5a7966a Mon Sep 17 00:00:00 2001
From: Dmitry Knyazev <okdas@users.noreply.github.com>
Date: Wed, 30 Nov 2022 13:16:28 -0800
Subject: [PATCH 223/227] Update main.yml

---
 .github/workflows/main.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index b54ab65b6..b0001dd52 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -54,7 +54,7 @@ jobs:
         # Not utilizing makefile target here to make use of pipefail bash feature.
         run: |
           set -euo pipefail
-          go test -p 1 -json ./... -covermode=count -coverprofile=coverage.out -run TestUtilityContext | tee test_results.json | jq
+          go test -p 1 -json ./... -covermode=count -coverprofile=coverage.out -run TestUtilityContext 2>&1 | tee test_results.json | jq
       - name: Output test failures
         # Makes it easier to find failed tests so no need to scroll through the whole log.
         if: ${{ failure() && env.TARGET_GOLANG_VERSION == matrix.go }}

From 97d4fda34d16f6044b66bff9827432ce71163690 Mon Sep 17 00:00:00 2001
From: Dmitry Knyazev <okdas@users.noreply.github.com>
Date: Wed, 30 Nov 2022 13:18:20 -0800
Subject: [PATCH 224/227] Update main.yml

---
 .github/workflows/main.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index b0001dd52..fb04c28cf 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -54,7 +54,7 @@ jobs:
         # Not utilizing makefile target here to make use of pipefail bash feature.
         run: |
           set -euo pipefail
-          go test -p 1 -json ./... -covermode=count -coverprofile=coverage.out -run TestUtilityContext 2>&1 | tee test_results.json | jq
+          go test -p 1 -json ./... -covermode=count -coverprofile=coverage.out -run TestUtilityContext 2>&1 | tee test_results.json
       - name: Output test failures
         # Makes it easier to find failed tests so no need to scroll through the whole log.
         if: ${{ failure() && env.TARGET_GOLANG_VERSION == matrix.go }}

From 7da547b8204ade548c3cc4f8c743593d75e68ea0 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 30 Nov 2022 13:20:06 -0800
Subject: [PATCH 225/227] Only create one persistence mod in all utility tests

---
 persistence/test/setup_test.go |  2 +-
 utility/test/module_test.go    | 74 +++++++++++++++++++++++-----------
 2 files changed, 51 insertions(+), 25 deletions(-)

diff --git a/persistence/test/setup_test.go b/persistence/test/setup_test.go
index c92137fc3..fbd0a0c79 100644
--- a/persistence/test/setup_test.go
+++ b/persistence/test/setup_test.go
@@ -78,7 +78,7 @@ func NewTestPostgresContext(t testing.TB, height int64) *persistence.PostgresCon
 	return db
 }
 
-// TODO(andrew): Take in `t testing.T` as a parameter and error if there's an issue
+// TODO(olshansky): Take in `t testing.T` as a parameter and error if there's an issue
 func newTestPersistenceModule(databaseUrl string) modules.PersistenceModule {
 	// HACK: See `runtime/test_artifacts/generator.go` for why we're doing this to get deterministic key generation.
 	os.Setenv(test_artifacts.PrivateKeySeedEnv, "42")
diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index 127be54bf..4232dc8a1 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -2,17 +2,18 @@ package test
 
 import (
 	"encoding/hex"
+	"log"
 	"math/big"
 	"os"
 	"testing"
 
-	"github.com/golang/mock/gomock"
 	"github.com/pokt-network/pocket/persistence"
+	"github.com/pokt-network/pocket/persistence/types"
+	"github.com/pokt-network/pocket/runtime"
 	"github.com/pokt-network/pocket/runtime/defaults"
 	"github.com/pokt-network/pocket/runtime/test_artifacts"
 	"github.com/pokt-network/pocket/shared/messaging"
 	"github.com/pokt-network/pocket/shared/modules"
-	mock_modules "github.com/pokt-network/pocket/shared/modules/mocks"
 	"github.com/pokt-network/pocket/utility"
 	utilTypes "github.com/pokt-network/pocket/utility/types"
 	"github.com/stretchr/testify/require"
@@ -35,6 +36,7 @@ var (
 	testMessageSendType        = "MessageSend"
 )
 
+var testPersistenceMod modules.PersistenceModule // initialized in TestMain
 var persistenceDbUrl string
 var actorTypes = []utilTypes.ActorType{
 	// utilTypes.ActorType_App,
@@ -49,7 +51,8 @@ func NewTestingMempool(_ *testing.T) utilTypes.Mempool {
 
 func TestMain(m *testing.M) {
 	pool, resource, dbUrl := test_artifacts.SetupPostgresDocker()
-	persistenceDbUrl = dbUrl
+	testPersistenceMod = newTestPersistenceModule(dbUrl)
+	// persistenceDbUrl = dbUrl
 	exitCode := m.Run()
 	test_artifacts.CleanupPostgresDocker(m, pool, resource)
 	os.Exit(exitCode)
@@ -57,7 +60,7 @@ func TestMain(m *testing.M) {
 
 func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext {
 	// IMPROVE: Avoid creating a new persistence module with every test
-	testPersistenceMod := newTestPersistenceModule(t, persistenceDbUrl)
+	// testPersistenceMod := newTestPersistenceModule(t, persistenceDbUrl)
 
 	persistenceContext, err := testPersistenceMod.NewRWContext(height)
 	require.NoError(t, err)
@@ -84,33 +87,56 @@ func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext
 	}
 }
 
-func newTestPersistenceModule(t *testing.T, databaseUrl string) modules.PersistenceModule {
-	ctrl := gomock.NewController(t)
+// TODO(olshansky): Take in `t testing.T` as a parameter and error if there's an issue
+func newTestPersistenceModule(databaseUrl string) modules.PersistenceModule {
+	// HACK: See `runtime/test_artifacts/generator.go` for why we're doing this to get deterministic key generation.
+	// os.Setenv(test_artifacts.PrivateKeySeedEnv, "42")
+	// defer os.Unsetenv(test_artifacts.PrivateKeySeedEnv)
+
+	cfg := runtime.NewConfig(&runtime.BaseConfig{}, runtime.WithPersistenceConfig(&types.PersistenceConfig{
+		PostgresUrl:    databaseUrl,
+		NodeSchema:     testSchema,
+		BlockStorePath: "",
+		TxIndexerPath:  "",
+		TreesStoreDir:  "",
+	}))
+	genesisState, _ := test_artifacts.NewGenesisState(5, 1, 1, 1)
+	runtimeCfg := runtime.NewManager(cfg, genesisState)
 
-	mockPersistenceConfig := mock_modules.NewMockPersistenceConfig(ctrl)
-	mockPersistenceConfig.EXPECT().GetPostgresUrl().Return(databaseUrl).AnyTimes()
-	mockPersistenceConfig.EXPECT().GetNodeSchema().Return(testSchema).AnyTimes()
-	mockPersistenceConfig.EXPECT().GetBlockStorePath().Return("").AnyTimes()
-	mockPersistenceConfig.EXPECT().GetTxIndexerPath().Return("").AnyTimes()
-	mockPersistenceConfig.EXPECT().GetTreesStoreDir().Return("").AnyTimes()
+	persistenceMod, err := persistence.Create(runtimeCfg)
+	if err != nil {
+		log.Fatalf("Error creating persistence module: %s", err)
+	}
+	return persistenceMod.(modules.PersistenceModule)
+}
 
-	mockRuntimeConfig := mock_modules.NewMockConfig(ctrl)
-	mockRuntimeConfig.EXPECT().GetPersistenceConfig().Return(mockPersistenceConfig).AnyTimes()
+// func newTestPersistenceModule(t *testing.T, databaseUrl string) modules.PersistenceModule {
+// 	ctrl := gomock.NewController(t)
 
-	mockRuntimeMgr := mock_modules.NewMockRuntimeMgr(ctrl)
-	mockRuntimeMgr.EXPECT().GetConfig().Return(mockRuntimeConfig).AnyTimes()
+// 	mockPersistenceConfig := mock_modules.NewMockPersistenceConfig(ctrl)
+// 	mockPersistenceConfig.EXPECT().GetPostgresUrl().Return(databaseUrl).AnyTimes()
+// 	mockPersistenceConfig.EXPECT().GetNodeSchema().Return(testSchema).AnyTimes()
+// 	mockPersistenceConfig.EXPECT().GetBlockStorePath().Return("").AnyTimes()
+// 	mockPersistenceConfig.EXPECT().GetTxIndexerPath().Return("").AnyTimes()
+// 	mockPersistenceConfig.EXPECT().GetTreesStoreDir().Return("").AnyTimes()
 
-	genesisState, _ := test_artifacts.NewGenesisState(5, 1, 1, 1)
-	mockRuntimeMgr.EXPECT().GetGenesis().Return(genesisState).AnyTimes()
+// 	mockRuntimeConfig := mock_modules.NewMockConfig(ctrl)
+// 	mockRuntimeConfig.EXPECT().GetPersistenceConfig().Return(mockPersistenceConfig).AnyTimes()
 
-	persistenceMod, err := persistence.Create(mockRuntimeMgr)
-	require.NoError(t, err)
+// 	mockRuntimeMgr := mock_modules.NewMockRuntimeMgr(ctrl)
+// 	mockRuntimeMgr.EXPECT().GetConfig().Return(mockRuntimeConfig).AnyTimes()
 
-	err = persistenceMod.Start()
-	require.NoError(t, err)
+// 	genesisState, _ := test_artifacts.NewGenesisState(5, 1, 1, 1)
+// 	mockRuntimeMgr.EXPECT().GetGenesis().Return(genesisState).AnyTimes()
 
-	return persistenceMod.(modules.PersistenceModule)
-}
+// 	persistenceMod, err := persistence.Create(mockRuntimeMgr)
+// 	require.NoError(t, err)
+
+// 	err = persistenceMod.Start()
+// 	require.NoError(t, err)
+
+// 	return persistenceMod.(modules.PersistenceModule)
+// }
 
 func requireValidTestingTxResults(t *testing.T, tx *utilTypes.Transaction, txResults []modules.TxResult) {
 	for _, txResult := range txResults {

From 00986d0c138e0f5650bbe36fb37bbb78dde115a2 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 30 Nov 2022 13:23:15 -0800
Subject: [PATCH 226/227] Run :all_the_tests:

---
 .github/workflows/main.yml  |  2 +-
 utility/test/module_test.go | 41 ++-----------------------------------
 2 files changed, 3 insertions(+), 40 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index fb04c28cf..a13fac5aa 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -54,7 +54,7 @@ jobs:
         # Not utilizing makefile target here to make use of pipefail bash feature.
         run: |
           set -euo pipefail
-          go test -p 1 -json ./... -covermode=count -coverprofile=coverage.out -run TestUtilityContext 2>&1 | tee test_results.json
+          go test -p 1 -json ./... -covermode=count -coverprofile=coverage.out 2>&1 | tee test_results.json
       - name: Output test failures
         # Makes it easier to find failed tests so no need to scroll through the whole log.
         if: ${{ failure() && env.TARGET_GOLANG_VERSION == matrix.go }}
diff --git a/utility/test/module_test.go b/utility/test/module_test.go
index 4232dc8a1..2ad166bdf 100644
--- a/utility/test/module_test.go
+++ b/utility/test/module_test.go
@@ -37,10 +37,9 @@ var (
 )
 
 var testPersistenceMod modules.PersistenceModule // initialized in TestMain
-var persistenceDbUrl string
 var actorTypes = []utilTypes.ActorType{
-	// utilTypes.ActorType_App,
-	// utilTypes.ActorType_ServiceNode,
+	utilTypes.ActorType_App,
+	utilTypes.ActorType_ServiceNode,
 	utilTypes.ActorType_Fisherman,
 	utilTypes.ActorType_Validator,
 }
@@ -52,16 +51,12 @@ func NewTestingMempool(_ *testing.T) utilTypes.Mempool {
 func TestMain(m *testing.M) {
 	pool, resource, dbUrl := test_artifacts.SetupPostgresDocker()
 	testPersistenceMod = newTestPersistenceModule(dbUrl)
-	// persistenceDbUrl = dbUrl
 	exitCode := m.Run()
 	test_artifacts.CleanupPostgresDocker(m, pool, resource)
 	os.Exit(exitCode)
 }
 
 func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext {
-	// IMPROVE: Avoid creating a new persistence module with every test
-	// testPersistenceMod := newTestPersistenceModule(t, persistenceDbUrl)
-
 	persistenceContext, err := testPersistenceMod.NewRWContext(height)
 	require.NoError(t, err)
 
@@ -89,10 +84,6 @@ func NewTestingUtilityContext(t *testing.T, height int64) utility.UtilityContext
 
 // TODO(olshansky): Take in `t testing.T` as a parameter and error if there's an issue
 func newTestPersistenceModule(databaseUrl string) modules.PersistenceModule {
-	// HACK: See `runtime/test_artifacts/generator.go` for why we're doing this to get deterministic key generation.
-	// os.Setenv(test_artifacts.PrivateKeySeedEnv, "42")
-	// defer os.Unsetenv(test_artifacts.PrivateKeySeedEnv)
-
 	cfg := runtime.NewConfig(&runtime.BaseConfig{}, runtime.WithPersistenceConfig(&types.PersistenceConfig{
 		PostgresUrl:    databaseUrl,
 		NodeSchema:     testSchema,
@@ -110,34 +101,6 @@ func newTestPersistenceModule(databaseUrl string) modules.PersistenceModule {
 	return persistenceMod.(modules.PersistenceModule)
 }
 
-// func newTestPersistenceModule(t *testing.T, databaseUrl string) modules.PersistenceModule {
-// 	ctrl := gomock.NewController(t)
-
-// 	mockPersistenceConfig := mock_modules.NewMockPersistenceConfig(ctrl)
-// 	mockPersistenceConfig.EXPECT().GetPostgresUrl().Return(databaseUrl).AnyTimes()
-// 	mockPersistenceConfig.EXPECT().GetNodeSchema().Return(testSchema).AnyTimes()
-// 	mockPersistenceConfig.EXPECT().GetBlockStorePath().Return("").AnyTimes()
-// 	mockPersistenceConfig.EXPECT().GetTxIndexerPath().Return("").AnyTimes()
-// 	mockPersistenceConfig.EXPECT().GetTreesStoreDir().Return("").AnyTimes()
-
-// 	mockRuntimeConfig := mock_modules.NewMockConfig(ctrl)
-// 	mockRuntimeConfig.EXPECT().GetPersistenceConfig().Return(mockPersistenceConfig).AnyTimes()
-
-// 	mockRuntimeMgr := mock_modules.NewMockRuntimeMgr(ctrl)
-// 	mockRuntimeMgr.EXPECT().GetConfig().Return(mockRuntimeConfig).AnyTimes()
-
-// 	genesisState, _ := test_artifacts.NewGenesisState(5, 1, 1, 1)
-// 	mockRuntimeMgr.EXPECT().GetGenesis().Return(genesisState).AnyTimes()
-
-// 	persistenceMod, err := persistence.Create(mockRuntimeMgr)
-// 	require.NoError(t, err)
-
-// 	err = persistenceMod.Start()
-// 	require.NoError(t, err)
-
-// 	return persistenceMod.(modules.PersistenceModule)
-// }
-
 func requireValidTestingTxResults(t *testing.T, tx *utilTypes.Transaction, txResults []modules.TxResult) {
 	for _, txResult := range txResults {
 		msg, err := tx.GetMessage()

From 5df8756395f7a9182befdeb77154d4b2146464e6 Mon Sep 17 00:00:00 2001
From: Daniel Olshansky <olshansky.daniel@gmail.com>
Date: Wed, 30 Nov 2022 13:27:04 -0800
Subject: [PATCH 227/227] Removing shitty code

---
 utility/test/actor_test.go | 42 +++++++++++++-------------------------
 utility/test/block_test.go |  6 ++----
 2 files changed, 16 insertions(+), 32 deletions(-)

diff --git a/utility/test/actor_test.go b/utility/test/actor_test.go
index 129fd091d..25215b6a6 100644
--- a/utility/test/actor_test.go
+++ b/utility/test/actor_test.go
@@ -21,8 +21,7 @@ import (
 // CLEANUP: Move `App` specific tests to `app_test.go`
 
 func TestUtilityContext_HandleMessageStake(t *testing.T) {
-	for _, at := range actorTypes {
-		actorType := at
+	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.HandleMessageStake", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
 
@@ -65,8 +64,7 @@ func TestUtilityContext_HandleMessageStake(t *testing.T) {
 }
 
 func TestUtilityContext_HandleMessageEditStake(t *testing.T) {
-	for _, at := range actorTypes {
-		actorType := at
+	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.HandleMessageEditStake", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
 			actor := getFirstActor(t, ctx, actorType)
@@ -108,8 +106,7 @@ func TestUtilityContext_HandleMessageEditStake(t *testing.T) {
 }
 
 func TestUtilityContext_HandleMessageUnpause(t *testing.T) {
-	for _, at := range actorTypes {
-		actorType := at
+	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.HandleMessageUnpause", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)
 
@@ -156,8 +153,7 @@ func TestUtilityContext_HandleMessageUnpause(t *testing.T) {
 }
 
 func TestUtilityContext_HandleMessageUnstake(t *testing.T) {
-	for _, at := range actorTypes {
-		actorType := at
+	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.HandleMessageUnstake", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)
 
@@ -198,8 +194,7 @@ func TestUtilityContext_HandleMessageUnstake(t *testing.T) {
 }
 
 func TestUtilityContext_BeginUnstakingMaxPaused(t *testing.T) {
-	for _, at := range actorTypes {
-		actorType := at
+	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.BeginUnstakingMaxPaused", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)
 			actor := getFirstActor(t, ctx, actorType)
@@ -246,8 +241,7 @@ func TestUtilityContext_CalculateMaxAppRelays(t *testing.T) {
 }
 
 func TestUtilityContext_CalculateUnstakingHeight(t *testing.T) {
-	for _, at := range actorTypes {
-		actorType := at
+	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.CalculateUnstakingHeight", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
 			var unstakingBlocks int64
@@ -276,8 +270,7 @@ func TestUtilityContext_CalculateUnstakingHeight(t *testing.T) {
 }
 
 func TestUtilityContext_GetExists(t *testing.T) {
-	for _, at := range actorTypes {
-		actorType := at
+	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.GetExists", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
 
@@ -302,8 +295,7 @@ func TestUtilityContext_GetExists(t *testing.T) {
 }
 
 func TestUtilityContext_GetOutputAddress(t *testing.T) {
-	for _, at := range actorTypes {
-		actorType := at
+	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.GetOutputAddress", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
 
@@ -321,8 +313,7 @@ func TestUtilityContext_GetOutputAddress(t *testing.T) {
 }
 
 func TestUtilityContext_GetPauseHeightIfExists(t *testing.T) {
-	for _, at := range actorTypes {
-		actorType := at
+	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.GetPauseHeightIfExists", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
 			pauseHeight := int64(100)
@@ -350,8 +341,7 @@ func TestUtilityContext_GetPauseHeightIfExists(t *testing.T) {
 }
 
 func TestUtilityContext_GetMessageEditStakeSignerCandidates(t *testing.T) {
-	for _, at := range actorTypes {
-		actorType := at
+	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.GetMessageEditStakeSignerCandidates", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
 			actor := getFirstActor(t, ctx, actorType)
@@ -378,8 +368,7 @@ func TestUtilityContext_GetMessageEditStakeSignerCandidates(t *testing.T) {
 }
 
 func TestUtilityContext_GetMessageUnpauseSignerCandidates(t *testing.T) {
-	for _, at := range actorTypes {
-		actorType := at
+	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.GetMessageUnpauseSignerCandidates", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
 			actor := getFirstActor(t, ctx, actorType)
@@ -404,8 +393,7 @@ func TestUtilityContext_GetMessageUnpauseSignerCandidates(t *testing.T) {
 }
 
 func TestUtilityContext_GetMessageUnstakeSignerCandidates(t *testing.T) {
-	for _, at := range actorTypes {
-		actorType := at
+	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.GetMessageUnstakeSignerCandidates", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 0)
 			actor := getFirstActor(t, ctx, actorType)
@@ -430,8 +418,7 @@ func TestUtilityContext_GetMessageUnstakeSignerCandidates(t *testing.T) {
 }
 
 func TestUtilityContext_UnstakePausedBefore(t *testing.T) {
-	for _, at := range actorTypes {
-		actorType := at
+	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.UnstakePausedBefore", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)
 
@@ -490,8 +477,7 @@ func TestUtilityContext_UnstakePausedBefore(t *testing.T) {
 }
 
 func TestUtilityContext_UnstakeActorsThatAreReady(t *testing.T) {
-	for _, at := range actorTypes {
-		actorType := at
+	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.UnstakeActorsThatAreReady", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)
 
diff --git a/utility/test/block_test.go b/utility/test/block_test.go
index f5ee87c11..5fb1ab5fa 100644
--- a/utility/test/block_test.go
+++ b/utility/test/block_test.go
@@ -89,8 +89,7 @@ func TestUtilityContext_BeginBlock(t *testing.T) {
 }
 
 func TestUtilityContext_BeginUnstakingMaxPausedActors(t *testing.T) {
-	for _, at := range actorTypes {
-		actorType := at
+	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.BeginUnstakingMaxPausedActors", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)
 			actor := getFirstActor(t, ctx, actorType)
@@ -166,8 +165,7 @@ func TestUtilityContext_EndBlock(t *testing.T) {
 }
 
 func TestUtilityContext_UnstakeValidatorsActorsThatAreReady(t *testing.T) {
-	for _, at := range actorTypes {
-		actorType := at
+	for _, actorType := range actorTypes {
 		t.Run(fmt.Sprintf("%s.UnstakeValidatorsActorsThatAreReady", actorType.String()), func(t *testing.T) {
 			ctx := NewTestingUtilityContext(t, 1)