Remove deprecated balance methods

Author: Jeff Yanta

pkg/code/balance/calculator.go

@@ -7,8 +7,6 @@ import (
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 
-	commonpb "github.com/code-payments/code-protobuf-api/generated/go/common/v1"
-
 	"github.com/code-payments/code-server/pkg/code/common"
 	code_data "github.com/code-payments/code-server/pkg/code/data"
 	"github.com/code-payments/code-server/pkg/code/data/balance"
@@ -402,61 +400,6 @@ func FundingFromExternalDepositsBatch(ctx context.Context, data code_data.Provid
 	}
 }
 
-// GetPrivateBalance gets an owner account's total private balance.
-//
-// Note: Assumes all private accounts have the same mint
-func GetPrivateBalance(ctx context.Context, data code_data.Provider, owner *common.Account) (uint64, error) {
-	log := logrus.StandardLogger().WithFields(logrus.Fields{
-		"method": "GetPrivateBalance",
-		"owner":  owner.PublicKey().ToBase58(),
-	})
-
-	tracer := metrics.TraceMethodCall(ctx, metricsPackageName, "GetPrivateBalance")
-	tracer.AddAttribute("owner", owner.PublicKey().ToBase58())
-	defer tracer.End()
-
-	accountRecordsByType, err := common.GetLatestTokenAccountRecordsForOwner(ctx, data, owner)
-	if err != nil {
-		log.WithError(err).Warn("failure getting latest token account records")
-		tracer.OnError(err)
-		return 0, err
-	}
-
-	if len(accountRecordsByType) == 0 {
-		tracer.OnError(ErrNotManagedByCode)
-		return 0, ErrNotManagedByCode
-	}
-
-	var accountRecordsBatch []*common.AccountRecords
-	for _, accountRecords := range accountRecordsByType {
-		switch accountRecords[0].General.AccountType {
-		case commonpb.AccountType_PRIMARY,
-			commonpb.AccountType_LEGACY_PRIMARY_2022,
-			commonpb.AccountType_REMOTE_SEND_GIFT_CARD,
-			commonpb.AccountType_RELATIONSHIP,
-			commonpb.AccountType_SWAP:
-			continue
-		}
-
-		accountRecordsBatch = append(accountRecordsBatch, accountRecords...)
-	}
-
-	balanceByAccount, err := BatchCalculateFromCacheWithAccountRecords(ctx, data, accountRecordsBatch...)
-	if err != nil {
-		log.WithError(err).Warn("failure getting balances")
-		tracer.OnError(err)
-		return 0, err
-	}
-
-	var total uint64
-	for _, batchRecords := range accountRecordsByType {
-		for _, records := range batchRecords {
-			total += balanceByAccount[records.General.TokenAccount]
-		}
-	}
-	return total, nil
-}
-
 func (s Source) String() string {
 	switch s {
 	case UnknownSource:

pkg/code/balance/calculator_test.go

@@ -3,7 +3,6 @@ package balance
 import (
 	"context"
 	"fmt"
-	"math"
 	"testing"
 	"time"
 
@@ -19,7 +18,6 @@ import (
 	"github.com/code-payments/code-server/pkg/code/data/deposit"
 	"github.com/code-payments/code-server/pkg/code/data/intent"
 	"github.com/code-payments/code-server/pkg/code/data/transaction"
-	"github.com/code-payments/code-server/pkg/pointer"
 	timelock_token_v1 "github.com/code-payments/code-server/pkg/solana/timelock/v1"
 	"github.com/code-payments/code-server/pkg/testutil"
 )
@@ -347,66 +345,6 @@ func TestDefaultCalculation_ExternalAccount(t *testing.T) {
 	// Note: not possible with batch method, since we wouldn't have account records
 }
 
-func TestGetAggregatedBalances(t *testing.T) {
-	env := setupBalanceTestEnv(t)
-
-	vmAccount := testutil.NewRandomAccount(t)
-	owner := testutil.NewRandomAccount(t)
-
-	_, err := GetPrivateBalance(env.ctx, env.data, owner)
-	assert.Equal(t, ErrNotManagedByCode, err)
-
-	var expectedTotalBalance, expectedPrivateBalance uint64
-	for i, accountType := range account.AllAccountTypes {
-		if accountType == commonpb.AccountType_REMOTE_SEND_GIFT_CARD || accountType == commonpb.AccountType_SWAP {
-			continue
-		}
-
-		authority := testutil.NewRandomAccount(t)
-		if accountType == commonpb.AccountType_PRIMARY {
-			authority = owner
-		}
-
-		balance := uint64(math.Pow10(i))
-		expectedTotalBalance += balance
-		if accountType != commonpb.AccountType_PRIMARY && accountType != commonpb.AccountType_RELATIONSHIP {
-			expectedPrivateBalance += balance
-		}
-
-		timelockAccounts, err := authority.GetTimelockAccounts(vmAccount, common.CoreMintAccount)
-		require.NoError(t, err)
-
-		timelockRecord := timelockAccounts.ToDBRecord()
-		require.NoError(t, env.data.SaveTimelock(env.ctx, timelockRecord))
-
-		accountInfoRecord := account.Record{
-			OwnerAccount:     owner.PublicKey().ToBase58(),
-			AuthorityAccount: authority.PublicKey().ToBase58(),
-			TokenAccount:     timelockRecord.VaultAddress,
-			MintAccount:      common.CoreMintAccount.PublicKey().ToBase58(),
-			AccountType:      accountType,
-		}
-		if accountType == commonpb.AccountType_RELATIONSHIP {
-			accountInfoRecord.RelationshipTo = pointer.String("example.com")
-		}
-		require.NoError(t, env.data.CreateAccountInfo(env.ctx, &accountInfoRecord))
-
-		actionRecord := action.Record{
-			Intent:      testutil.NewRandomAccount(t).PublicKey().ToBase58(),
-			IntentType:  intent.SendPrivatePayment,
-			ActionType:  action.PrivateTransfer,
-			Source:      testutil.NewRandomAccount(t).PublicKey().ToBase58(),
-			Destination: &accountInfoRecord.TokenAccount,
-			Quantity:    &balance,
-		}
-		require.NoError(t, env.data.PutAllActions(env.ctx, &actionRecord))
-	}
-
-	balance, err := GetPrivateBalance(env.ctx, env.data, owner)
-	require.NoError(t, err)
-	assert.EqualValues(t, expectedPrivateBalance, balance)
-}
-
 type balanceTestEnv struct {
 	ctx  context.Context
 	data code_data.Provider