This fixes two issues with our state handling when querying state via

`CallSim` and `CallCodeSim`.

State is separated into a mutable write side and an immutable read side
(from last commit/height) via RWTree and then via MutableForest in an
MVCC style manner. Reads should hit the last committed version. However
there were two bugs in TransactServer's `CallTxSim` and `CallCodeSim`:

1. During the execution of a simulated call if a block is committed
reads can be made from consecutive blocks and so may not see a
consistent view of the state.

2. `ImmutableForest`'s `loadOrCreateTree` was unsynchronised and
committed a multitude of sins: creating and returning multiple trees for the
same prefix when it should ensure one instance exists in cache and most problematically allowing access to uninitialised trees by pushing into LRU
cache before `Load`ing the tree from DB.

The fix for 1 is to pull a snapshot `ImmutableForest` when Call*Sim are
called which is fixed to the latest height at the time of the call.

The fix for 2 was to synchronise `loadOrCreateTree` and only push
initialised trees into the `treeCache`.

simulated_call_test.go adds a test that triggers the second bug
(requires a cold cache and a prefix with previous existing versions)

Additionally:

- Make MutableForest and ImmutableForest fully thread-safe on reads and
writes.

Signed-off-by: Silas Davis <[email protected]>

Author: Silas Davis

acm/acmstate/state_cache.go

@@ -262,21 +262,26 @@ func (cache *Cache) get(address crypto.Address) (*accountInfo, error) {
 	cache.RLock()
 	accInfo := cache.accounts[address]
 	cache.RUnlock()
-	if accInfo == nil {
-		cache.Lock()
-		defer cache.Unlock()
-		accInfo = cache.accounts[address]
-		if accInfo == nil {
-			account, err := cache.backend.GetAccount(address)
-			if err != nil {
-				return nil, err
-			}
-			accInfo = &accountInfo{
-				account: account,
-				storage: make(map[binary.Word256][]byte),
-			}
-			cache.accounts[address] = accInfo
-		}
+	if accInfo != nil {
+		return accInfo, nil
+	}
+	// Take write lock to fill cache
+	cache.Lock()
+	defer cache.Unlock()
+	// Check for an interleaved cache fill
+	accInfo = cache.accounts[address]
+	if accInfo != nil {
+		return accInfo, nil
+	}
+	// Pull from backend
+	account, err := cache.backend.GetAccount(address)
+	if err != nil {
+		return nil, err
+	}
+	accInfo = &accountInfo{
+		account: account,
+		storage: make(map[binary.Word256][]byte),
 	}
+	cache.accounts[address] = accInfo
 	return accInfo, nil
 }

cmd/burrow/commands/errors.go

@@ -0,0 +1,29 @@
+package commands
+
+import (
+	"encoding/json"
+
+	"github.com/hyperledger/burrow/execution/errors"
+	cli "github.com/jawher/mow.cli"
+)
+
+func Errors(output Output) func(cmd *cli.Cmd) {
+	return func(cmd *cli.Cmd) {
+
+		jsonOpt := cmd.BoolOpt("j json", false, "output errors as a JSON object")
+
+		cmd.Spec = "[ --json ]"
+
+		cmd.Action = func() {
+			if *jsonOpt {
+				bs, err := json.MarshalIndent(errors.Codes, "", "\t")
+				if err != nil {
+					output.Fatalf("Could not marshal error codes: %w", err)
+				}
+				output.Printf(string(bs))
+			} else {
+				output.Printf(errors.Codes.String())
+			}
+		}
+	}
+}

cmd/burrow/main.go

@@ -87,6 +87,8 @@ func burrow(output commands.Output) *cli.Cli {
 	app.Command("compile", "Compile solidity files embedding the compilation results as a fixture in a Go file",
 		commands.Compile(output))
 
+	app.Command("errors", "Print error codes",
+		commands.Errors(output))
 	return app
 }
 

core/processes.go

@@ -6,6 +6,8 @@ import (
 	"net/http"
 	"time"
 
+	"github.com/hyperledger/burrow/acm/acmstate"
+
 	"github.com/hyperledger/burrow/bcm"
 	"github.com/hyperledger/burrow/consensus/abci"
 	"github.com/hyperledger/burrow/execution"
@@ -320,7 +322,9 @@ func GRPCLauncher(kern *Kernel, conf *rpc.ServerConfig, keyConfig *keys.KeysConf
 
 			txCodec := txs.NewProtobufCodec()
 			rpctransact.RegisterTransactServer(grpcServer,
-				rpctransact.NewTransactServer(kern.State, kern.Blockchain, kern.Transactor, txCodec, kern.Logger))
+				rpctransact.NewTransactServer(func() (acmstate.Reader, error) {
+					return kern.State.AtLatestVersion()
+				}, kern.Blockchain, kern.Transactor, txCodec, kern.Logger))
 
 			rpcevents.RegisterExecutionEventsServer(grpcServer, rpcevents.NewExecutionEventsServer(kern.State,
 				kern.Emitter, kern.Blockchain, kern.Logger))

dump/dump.go

@@ -70,7 +70,7 @@ func (ds *Dumper) Transmit(sink Sink, startHeight, endHeight uint64, options Opt
 	if endHeight == 0 || endHeight > lastHeight {
 		endHeight = lastHeight
 	}
-	st, err := ds.state.LoadHeight(endHeight)
+	st, err := ds.state.AtHeight(endHeight)
 	if err != nil {
 		return err
 	}

execution/accounts.go

@@ -36,6 +36,7 @@ func NewAccounts(reader acmstate.Reader, keyClient keys.KeyClient, mutexCount in
 		keyClient: keyClient,
 	}
 }
+
 func (accs *Accounts) SigningAccount(address crypto.Address) (*SigningAccount, error) {
 	signer, err := keys.AddressableSigner(accs.keyClient, address)
 	if err != nil {

execution/errors/codes.go

@@ -4,6 +4,8 @@ import (
 	"encoding/json"
 	"fmt"
 	"reflect"
+	"strconv"
+	"strings"
 )
 
 type codes struct {
@@ -89,3 +91,16 @@ func (es *codes) Get(number uint32) *Code {
 	}
 	return es.codes[number]
 }
+
+func (es *codes) String() string {
+	sb := new(strings.Builder)
+	for _, c := range es.codes {
+		sb.WriteString(strconv.FormatUint(uint64(c.Number), 10))
+		sb.WriteString(": ")
+		sb.WriteString(c.Name)
+		sb.WriteString(" - ")
+		sb.WriteString(c.Description)
+		sb.WriteRune('\n')
+	}
+	return sb.String()
+}

execution/errors/errors.go

@@ -21,7 +21,7 @@ type Source interface {
 	Error() error
 }
 
-var Codes = codes{
+var Codes = &codes{
 	None:                   code("none"),
 	UnknownAddress:         code("unknown address"),
 	InsufficientBalance:    code("insufficient balance"),

execution/errors/errors_test.go

@@ -25,3 +25,7 @@ func TestCode_String(t *testing.T) {
 	err := Codes.CodeOutOfBounds
 	fmt.Println(err.Error())
 }
+
+func TestPrintCodes(t *testing.T) {
+	fmt.Printf("%v", Codes)
+}

execution/execution.go

@@ -54,6 +54,7 @@ type ExecutorState interface {
 	proposal.Reader
 	validator.IterableReader
 }
+
 type BatchExecutor interface {
 	// Provides access to write lock for a BatchExecutor so reads can be prevented for the duration of a commit
 	sync.Locker
@@ -284,7 +285,7 @@ func (exe *executor) validateInputsAndStorePublicKeys(txEnv *txs.Envelope) error
 	for s, in := range txEnv.Tx.GetInputs() {
 		err := exe.updateSignatory(txEnv.Signatories[s])
 		if err != nil {
-			return fmt.Errorf("failed to update public key for input %v: %v", in.Address, err)
+			return fmt.Errorf("failed to update public key for input %v: %w", in.Address, err)
 		}
 		acc, err := exe.stateCache.GetAccount(in.Address)
 		if err != nil {