added validation for all fee operations to have negative value

asserter/block.go

@@ -320,7 +320,20 @@ func (a *Asserter) Operations( // nolint:gocognit
 					)
 				}
 
-				val, _ := new(big.Int).SetString(op.Amount.Value, 10)
+				val, err := types.BigInt(op.Amount.Value)
+				if err != nil {
+					return err
+				}
+
+				// Validate that fee operation amount is negative
+				if val.Sign() != -1 {
+					return fmt.Errorf(
+						"%w: operation index %d",
+						ErrFeeAmountNotNegative,
+						op.OperationIdentifier.Index,
+					)
+				}
+
 				feeTotal.Add(feeTotal, val)
 				feeCount++
 			}

asserter/block_test.go

@@ -293,6 +293,14 @@ func TestOperationsValidations(t *testing.T) {
 			},
 		}
 
+		invalidFeeAmount = &types.Amount{
+			Value: "100",
+			Currency: &types.Currency{
+				Symbol:   "BTC",
+				Decimals: 8,
+			},
+		}
+
 		validAccount = &types.AccountIdentifier{
 			Address: "test",
 		}
@@ -513,6 +521,88 @@ func TestOperationsValidations(t *testing.T) {
 			construction:       false,
 			err:                ErrRelatedOperationInFeeNotAllowed,
 		},
+
+		"fee amount is non-negative": {
+			operations: []*types.Operation{
+				{
+					OperationIdentifier: &types.OperationIdentifier{
+						Index: int64(0),
+					},
+					Type:    "PAYMENT",
+					Status:  types.String("SUCCESS"),
+					Account: validAccount,
+					Amount:  validDepositAmount,
+				},
+				{
+					OperationIdentifier: &types.OperationIdentifier{
+						Index: int64(1),
+					},
+					Type:    "PAYMENT",
+					Status:  types.String("SUCCESS"),
+					Account: validAccount,
+					Amount: &types.Amount{
+						Value: "-2000",
+						Currency: &types.Currency{
+							Symbol:   "BTC",
+							Decimals: 8,
+						},
+					},
+				},
+				{
+					OperationIdentifier: &types.OperationIdentifier{
+						Index: int64(2),
+					},
+					Type:    "FEE",
+					Status:  types.String("SUCCESS"),
+					Account: validAccount,
+					Amount:  invalidFeeAmount,
+				},
+			},
+			validationFilePath: "data/validation_fee_and_payment_unbalanced.json",
+			construction:       false,
+			err:                ErrFeeAmountNotNegative,
+		},
+
+		"fee amount is negative as expected": {
+			operations: []*types.Operation{
+				{
+					OperationIdentifier: &types.OperationIdentifier{
+						Index: int64(0),
+					},
+					Type:    "PAYMENT",
+					Status:  types.String("SUCCESS"),
+					Account: validAccount,
+					Amount:  validDepositAmount,
+				},
+				{
+					OperationIdentifier: &types.OperationIdentifier{
+						Index: int64(1),
+					},
+					Type:    "PAYMENT",
+					Status:  types.String("SUCCESS"),
+					Account: validAccount,
+					Amount: &types.Amount{
+						Value: "-2000",
+						Currency: &types.Currency{
+							Symbol:   "BTC",
+							Decimals: 8,
+						},
+					},
+				},
+				{
+					OperationIdentifier: &types.OperationIdentifier{
+						Index: int64(2),
+					},
+					Type:    "FEE",
+					Status:  types.String("SUCCESS"),
+					Account: validAccount,
+					Amount:  validFeeAmount,
+				},
+			},
+			validationFilePath: "data/validation_fee_and_payment_unbalanced.json",
+			construction:       false,
+			err:                nil,
+		},
 	}
 
 	for name, test := range tests {

asserter/errors.go

@@ -103,6 +103,7 @@ var (
 	ErrFeeAmountNotBalancing       = errors.New("fee amount doesn't balance")
 	ErrPaymentCountMismatch        = errors.New("payment count doesn't match")
 	ErrFeeCountMismatch            = errors.New("fee count doesn't match")
+	ErrFeeAmountNotNegative        = errors.New("fee amount is not negative")
 
 	BlockErrs = []error{
 		ErrAmountValueMissing,
@@ -142,6 +143,7 @@ var (
 		ErrDuplicateRelatedTransaction,
 		ErrPaymentAmountNotBalancing,
 		ErrFeeAmountNotBalancing,
+		ErrFeeAmountNotNegative,
 	}
 )
 

storage/modules/coin_storage.go

@@ -501,21 +501,28 @@ func (c *CoinStorage) GetLargestCoin(
 // This is used when importing prefunded addresses.
 func (c *CoinStorage) SetCoinsImported(
 	ctx context.Context,
-	accountBalances []*utils.AccountBalance,
+	accts []*types.AccountIdentifier,
+	acctCoinsResp []*utils.AccountCoinsResponse,
 ) error {
-	var accountCoins []*types.AccountCoin
-	for _, accountBalance := range accountBalances {
-		for _, coin := range accountBalance.Coins {
-			accountCoin := &types.AccountCoin{
-				Account: accountBalance.Account,
+	// Request array length should always equal response array length.
+	// But we still check it for sure.
+	if len(accts) != len(acctCoinsResp) {
+		return errors.ErrCoinImportFailed
+	}
+
+	var acctCoins []*types.AccountCoin
+	for i, resp := range acctCoinsResp {
+		for _, coin := range resp.Coins {
+			acctCoin := &types.AccountCoin{
+				Account: accts[i],
 				Coin:    coin,
 			}
 
-			accountCoins = append(accountCoins, accountCoin)
+			acctCoins = append(acctCoins, acctCoin)
 		}
 	}
 
-	if err := c.AddCoins(ctx, accountCoins); err != nil {
+	if err := c.AddCoins(ctx, acctCoins); err != nil {
 		return fmt.Errorf("%w: %v", errors.ErrCoinImportFailed, err)
 	}
 

storage/modules/coin_storage_test.go

@@ -386,6 +386,15 @@ var (
 			},
 		},
 	}
+
+	acctCoins = []*utils.AccountCoinsResponse{
+		{
+			Coins: accBalance1.Coins,
+		},
+		{
+			Coins: accBalance2.Coins,
+		},
+	}
 )
 
 func TestCoinStorage(t *testing.T) {
@@ -961,9 +970,8 @@ func TestCoinStorage(t *testing.T) {
 	})
 
 	t.Run("SetCoinsImported", func(t *testing.T) {
-		accBalances := []*utils.AccountBalance{accBalance1, accBalance2}
-
-		err := c.SetCoinsImported(ctx, accBalances)
+		accts := []*types.AccountIdentifier{accBalance1.Account, accBalance2.Account}
+		err := c.SetCoinsImported(ctx, accts, acctCoins)
 		assert.NoError(t, err)
 
 		mockHelper.On(

utils/utils.go

@@ -192,6 +192,14 @@ type FetcherHelper interface {
 		block *types.PartialBlockIdentifier,
 		currencies []*types.Currency,
 	) (*types.BlockIdentifier, []*types.Amount, map[string]interface{}, *fetcher.Error)
+
+	AccountCoinsRetry(
+		ctx context.Context,
+		network *types.NetworkIdentifier,
+		acct *types.AccountIdentifier,
+		includeMempool bool,
+		currencies []*types.Currency,
+	) (*types.BlockIdentifier, []*types.Coin, map[string]interface{}, *fetcher.Error)
 }
 
 type BlockStorageHelper interface {
@@ -491,6 +499,57 @@ func GetAccountBalances(
 	return accountBalances, nil
 }
 
+// -------------------------------------------------------------------------------
+// ----------------- Helper struct for fetching account coins --------------------
+// -------------------------------------------------------------------------------
+
+// AccountCoinsRequest defines the required information to get an account's coins.
+type AccountCoinsRequest struct {
+	Account        *types.AccountIdentifier
+	Network        *types.NetworkIdentifier
+	Currencies     []*types.Currency
+	IncludeMempool bool
+}
+
+// AccountCoins defines an account's coins info at tip.
+type AccountCoinsResponse struct {
+	Coins []*types.Coin
+}
+
+// GetAccountCoins calls /account/coins endpoint and returns an array of coins at tip.
+func GetAccountCoins(
+	ctx context.Context,
+	fetcher FetcherHelper,
+	acctCoinsReqs []*AccountCoinsRequest,
+) ([]*AccountCoinsResponse, error) {
+	var acctCoins []*AccountCoinsResponse
+	for _, req := range acctCoinsReqs {
+		_, coins, _, err := fetcher.AccountCoinsRetry(
+			ctx,
+			req.Network,
+			req.Account,
+			req.IncludeMempool,
+			req.Currencies,
+		)
+
+		if err != nil {
+			return nil, err.Err
+		}
+
+		resp := &AccountCoinsResponse{
+			Coins: coins,
+		}
+
+		acctCoins = append(acctCoins, resp)
+	}
+
+	return acctCoins, nil
+}
+
+// -------------------------------------------------------------------------------
+// ------------------- End of helper struct for account coins --------------------
+// -------------------------------------------------------------------------------
+
 // AtTip returns a boolean indicating if a block timestamp
 // is within tipDelay from the current time.
 func AtTip(