The best version ever

Author: tjayrush

src/apps/chifra/pkg/ledger1/get_statements.go

@@ -19,8 +19,8 @@ func (r *Reconciler1) GetStatements1(pos *types.AppPosition, trans *types.Transa
 	if ledger10.AssetOfInterest(r.opts.AssetFilters, base.FAKE_ETH_ADDRESS) {
 		var err error
 		reconciled := false
-		stmt := r.getStatementFromTransaction(trans)
 		if !r.opts.UseTraces {
+			stmt := r.getStatementFromTransaction(trans)
 			if reconciled, err = r.trialBalance(pos, trans, stmt); err != nil {
 				return nil, err
 			} else {
@@ -31,14 +31,15 @@ func (r *Reconciler1) GetStatements1(pos *types.AppPosition, trans *types.Transa
 		}
 
 		if r.opts.UseTraces || !reconciled {
-			results = make([]types.Statement, 0, 20) /* reset this */
-			if stmt, err := r.getStatementFromTraces(pos, trans, stmt); err != nil {
+			if stmt, err := r.getStatementFromTraces(trans); err != nil {
 				logger.Warn(colors.Yellow+"Statement at ", fmt.Sprintf("%d.%d", trans.BlockNumber, trans.TransactionIndex), " does not reconcile."+colors.Off)
 			} else {
 				if _, err = r.trialBalance(pos, trans, stmt); err != nil {
 					return nil, err
 				} else {
-					results = append(results, *stmt)
+					if stmt.IsMaterial() {
+						results = append(results, *stmt)
+					}
 				}
 			}
 		}
@@ -49,21 +50,24 @@ func (r *Reconciler1) GetStatements1(pos *types.AppPosition, trans *types.Transa
 			return nil, err
 		} else {
 			receiptStatements := make([]types.Statement, 0, len(statements))
-			for _, s := range statements {
-				reconciled, _ := r.trialBalance(pos, trans, &s)
-				if reconciled {
-					id := fmt.Sprintf(" %d.%d.%d", s.BlockNumber, s.TransactionIndex, s.LogIndex)
-					logger.Progress(true, colors.Green+"Transaction", id, "reconciled       "+colors.Off)
+			for _, stmt := range statements {
+				if reconciled, err := r.trialBalance(pos, trans, &stmt); err != nil {
+					// TODO: Silent fail?
+					continue
 				} else {
-					if os.Getenv("TEST_MODE") != "true" {
-						id := fmt.Sprintf(" %d.%d.%d", s.BlockNumber, s.TransactionIndex, s.LogIndex)
-						logger.Warn("Log statement at ", id, " does not reconcile.")
+					if reconciled {
+						id := fmt.Sprintf(" %d.%d.%d", stmt.BlockNumber, stmt.TransactionIndex, stmt.LogIndex)
+						logger.Progress(true, colors.Green+"Transaction", id, "reconciled       "+colors.Off)
+					} else {
+						if os.Getenv("TEST_MODE") != "true" {
+							id := fmt.Sprintf(" %d.%d.%d", stmt.BlockNumber, stmt.TransactionIndex, stmt.LogIndex)
+							logger.Warn("Log statement at ", id, " does not reconcile.")
+						}
+					}
+					// order matters
+					if stmt.IsMaterial() {
+						receiptStatements = append(receiptStatements, stmt)
 					}
-				}
-
-				// order matters
-				if s.IsMaterial() {
-					receiptStatements = append(receiptStatements, s)
 				}
 			}
 			results = append(results, receiptStatements...)
@@ -126,40 +130,19 @@ func (r *Reconciler1) getStatementFromTransaction(trans *types.Transaction) *typ
 	return stmt
 }
 
-func (r *Reconciler1) getStatementFromTraces(pos *types.AppPosition, trans *types.Transaction, s *types.Statement) (*types.Statement, error) {
-
-	stmt := *s
-	// clear all the internal accounting values. Keeps AmountIn, AmountOut and GasOut because
-	// those are at the top level (both the transaction itself and trace '0' have them). We
-	// skip trace '0' because it's the same as the transaction.
-	// stmt.AmountIn.SetUint64(0)
-	stmt.InternalIn.SetUint64(0)
-	stmt.MinerBaseRewardIn.SetUint64(0)
-	stmt.MinerNephewRewardIn.SetUint64(0)
-	stmt.MinerTxFeeIn.SetUint64(0)
-	stmt.MinerUncleRewardIn.SetUint64(0)
-	stmt.CorrectingIn.SetUint64(0)
-	stmt.PrefundIn.SetUint64(0)
-	stmt.SelfDestructIn.SetUint64(0)
-
-	// stmt.AmountOut.SetUint64(0)
-	// stmt.GasOut.SetUint64(0)
-	stmt.InternalOut.SetUint64(0)
-	stmt.CorrectingOut.SetUint64(0)
-	stmt.SelfDestructOut.SetUint64(0)
-
+func (r *Reconciler1) getStatementFromTraces(trans *types.Transaction) (*types.Statement, error) {
 	if traces, err := r.opts.Connection.GetTracesByTransactionHash(trans.Hash.Hex(), trans); err != nil {
 		return nil, err
 
 	} else {
-		// These values accumulate...so we use += instead of =
+		stmt := r.getStatementFromTransaction(trans)
 		for i, trace := range traces {
 			if i == 0 {
 				// the first trace is identical to the transaction itself, so we can skip it
 				continue
 			}
 
-			if trace.Action.CallType == "delegatecall" && trace.Action.To != s.AccountedFor {
+			if trace.Action.CallType == "delegatecall" && trace.Action.To != stmt.AccountedFor {
 				// delegate calls are not included in the transaction's gas cost, so we skip them
 				continue
 			}
@@ -169,7 +152,7 @@ func (r *Reconciler1) getStatementFromTraces(pos *types.AppPosition, trans *type
 			}
 
 			// Do not collapse, more than one of these can be true at the same time
-			if trace.Action.From == s.AccountedFor {
+			if trace.Action.From == stmt.AccountedFor {
 				stmt.InternalOut = plusEq(&stmt.InternalOut, &trace.Action.Value)
 				stmt.Sender = trace.Action.From
 				if trace.Action.To.IsZero() {
@@ -181,13 +164,13 @@ func (r *Reconciler1) getStatementFromTraces(pos *types.AppPosition, trans *type
 				}
 			}
 
-			if trace.Action.To == s.AccountedFor {
+			if trace.Action.To == stmt.AccountedFor {
 				stmt.InternalIn = plusEq(&stmt.InternalIn, &trace.Action.Value)
 				stmt.Sender = trace.Action.From
 				stmt.Recipient = trace.Action.To
 			}
 
-			if trace.Action.SelfDestructed == s.AccountedFor {
+			if trace.Action.SelfDestructed == stmt.AccountedFor {
 				stmt.SelfDestructOut = plusEq(&stmt.SelfDestructOut, &trace.Action.Balance)
 				stmt.Sender = trace.Action.SelfDestructed
 				if stmt.Sender.IsZero() {
@@ -196,7 +179,7 @@ func (r *Reconciler1) getStatementFromTraces(pos *types.AppPosition, trans *type
 				stmt.Recipient = trace.Action.RefundAddress
 			}
 
-			if trace.Action.RefundAddress == s.AccountedFor {
+			if trace.Action.RefundAddress == stmt.AccountedFor {
 				stmt.SelfDestructIn = plusEq(&stmt.SelfDestructIn, &trace.Action.Balance)
 				stmt.Sender = trace.Action.SelfDestructed
 				if stmt.Sender.IsZero() {
@@ -205,90 +188,98 @@ func (r *Reconciler1) getStatementFromTraces(pos *types.AppPosition, trans *type
 				stmt.Recipient = trace.Action.RefundAddress
 			}
 
-			if trace.Action.Address == s.AccountedFor && !trace.Action.RefundAddress.IsZero() {
+			if trace.Action.Address == stmt.AccountedFor && !trace.Action.RefundAddress.IsZero() {
 				stmt.SelfDestructOut = plusEq(&stmt.SelfDestructOut, &trace.Action.Balance)
 				// self destructed send
 				stmt.Sender = trace.Action.Address
 				stmt.Recipient = trace.Action.RefundAddress
 			}
 
 			if trace.Result != nil {
-				if trace.Result.Address == s.AccountedFor {
+				if trace.Result.Address == stmt.AccountedFor {
 					stmt.InternalIn = plusEq(&stmt.InternalIn, &trace.Action.Value)
 					stmt.Sender = trace.Action.From
 					stmt.Recipient = trace.Result.Address
 				}
 			}
 		}
+		return stmt, nil
 	}
-
-	return &stmt, nil
 }
 
 func (r *Reconciler1) getStatementsFromLogs(logs []types.Log) ([]types.Statement, error) {
-	receiptStatements := make([]types.Statement, 0, 20)
+	statements := make([]types.Statement, 0, 20)
 	for _, log := range logs {
-		if log.Topics[0] != topics.TransferTopic {
+		pass1 := log.Topics[0] == topics.TransferTopic
+		if !pass1 {
 			continue
 		}
-		addrArray := []base.Address{r.opts.AccountFor}
-		if r.opts.AppFilters.ApplyLogFilter(&log, addrArray) && ledger10.AssetOfInterest(r.opts.AssetFilters, log.Address) {
-			normalized, err := normalize.NormalizeKnownLogs(&log)
-			if err != nil {
-				continue
-			} else if normalized.IsNFT() {
+
+		pass2 := r.opts.AppFilters.ApplyLogFilter(&log, []base.Address{r.opts.AccountFor})
+		if !pass2 {
+			continue
+		}
+
+		pass3 := ledger10.AssetOfInterest(r.opts.AssetFilters, log.Address)
+		if !pass3 {
+			continue
+		}
+
+		normalized, err := normalize.NormalizeKnownLogs(&log)
+		if err != nil {
+			// TODO: silent fail?
+			continue
+
+		} else if normalized.IsNFT() {
+			continue
+
+		} else {
+			sender := base.HexToAddress(normalized.Topics[1].Hex())
+			recipient := base.HexToAddress(normalized.Topics[2].Hex())
+			isSender, isRecipient := r.opts.AccountFor == sender, r.opts.AccountFor == recipient
+			if !isSender && !isRecipient {
 				continue
-			} else {
-				sender := base.HexToAddress(normalized.Topics[1].Hex())
-				recipient := base.HexToAddress(normalized.Topics[2].Hex())
-				isSender, isRecipient := r.opts.AccountFor == sender, r.opts.AccountFor == recipient
-				if !isSender && !isRecipient {
-					continue
-				}
+			}
 
-				sym := normalized.Address.DefaultSymbol()
-				decimals := base.Value(18)
-				name := r.names[normalized.Address]
-				if name.Address == normalized.Address {
-					if name.Symbol != "" {
-						sym = name.Symbol
-					}
-					if name.Decimals != 0 {
-						decimals = base.Value(name.Decimals)
-					}
-				}
+			var amountIn, amountOut base.Wei
+			amount, _ := new(base.Wei).SetString(strings.ReplaceAll(normalized.Data, "0x", ""), 16)
+			if amount == nil {
+				amount = base.ZeroWei
+			}
+			if r.opts.AccountFor == sender {
+				amountOut = *amount
+			}
+			if r.opts.AccountFor == recipient {
+				amountIn = *amount
+			}
+			stmt := &types.Statement{
+				AccountedFor:     r.opts.AccountFor,
+				Sender:           sender,
+				Recipient:        recipient,
+				BlockNumber:      normalized.BlockNumber,
+				TransactionIndex: normalized.TransactionIndex,
+				LogIndex:         normalized.LogIndex,
+				TransactionHash:  normalized.TransactionHash,
+				Timestamp:        normalized.Timestamp,
+				Asset:            normalized.Address,
+				PriceSource:      "not-priced",
+				AmountIn:         amountIn,
+				AmountOut:        amountOut,
+			}
 
-				var amountIn, amountOut base.Wei
-				amount, _ := new(base.Wei).SetString(strings.ReplaceAll(normalized.Data, "0x", ""), 16)
-				if amount == nil {
-					amount = base.NewWei(0)
-				}
-				if r.opts.AccountFor == sender {
-					amountOut = *amount
-				}
-				if r.opts.AccountFor == recipient {
-					amountIn = *amount
+			name := r.names[stmt.Asset]
+			stmt.Symbol = stmt.Asset.DefaultSymbol()
+			stmt.Decimals = base.Value(18)
+			if name.Address == stmt.Asset {
+				if name.Symbol != "" {
+					stmt.Symbol = name.Symbol
 				}
-				s := types.Statement{
-					AccountedFor:     r.opts.AccountFor,
-					Sender:           sender,
-					Recipient:        recipient,
-					BlockNumber:      normalized.BlockNumber,
-					TransactionIndex: normalized.TransactionIndex,
-					LogIndex:         normalized.LogIndex,
-					TransactionHash:  normalized.TransactionHash,
-					Timestamp:        normalized.Timestamp,
-					Asset:            normalized.Address,
-					Symbol:           sym,
-					Decimals:         decimals,
-					SpotPrice:        0.0,
-					PriceSource:      "not-priced",
-					AmountIn:         amountIn,
-					AmountOut:        amountOut,
+				if name.Decimals != 0 {
+					stmt.Decimals = base.Value(name.Decimals)
 				}
-				receiptStatements = append(receiptStatements, s)
 			}
+			statements = append(statements, *stmt)
 		}
 	}
-	return receiptStatements, nil
+	return statements, nil
 }