Merge pull request #16 from rarimo/fix/residual_balance

changed uint64 to big.Int

Author: 2pa-arch

docs/spec/components/schemas/VotingPredictAttributes.yaml

@@ -1,7 +1,5 @@
 type: object
 x-go-is-request: true
-required:
-  - voting_id
 properties:
   amount:
     type: string
@@ -14,7 +12,7 @@ properties:
     example: "10000"
     description: The number of transactions that need to be covered
   voting_id:
-    type: string
-    pattern: "^[0-9]+$"
+    type: integer
+    format: int64
     example: "12"
     description: ID of the voting to which the vote

docs/spec/paths/integrations@proof-verification-relayer@v2@predict.yaml

@@ -1,7 +1,8 @@
 post:
   tags:
     - Voting Info
-  summary: Voting Info
+  summary: Prediction of voting parameters (number of transactions or required amount)
+  description: "This endpoint allows predicting voting parameters. The user can provide a voting ID and select one of the prediction types: forecasting the required amount for a given number of transactions or estimating the possible number of transactions with a specified amount"
   operationId: votingPredict
   requestBody:
     content:

internal/checker/checker.go

@@ -65,15 +65,13 @@ func (ch *checker) check(ctx context.Context) error {
 
 	startBlock, err := ch.getStartBlockNumber()
 	if err != nil {
-		ch.log.Errorf("Failed get start block: %v", err)
-		return err
+		return errors.Wrap(err, "Failed get start block")
 	}
 
 	ch.readOldEvents(ctx, startBlock)
 	startBlock, err = ch.getStartBlockNumber()
 	if err != nil {
-		ch.log.Errorf("Failed get start block: %v", err)
-		return err
+		return errors.Wrap(err, "Failed get start block")
 	}
 	go ch.readNewEvents(ctx, ch.VotingV2Config.WithSub)
 
@@ -138,11 +136,11 @@ func (ch *checker) readNewEventsWithoutSub(ctx context.Context) {
 	}
 }
 
-func (ch *checker) readNewEventsSub(ctx context.Context, eventName string) error {
+func (ch *checker) readNewEventsSub(ctx context.Context, eventName string) {
 	parsedABI, err := abi.JSON(strings.NewReader(contracts.ProposalsStateABI))
 	if err != nil {
 		ch.log.Errorf("Failed to parse contract ABI: %v", err)
-		return err
+		return
 	}
 
 	query := ethereum.FilterQuery{
@@ -153,14 +151,14 @@ func (ch *checker) readNewEventsSub(ctx context.Context, eventName string) error
 	sub, err := ch.VotingV2Config.RPC.SubscribeFilterLogs(context.Background(), query, logs)
 	if err != nil {
 		ch.log.WithFields(logan.F{"Error": err, "eventName": eventName}).Error("failed subscribe event")
-		return err
+		return
 	}
 
 	for {
 		select {
 		case <-ctx.Done():
 			ch.log.Info("unsubscribe from events")
-			return nil
+			return
 		case err := <-sub.Err():
 			ch.log.WithFields(logan.F{
 				"Error":     err,
@@ -170,7 +168,12 @@ func (ch *checker) readNewEventsSub(ctx context.Context, eventName string) error
 		case vLog := <-logs:
 			err := ch.processLog(vLog, eventName)
 			if err != nil {
-				ch.log.WithFields(logan.F{"Error": err, "log_index": vLog.Index, "hash_tx": vLog.TxHash.Hex()}).Warn("failed process log")
+				ch.log.WithFields(logan.F{
+					"Error":      err,
+					"log_index":  vLog.Index,
+					"hash_tx":    vLog.TxHash.Hex(),
+					"event_name": eventName}).
+					Warn("failed process log")
 			}
 		}
 	}
@@ -186,12 +189,13 @@ func (ch *checker) checkFilter(block, toBlock uint64, contract *contracts.Propos
 
 	filterLogsF, err := contract.FilterProposalFunded(&query, nil)
 	if err != nil {
-		ch.log.WithField("Error", err).Info("failed to filter logs")
-		return errors.Wrap(err, "failed to filter logs", logan.F{"address": contractAddress, "start_block": block})
+		return errors.Wrap(err, "failed to filter logs", logan.F{
+			"address":     contractAddress,
+			"start_block": block,
+		})
 	}
 	filterLogs, err := contract.FilterProposalCreated(&query, nil)
 	if err != nil {
-		ch.log.WithField("Error", err).Info("failed to filter logs")
 		return errors.Wrap(err, "failed to filter logs", logan.F{"address": contractAddress, "start_block": block})
 	}
 
@@ -210,7 +214,7 @@ func (ch *checker) filterEvets(event contracts.ProposalEvent, block uint64, toBl
 				"Error":     err,
 				"log_index": event.LogIndex(),
 				"hash_tx":   event.TxHash().Hex(),
-				"value":     event.FundAmountU64(),
+				"value":     event.FundAmount().String(),
 				"eventName": eventName,
 			}).
 				Warn("failed process log")
@@ -227,25 +231,23 @@ func (ch *checker) filterEvets(event contracts.ProposalEvent, block uint64, toBl
 	}).Debug("found events")
 }
 
-func (ch *checker) readOldEvents(ctx context.Context, block uint64) error {
+func (ch *checker) readOldEvents(ctx context.Context, block uint64) {
 	client := ch.VotingV2Config.RPC
 	contractAddress := ch.VotingV2Config.Address
 	ch.log.WithField("from", block).Info("start reading old events")
 
 	contract, err := contracts.NewProposalsStateFilterer(contractAddress, client)
 	if err != nil {
 		ch.log.Errorf("failed cretate proposal state filter: %v", err)
-		return err
+		return
 	}
 	header, err := client.HeaderByNumber(ctx, nil)
 	if err != nil {
 		ch.log.WithField("Error", err).Info("failed to get latest block header")
-		return errors.Wrap(err, "failed to get latest block header")
+		return
 	}
 	toBlock := ch.readFromToBlock(ctx, block, header.Number.Uint64(), contract)
 	ch.log.WithField("to", toBlock).Info("finish reading old events")
-
-	return nil
 }
 
 func (ch *checker) readFromToBlock(ctx context.Context, fromBlock uint64, toBlock uint64, contract *contracts.ProposalsStateFilterer) uint64 {

internal/checker/process_events.go

@@ -2,6 +2,7 @@ package checker
 
 import (
 	"database/sql"
+	"math/big"
 	"strings"
 
 	"github.com/ethereum/go-ethereum/accounts/abi"
@@ -18,20 +19,16 @@ func (ch *checker) processEvents(event contracts.ProposalEvent) error {
 	processedEvent.LogIndex = event.LogIndex()
 	processedEvent.TransactionHash = event.TxHash().Bytes()
 	if err := ch.insertProcessedEventLog(processedEvent); err != nil {
-		ch.log.WithField("Error", err).Debug("failed insert processed event")
-		return err
+		return errors.Wrap(err, "failed insert processed event")
 	}
 	votingInfo, err := ch.checkVoteAndGetBalance(event.ProposalID())
 	if err != nil {
-		ch.log.WithField("Error", err).Errorf("failed insert processed event")
-
-		return err
+		return errors.Wrap(err, "failed get voting info")
 	}
-	votingInfo.Balance += event.FundAmountU64()
+	votingInfo.Balance = new(big.Int).Add(votingInfo.Balance, event.FundAmount())
 
 	if err := ch.checkerQ.UpdateVotingInfo(votingInfo); err != nil {
-		ch.log.Errorf("Failed Update voting balance: %v", err)
-		return err
+		return errors.Wrap(err, "failed Update voting balance")
 	}
 
 	return nil
@@ -47,8 +44,7 @@ func (ch *checker) processLog(vLog types.Log, eventName string) error {
 
 	err := ch.insertProcessedEventLog(processedEvent)
 	if err != nil {
-		ch.log.WithFields(logan.F{"Error": err, "eventName": eventName}).Error("failed insert processed event")
-		return err
+		return errors.Wrap(err, "failed insert processed event")
 	}
 
 	votingId, value, err := ch.getTransferEvent(eventName, vLog)
@@ -58,52 +54,48 @@ func (ch *checker) processLog(vLog types.Log, eventName string) error {
 
 	votingInfo, err := ch.checkVoteAndGetBalance(votingId)
 	if err != nil {
-		ch.log.WithFields(logan.F{"Error": err, "eventName": eventName, "Voting ID": votingId}).Error("failed get voting info")
-		return err
+		return errors.Wrap(err, "failed get voting info", logan.F{"Voting ID": votingId})
 	}
-	votingInfo.Balance = votingInfo.Balance + value
+	votingInfo.Balance = new(big.Int).Add(votingInfo.Balance, value)
 
 	err = ch.checkerQ.UpdateVotingInfo(votingInfo)
 	if err != nil {
-		ch.log.WithFields(logan.F{"Error": err, "eventName": eventName, "Voting ID": votingId}).Error("Failed Update voting balance")
-		return err
+		return errors.Wrap(err, "failed update voting balance", logan.F{"Voting ID": votingId})
 	}
 	return nil
 }
 
-func (ch *checker) getTransferEvent(eventName string, vLog types.Log) (votingId int64, value uint64, err error) {
+func (ch *checker) getTransferEvent(eventName string, vLog types.Log) (votingId int64, value *big.Int, err error) {
 	parsedABI, err := abi.JSON(strings.NewReader(contracts.ProposalsStateABI))
 	if err != nil {
 		ch.log.Errorf("Failed to parse contract ABI: %v", err)
-		return 0, 0, err
+		return 0, nil, err
 	}
 
 	if eventName == "ProposalCreated" {
 		var transferEvent contracts.ProposalsStateProposalCreated
 		err = parsedABI.UnpackIntoInterface(&transferEvent, eventName, vLog.Data)
 		if err != nil {
 			ch.log.Errorf("Failed to unpack log data: %v", err)
-			return 0, 0, err
+			return 0, nil, err
 		}
-		return transferEvent.ProposalId.Int64(), transferEvent.FundAmount.Uint64(), nil
+		return transferEvent.ProposalId.Int64(), transferEvent.FundAmount, nil
 	}
 
 	var transferEvent contracts.ProposalsStateProposalFunded
 	err = parsedABI.UnpackIntoInterface(&transferEvent, eventName, vLog.Data)
 	if err != nil {
-		ch.log.Errorf("Failed to unpack log data: %v", err)
-		return 0, 0, err
+		return 0, nil, errors.Wrap(err, "failed to unpack log data")
 	}
-	return transferEvent.ProposalId.Int64(), transferEvent.FundAmount.Uint64(), nil
+	return transferEvent.ProposalId.Int64(), transferEvent.FundAmount, nil
 }
 
 func (ch *checker) insertProcessedEventLog(processedEvent data.ProcessedEvent) error {
 	isExist, err := ch.checkerQ.CheckProcessedEventExist(processedEvent)
 	if isExist {
-		ch.log.WithField("event_index_log", processedEvent.LogIndex).Debug("Duplicate event in db")
 		return errors.New("Duplicate event in db")
 	}
-	if err != nil && err != sql.ErrNoRows {
+	if err != nil {
 		return err
 	}
 	err = ch.checkerQ.InsertProcessedEvent(processedEvent)
@@ -113,36 +105,36 @@ func (ch *checker) insertProcessedEventLog(processedEvent data.ProcessedEvent) e
 	return nil
 }
 
-func (ch *checker) checkVoteAndGetBalance(votingId int64) (data.VotingInfo, error) {
+func (ch *checker) checkVoteAndGetBalance(votingId int64) (*data.VotingInfo, error) {
 	votingInfo, err := ch.checkerQ.GetVotingInfo(votingId)
-	if err == sql.ErrNoRows {
-		newVote := &data.VotingInfo{
-			VotingId: votingId,
-			Balance:  0,
-			GasLimit: ch.VotingV2Config.GasLimit,
-		}
+	if err != nil {
+		return nil, err
+	}
+	if votingInfo != nil {
+		return votingInfo, nil
+	}
 
-		err := ch.checkerQ.InsertVotingInfo(*newVote)
-		if err != nil {
-			ch.log.Errorf("Failed insert new voting info: %v", err)
-			return *newVote, err
-		}
-		return *newVote, nil
-	} else if err != nil {
-		ch.log.Errorf("Error get voting: %v", err)
-		return data.VotingInfo{}, err
+	votingInfo = &data.VotingInfo{
+		VotingId: votingId,
+		Balance:  big.NewInt(0),
+		GasLimit: ch.VotingV2Config.GasLimit,
+	}
+
+	err = ch.checkerQ.InsertVotingInfo(votingInfo)
+	if err != nil {
+		return votingInfo, errors.Wrap(err, "failed insert new voting info")
 	}
-	return votingInfo, err
+
+	return votingInfo, nil
 }
 
 func (ch *checker) getStartBlockNumber() (uint64, error) {
 	block, err := ch.checkerQ.GetLastBlock()
-	if err == sql.ErrNoRows {
+	if err != nil {
+		if err != sql.ErrNoRows {
+			return 0, errors.Wrap(err, "failed get block from db")
+		}
 		block = ch.VotingV2Config.Block
-	} else if err != nil {
-		ch.log.Errorf("Failed get block from db: %v", err)
-		return ch.VotingV2Config.Block, err
 	}
-
 	return block, nil
 }