return sql.ErrNotFound if account doesn't exist

common/types/testutil.go

@@ -2,6 +2,9 @@ package types
 
 import (
 	"crypto/rand"
+	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 // RandomBytes generates random data in bytes for testing.
@@ -137,3 +140,10 @@ func RandomVrfSignature() VrfSignature {
 	}
 	return VrfSignature(b)
 }
+
+func RandomAddress(tb testing.TB) Address {
+	var a Address
+	_, err := rand.Read(a[:])
+	require.NoError(tb, err)
+	return a
+}

genvm/core/context.go

@@ -2,6 +2,7 @@
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 
 	"github.com/spacemeshos/go-scale"
@@ -235,7 +236,10 @@
 	account, exist := c.changed[address]
 	if !exist {
 		loaded, err := c.Loader.Get(address)
-		if err != nil {
+		switch {
+		case errors.Is(err, ErrNotFound):
+			loaded = types.Account{Address: address}
+		case err != nil:
 			return nil, fmt.Errorf("%w: %w", ErrInternal, err)
 		}
 		account = &loaded

genvm/core/context_test.go

@@ -193,10 +193,8 @@ func TestRelay(t *testing.T) {
 				require.Equal(t, amount1, int(rec1state.Balance))
 				require.NotEqual(t, encoded, rec1state.State)
 
-				rec2state, err := cache.Get(receiver2)
-				require.NoError(t, err)
-				require.Equal(t, 0, int(rec2state.Balance))
-				require.NotEqual(t, encoded, rec2state.State)
+				_, err = cache.Get(receiver2)
+				require.ErrorIs(t, err, core.ErrNotFound) // relay to receiver2 failed
 
 				remoteState, err := cache.Get(remote)
 				require.NoError(t, err)

genvm/core/staged_cache.go

@@ -1,6 +1,8 @@
 package core
 
 import (
+	"errors"
+
 	"github.com/spacemeshos/go-spacemesh/common/types"
 	"github.com/spacemeshos/go-spacemesh/sql"
 	"github.com/spacemeshos/go-spacemesh/sql/accounts"
@@ -11,7 +13,11 @@ type DBLoader struct {
 }
 
 func (db DBLoader) Get(address types.Address) (types.Account, error) {
-	return accounts.Latest(db.Executor, address)
+	account, err := accounts.Latest(db.Executor, address)
+	if errors.Is(err, sql.ErrNotFound) {
+		return types.Account{}, ErrNotFound
+	}
+	return account, err
 }
 
 // NewStagedCache returns instance of the staged cache.

genvm/core/staged_cache_test.go

@@ -13,6 +13,7 @@ func TestCacheGetCopies(t *testing.T) {
 	db := statesql.InMemoryTest(t)
 	ss := core.NewStagedCache(core.DBLoader{db})
 	address := core.Address{1}
+	ss.Update(core.Account{Address: address})
 	account, err := ss.Get(address)
 	require.NoError(t, err)
 	account.Balance = 100

genvm/core/types.go

@@ -1,6 +1,8 @@
 package core
 
 import (
+	"errors"
+
 	"github.com/spacemeshos/go-scale"
 
 	"github.com/spacemeshos/go-spacemesh/common/types"
@@ -76,8 +78,13 @@ type Template interface {
 	Verify(Host, []byte, *scale.Decoder) bool
 }
 
+var ErrNotFound = errors.New("not found")
+
 // AccountLoader is an interface for loading accounts.
 type AccountLoader interface {
+	// Get account for given address
+	//
+	// Returns ErrNotFound if the account doesn't exist.
 	Get(Address) (Account, error)
 }
 

genvm/rewards.go

@@ -1,6 +1,7 @@
 package vm
 
 import (
+	"errors"
 	"fmt"
 	"math/big"
 
@@ -67,7 +68,10 @@
 		}
 		result = append(result, reward)
 		account, err := ss.Get(blockReward.Coinbase)
-		if err != nil {
+		switch {
+		case errors.Is(err, core.ErrNotFound):
+			account = types.Account{Address: blockReward.Coinbase}
+		case err != nil:
 			return nil, fmt.Errorf("%w: %w", core.ErrInternal, err)
 		}
 		account.Balance += reward.TotalReward

genvm/vm.go

@@ -156,7 +156,10 @@
 // GetNonce returns expected next nonce for the address.
 func (v *VM) GetNonce(address core.Address) (core.Nonce, error) {
 	account, err := accounts.Latest(v.db, address)
-	if err != nil {
+	switch {
+	case errors.Is(err, sql.ErrNotFound):
+		return 0, nil
+	case err != nil:
 		return 0, err
 	}
 	return account.NextNonce, nil
@@ -165,7 +168,10 @@
 // GetBalance returns balance for an address.
 func (v *VM) GetBalance(address types.Address) (uint64, error) {
 	account, err := accounts.Latest(v.db, address)
-	if err != nil {
+	switch {
+	case errors.Is(err, sql.ErrNotFound):
+		return 0, nil
+	case err != nil:
 		return 0, err
 	}
 	return account.Balance, nil
@@ -501,11 +507,14 @@
 		return nil, nil, nil, fmt.Errorf("%w: failed to decode method selector %w", core.ErrMalformed, err)
 	}
 	account, err := loader.Get(principal)
-	if err != nil {
+	switch {
+	case errors.Is(err, core.ErrNotFound):
+		account = types.Account{Address: principal}
+	case err != nil:
 		return nil, nil, nil, fmt.Errorf(
-			"%w: failed load state for principal %s - %w",
+			"%w: failed load state for principal %s: %w",
 			core.ErrInternal,
-			principal,
+			principal.String(),
 			err,
 		)
 	}

genvm/vm_test.go

@@ -34,6 +34,7 @@ import (
 	"github.com/spacemeshos/go-spacemesh/genvm/templates/wallet"
 	"github.com/spacemeshos/go-spacemesh/hash"
 	"github.com/spacemeshos/go-spacemesh/signing"
+	"github.com/spacemeshos/go-spacemesh/sql"
 	"github.com/spacemeshos/go-spacemesh/sql/accounts"
 	"github.com/spacemeshos/go-spacemesh/sql/layers"
 	"github.com/spacemeshos/go-spacemesh/sql/statesql"
@@ -1441,9 +1442,13 @@ func runTestCases(t *testing.T, tcs []templateTestCase, genTester func(t *testin
 				}
 				for account, changes := range layer.expected {
 					prev, err := accounts.Get(tt.db, tt.accounts[account].getAddress(), lid.Sub(1))
-					require.NoError(tt, err)
+					if err != nil {
+						require.ErrorIs(t, err, sql.ErrNotFound)
+					}
 					current, err := accounts.Get(tt.db, tt.accounts[account].getAddress(), lid)
-					require.NoError(tt, err)
+					if err != nil {
+						require.ErrorIs(t, err, sql.ErrNotFound)
+					}
 					tt.Logf("verifying account index=%d in layer index=%d", account, i)
 					changes.verify(tt, &prev, &current)
 				}
@@ -1652,6 +1657,7 @@ func testValidation(t *testing.T, tt *tester, template core.Address) {
 			if tc.err != nil {
 				require.ErrorIs(t, err, tc.err)
 			} else {
+				require.NoError(t, err)
 				require.Equal(t, tc.verified, req.Verify())
 				if tc.verified {
 					require.Equal(t, tc.header, header)

sql/accounts/accounts.go

@@ -24,7 +24,7 @@ func Has(db sql.Executor, address types.Address) (bool, error) {
 // Latest latest account data for an address.
 func Latest(db sql.Executor, address types.Address) (types.Account, error) {
 	var account types.Account
-	_, err := db.Exec(`
+	rows, err := db.Exec(`
 		select balance, next_nonce, layer_updated, template, state from accounts
 		where address = ?1
 		order by layer_updated desc;`,
@@ -46,20 +46,16 @@ func Latest(db sql.Executor, address types.Address) (types.Account, error) {
 	if err != nil {
 		return types.Account{}, fmt.Errorf("failed to load %v: %w", address, err)
 	}
-	// TODO(mafa): returning `sql.ErrNotFound` causes a bunch of tests to fail, some even panic
-	// this needs to be investigated and fixed
-	//
-	// if account.Address != address {
-	// 	return types.Account{}, sql.ErrNotFound
-	// }
-	account.Address = address // without this tests are failing not only assertions but are also panicking
+	if rows == 0 {
+		return types.Account{}, sql.ErrNotFound
+	}
 	return account, nil
 }
 
 // Get account data that was valid at the specified layer.
 func Get(db sql.Executor, address types.Address, layer types.LayerID) (types.Account, error) {
 	var account types.Account
-	_, err := db.Exec(`
+	rows, err := db.Exec(`
 		select balance, next_nonce, layer_updated, template, state from accounts
 		where address = ?1 and layer_updated <= ?2
 		order by layer_updated desc;`,
@@ -84,13 +80,9 @@ func Get(db sql.Executor, address types.Address, layer types.LayerID) (types.Acc
 	if err != nil {
 		return types.Account{}, fmt.Errorf("failed to load %v for layer %v: %w", address, layer, err)
 	}
-	// TODO(mafa): returning `sql.ErrNotFound` causes a bunch of tests to fail, some even panic
-	// this needs to be investigated and fixed
-	//
-	// if account.Address != address {
-	// 	return types.Account{}, sql.ErrNotFound
-	// }
-	account.Address = address // without this tests are failing not only assertions but are also panicking
+	if rows == 0 {
+		return types.Account{}, sql.ErrNotFound
+	}
 	return account, nil
 }
 

sql/accounts/accounts_test.go

@@ -48,6 +48,63 @@
 	require.True(t, has)
 }
 
+func TestLatest(t *testing.T) {
+	t.Run("doesn't exist", func(t *testing.T) {
+		db := statesql.InMemoryTest(t)
+		account, err := Latest(db, types.RandomAddress(t))
+		require.ErrorIs(t, err, sql.ErrNotFound)
+		require.Equal(t, types.Account{}, account)
+	})
+	t.Run("picks latest", func(t *testing.T) {
+		address := types.RandomAddress(t)
+		db := statesql.InMemoryTest(t)
+		err := Update(db, &types.Account{
+			Address: address,
+		})
+		require.NoError(t, err)
+		account := types.Account{
+			Layer:     1,
+			NextNonce: 1,
+			Balance:   100,
+			Address:   address,
+		}
+		err = Update(db, &account)
+		require.NoError(t, err)
+
+		got, err := Latest(db, address)
+		require.NoError(t, err)
+		require.Equal(t, account, got)
+	})
+}
+
+func TestGet(t *testing.T) {
+	t.Run("doesn't exist", func(t *testing.T) {
+		db := statesql.InMemoryTest(t)
+		account, err := Get(db, types.RandomAddress(t), 0)
+		require.ErrorIs(t, err, sql.ErrNotFound)
+		require.Equal(t, types.Account{}, account)
+	})
+	t.Run("picks the right one", func(t *testing.T) {
+		address := types.RandomAddress(t)
+		db := statesql.InMemoryTest(t)
+		account := types.Account{
+			Layer:     1,
+			NextNonce: 1,
+			Balance:   100,
+			Address:   address,
+		}
+		err := Update(db, &account)
+		require.NoError(t, err)
+
+		got, err := Get(db, address, 0)
+		require.ErrorIs(t, err, sql.ErrNotFound)
+
+		got, err = Get(db, address, 1)
+		require.NoError(t, err)
+		require.Equal(t, account, got)
+	})
+}
+
 func TestRevert(t *testing.T) {
 	address := types.Address{1, 1}
 	seq := genSeq(address, 10)