Refactor balance store to setup for more tables

Author: Jeff Yanta

pkg/code/balance/calculator.go

@@ -121,7 +121,7 @@ func CalculateFromBlockchain(ctx context.Context, data code_data.Provider, token
 	var cachedQuarks uint64
 	var cachedSlot uint64
 	var cachedUpdateTs time.Time
-	checkpointRecord, err := data.GetBalanceCheckpoint(ctx, tokenAccount.PublicKey().ToBase58())
+	checkpointRecord, err := data.GetExternalBalanceCheckpoint(ctx, tokenAccount.PublicKey().ToBase58())
 	if err == nil {
 		cachedQuarks = checkpointRecord.Quarks
 		cachedSlot = checkpointRecord.SlotCheckpoint
@@ -157,12 +157,12 @@ func CalculateFromBlockchain(ctx context.Context, data code_data.Provider, token
 
 	// Observed a balance that's more recent. Best-effort update the checkpoint.
 	if cachedSlot == 0 || (slot > cachedSlot && quarks != cachedQuarks) {
-		newCheckpointRecord := &balance.Record{
+		newCheckpointRecord := &balance.ExternalCheckpointRecord{
 			TokenAccount:   tokenAccount.PublicKey().ToBase58(),
 			Quarks:         quarks,
 			SlotCheckpoint: slot,
 		}
-		data.SaveBalanceCheckpoint(ctx, newCheckpointRecord)
+		data.SaveExternalBalanceCheckpoint(ctx, newCheckpointRecord)
 	}
 
 	return quarks, BlockchainSource, nil

pkg/code/data/balance/checkpoint.go

@@ -5,8 +5,7 @@ import (
 	"time"
 )
 
-// Note: Only supports external balances
-type Record struct {
+type ExternalCheckpointRecord struct {
 	Id uint64
 
 	TokenAccount   string
@@ -16,16 +15,16 @@ type Record struct {
 	LastUpdatedAt time.Time
 }
 
-func (r *Record) Validate() error {
+func (r *ExternalCheckpointRecord) Validate() error {
 	if len(r.TokenAccount) == 0 {
 		return errors.New("token account is required")
 	}
 
 	return nil
 }
 
-func (r *Record) Clone() Record {
-	return Record{
+func (r *ExternalCheckpointRecord) Clone() ExternalCheckpointRecord {
+	return ExternalCheckpointRecord{
 		Id: r.Id,
 
 		TokenAccount:   r.TokenAccount,
@@ -36,7 +35,7 @@ func (r *Record) Clone() Record {
 	}
 }
 
-func (r *Record) CopyTo(dst *Record) {
+func (r *ExternalCheckpointRecord) CopyTo(dst *ExternalCheckpointRecord) {
 	dst.Id = r.Id
 
 	dst.TokenAccount = r.TokenAccount

pkg/code/data/balance/memory/store.go

@@ -9,18 +9,18 @@ import (
 )
 
 type store struct {
-	mu      sync.Mutex
-	records []*balance.Record
-	last    uint64
+	mu                        sync.Mutex
+	externalCheckpointRecords []*balance.ExternalCheckpointRecord
+	last                      uint64
 }
 
 // New returns a new in memory balance.Store
 func New() balance.Store {
 	return &store{}
 }
 
-// SaveCheckpoint implements balance.Store.SaveCheckpoint
-func (s *store) SaveCheckpoint(_ context.Context, data *balance.Record) error {
+// SaveExternalCheckpoint implements balance.Store.SaveExternalCheckpoint
+func (s *store) SaveExternalCheckpoint(_ context.Context, data *balance.ExternalCheckpointRecord) error {
 	if err := data.Validate(); err != nil {
 		return err
 	}
@@ -29,7 +29,7 @@ func (s *store) SaveCheckpoint(_ context.Context, data *balance.Record) error {
 	defer s.mu.Unlock()
 
 	s.last++
-	if item := s.find(data); item != nil {
+	if item := s.findExternalCheckpoint(data); item != nil {
 		if data.SlotCheckpoint <= item.SlotCheckpoint {
 			return balance.ErrStaleCheckpoint
 		}
@@ -44,26 +44,26 @@ func (s *store) SaveCheckpoint(_ context.Context, data *balance.Record) error {
 		}
 		data.LastUpdatedAt = time.Now()
 		c := data.Clone()
-		s.records = append(s.records, &c)
+		s.externalCheckpointRecords = append(s.externalCheckpointRecords, &c)
 	}
 
 	return nil
 }
 
-// GetCheckpoint implements balance.Store.GetCheckpoint
-func (s *store) GetCheckpoint(_ context.Context, account string) (*balance.Record, error) {
+// GetExternalCheckpoint implements balance.Store.GetExternalCheckpoint
+func (s *store) GetExternalCheckpoint(_ context.Context, account string) (*balance.ExternalCheckpointRecord, error) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
-	if item := s.findByTokenAccount(account); item != nil {
+	if item := s.findExternalCheckpointByTokenAccount(account); item != nil {
 		cloned := item.Clone()
 		return &cloned, nil
 	}
 	return nil, balance.ErrCheckpointNotFound
 }
 
-func (s *store) find(data *balance.Record) *balance.Record {
-	for _, item := range s.records {
+func (s *store) findExternalCheckpoint(data *balance.ExternalCheckpointRecord) *balance.ExternalCheckpointRecord {
+	for _, item := range s.externalCheckpointRecords {
 		if item.Id == data.Id {
 			return item
 		}
@@ -74,8 +74,8 @@ func (s *store) find(data *balance.Record) *balance.Record {
 	return nil
 }
 
-func (s *store) findByTokenAccount(account string) *balance.Record {
-	for _, item := range s.records {
+func (s *store) findExternalCheckpointByTokenAccount(account string) *balance.ExternalCheckpointRecord {
+	for _, item := range s.externalCheckpointRecords {
 		if account == item.TokenAccount {
 			return item
 		}
@@ -87,6 +87,6 @@ func (s *store) reset() {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
-	s.records = nil
+	s.externalCheckpointRecords = nil
 	s.last = 0
 }

pkg/code/data/balance/postgres/model.go

@@ -12,10 +12,10 @@ import (
 )
 
 const (
-	tableName = "codewallet__core_balancecheckpoint"
+	externalCheckpointTableName = "codewallet__core_balanceexternalcheckpoint"
 )
 
-type model struct {
+type externalCheckpointModel struct {
 	Id sql.NullInt64 `db:"id"`
 
 	TokenAccount   string `db:"token_account"`
@@ -25,21 +25,21 @@ type model struct {
 	LastUpdatedAt time.Time `db:"last_updated_at"`
 }
 
-func toModel(obj *balance.Record) (*model, error) {
+func toExternalCheckpointModel(obj *balance.ExternalCheckpointRecord) (*externalCheckpointModel, error) {
 	if err := obj.Validate(); err != nil {
 		return nil, err
 	}
 
-	return &model{
+	return &externalCheckpointModel{
 		TokenAccount:   obj.TokenAccount,
 		Quarks:         obj.Quarks,
 		SlotCheckpoint: obj.SlotCheckpoint,
 		LastUpdatedAt:  obj.LastUpdatedAt,
 	}, nil
 }
 
-func fromModel(obj *model) *balance.Record {
-	return &balance.Record{
+func fromExternalCheckpoingModel(obj *externalCheckpointModel) *balance.ExternalCheckpointRecord {
+	return &balance.ExternalCheckpointRecord{
 		Id:             uint64(obj.Id.Int64),
 		TokenAccount:   obj.TokenAccount,
 		Quarks:         obj.Quarks,
@@ -48,16 +48,16 @@ func fromModel(obj *model) *balance.Record {
 	}
 }
 
-func (m *model) dbSave(ctx context.Context, db *sqlx.DB) error {
+func (m *externalCheckpointModel) dbSave(ctx context.Context, db *sqlx.DB) error {
 	return pgutil.ExecuteInTx(ctx, db, sql.LevelDefault, func(tx *sqlx.Tx) error {
-		query := `INSERT INTO ` + tableName + `
+		query := `INSERT INTO ` + externalCheckpointTableName + `
 			(token_account, quarks, slot_checkpoint, last_updated_at)
 			VALUES ($1, $2, $3, $4)
 
 			ON CONFLICT (token_account)
 			DO UPDATE
 				SET quarks = $2, slot_checkpoint = $3, last_updated_at = $4
-				WHERE ` + tableName + `.token_account = $1 AND ` + tableName + `.slot_checkpoint < $3
+				WHERE ` + externalCheckpointTableName + `.token_account = $1 AND ` + externalCheckpointTableName + `.slot_checkpoint < $3
 
 			RETURNING
 				id, token_account, quarks, slot_checkpoint, last_updated_at`
@@ -77,12 +77,12 @@ func (m *model) dbSave(ctx context.Context, db *sqlx.DB) error {
 	})
 }
 
-func dbGetCheckpoint(ctx context.Context, db *sqlx.DB, account string) (*model, error) {
-	res := &model{}
+func dbGetExternalCheckpoint(ctx context.Context, db *sqlx.DB, account string) (*externalCheckpointModel, error) {
+	res := &externalCheckpointModel{}
 
 	query := `SELECT
 		id, token_account, quarks, slot_checkpoint, last_updated_at
-		FROM ` + tableName + `
+		FROM ` + externalCheckpointTableName + `
 		WHERE token_account = $1
 		LIMIT 1`
 

pkg/code/data/balance/postgres/store.go

@@ -20,9 +20,9 @@ func New(db *sql.DB) balance.Store {
 	}
 }
 
-// SaveCheckpoint implements balance.Store.SaveCheckpoint
-func (s *store) SaveCheckpoint(ctx context.Context, record *balance.Record) error {
-	model, err := toModel(record)
+// SaveExternalCheckpoint implements balance.Store.SaveExternalCheckpoint
+func (s *store) SaveExternalCheckpoint(ctx context.Context, record *balance.ExternalCheckpointRecord) error {
+	model, err := toExternalCheckpointModel(record)
 	if err != nil {
 		return err
 	}
@@ -31,17 +31,17 @@ func (s *store) SaveCheckpoint(ctx context.Context, record *balance.Record) erro
 		return err
 	}
 
-	res := fromModel(model)
+	res := fromExternalCheckpoingModel(model)
 	res.CopyTo(record)
 
 	return nil
 }
 
-// GetCheckpoint implements balance.Store.GetCheckpoint
-func (s *store) GetCheckpoint(ctx context.Context, account string) (*balance.Record, error) {
-	model, err := dbGetCheckpoint(ctx, s.db, account)
+// GetExternalCheckpoint implements balance.Store.GetExternalCheckpoint
+func (s *store) GetExternalCheckpoint(ctx context.Context, account string) (*balance.ExternalCheckpointRecord, error) {
+	model, err := dbGetExternalCheckpoint(ctx, s.db, account)
 	if err != nil {
 		return nil, err
 	}
-	return fromModel(model), nil
+	return fromExternalCheckpoingModel(model), nil
 }

pkg/code/data/balance/postgres/store_test.go

@@ -24,7 +24,7 @@ var (
 const (
 	// Used for testing ONLY, the table and migrations are external to this repository
 	tableCreate = `
-	CREATE TABLE codewallet__core_balancecheckpoint (
+	CREATE TABLE codewallet__core_balanceexternalcheckpoint (
 		id SERIAL NOT NULL PRIMARY KEY,
 
 		token_account TEXT NOT NULL,
@@ -33,13 +33,13 @@ const (
 
 		last_updated_at TIMESTAMP WITH TIME ZONE,
 
-		CONSTRAINT codewallet__core_balancecheckpoint__uniq__token_account UNIQUE (token_account)
+		CONSTRAINT codewallet__core_balanceexternalcheckpoint__uniq__token_account UNIQUE (token_account)
 	);
 	`
 
 	// Used for testing ONLY, the table and migrations are external to this repository
 	tableDestroy = `
-		DROP TABLE codewallet__core_balancecheckpoint;
+		DROP TABLE codewallet__core_balanceexternalcheckpoint;
 	`
 )
 

pkg/code/data/balance/store.go

@@ -12,11 +12,12 @@ var (
 )
 
 type Store interface {
-	// SaveCheckpoint saves a balance at a checkpoint. ErrStaleCheckpoint is returned
-	// if the checkpoint is outdated
-	SaveCheckpoint(ctx context.Context, record *Record) error
+	// SaveExternalCheckpoint saves an external balance at a checkpoint.
+	// ErrStaleCheckpoint is returned if the checkpoint is outdated
+	SaveExternalCheckpoint(ctx context.Context, record *ExternalCheckpointRecord) error
 
-	// GetCheckpoint gets a balance checkpoint for a given account. ErrCheckpointNotFound
-	// is returend if no DB record exists.
-	GetCheckpoint(ctx context.Context, account string) (*Record, error)
+	// GetExternalCheckpoint gets an exeternal balance checkpoint for a
+	// given account. ErrCheckpointNotFound is returend if no DB record
+	// exists.
+	GetExternalCheckpoint(ctx context.Context, account string) (*ExternalCheckpointRecord, error)
 }

pkg/code/data/balance/tests/tests.go

@@ -13,68 +13,68 @@ import (
 
 func RunTests(t *testing.T, s balance.Store, teardown func()) {
 	for _, tf := range []func(t *testing.T, s balance.Store){
-		testHappyPath,
+		testExternalCheckpointHappyPath,
 	} {
 		tf(t, s)
 		teardown()
 	}
 }
 
-func testHappyPath(t *testing.T, s balance.Store) {
-	t.Run("testHappyPath", func(t *testing.T) {
+func testExternalCheckpointHappyPath(t *testing.T, s balance.Store) {
+	t.Run("testExternalCheckpointHappyPath", func(t *testing.T) {
 		ctx := context.Background()
 
-		_, err := s.GetCheckpoint(ctx, "token_account")
+		_, err := s.GetExternalCheckpoint(ctx, "token_account")
 		assert.Equal(t, balance.ErrCheckpointNotFound, err)
 
 		start := time.Now()
 
-		expected := &balance.Record{
+		expected := &balance.ExternalCheckpointRecord{
 			TokenAccount:   "token_account",
 			Quarks:         0,
 			SlotCheckpoint: 0,
 		}
 		cloned := expected.Clone()
 
-		require.NoError(t, s.SaveCheckpoint(ctx, expected))
+		require.NoError(t, s.SaveExternalCheckpoint(ctx, expected))
 		assert.EqualValues(t, 1, expected.Id)
 		assert.True(t, expected.LastUpdatedAt.After(start))
 
-		actual, err := s.GetCheckpoint(ctx, "token_account")
+		actual, err := s.GetExternalCheckpoint(ctx, "token_account")
 		require.NoError(t, err)
-		assertEquivalentRecords(t, actual, &cloned)
+		assertEquivalentExternalCheckpoingRecords(t, actual, &cloned)
 
 		start = time.Now()
 
 		expected.Quarks = 12345
 		expected.SlotCheckpoint = 10
 		cloned = expected.Clone()
 
-		require.NoError(t, s.SaveCheckpoint(ctx, expected))
+		require.NoError(t, s.SaveExternalCheckpoint(ctx, expected))
 		assert.EqualValues(t, 1, expected.Id)
 		assert.True(t, expected.LastUpdatedAt.After(start))
 
-		actual, err = s.GetCheckpoint(ctx, "token_account")
+		actual, err = s.GetExternalCheckpoint(ctx, "token_account")
 		require.NoError(t, err)
-		assertEquivalentRecords(t, actual, &cloned)
+		assertEquivalentExternalCheckpoingRecords(t, actual, &cloned)
 
 		expected.Quarks = 67890
-		assert.Equal(t, balance.ErrStaleCheckpoint, s.SaveCheckpoint(ctx, expected))
+		assert.Equal(t, balance.ErrStaleCheckpoint, s.SaveExternalCheckpoint(ctx, expected))
 
-		actual, err = s.GetCheckpoint(ctx, "token_account")
+		actual, err = s.GetExternalCheckpoint(ctx, "token_account")
 		require.NoError(t, err)
-		assertEquivalentRecords(t, actual, &cloned)
+		assertEquivalentExternalCheckpoingRecords(t, actual, &cloned)
 
 		expected.SlotCheckpoint -= 1
-		assert.Equal(t, balance.ErrStaleCheckpoint, s.SaveCheckpoint(ctx, expected))
+		assert.Equal(t, balance.ErrStaleCheckpoint, s.SaveExternalCheckpoint(ctx, expected))
 
-		actual, err = s.GetCheckpoint(ctx, "token_account")
+		actual, err = s.GetExternalCheckpoint(ctx, "token_account")
 		require.NoError(t, err)
-		assertEquivalentRecords(t, actual, &cloned)
+		assertEquivalentExternalCheckpoingRecords(t, actual, &cloned)
 	})
 }
 
-func assertEquivalentRecords(t *testing.T, obj1, obj2 *balance.Record) {
+func assertEquivalentExternalCheckpoingRecords(t *testing.T, obj1, obj2 *balance.ExternalCheckpointRecord) {
 	assert.Equal(t, obj1.TokenAccount, obj2.TokenAccount)
 	assert.Equal(t, obj1.Quarks, obj2.Quarks)
 	assert.Equal(t, obj1.SlotCheckpoint, obj2.SlotCheckpoint)