Include operation information in the ingest.Change struct

ingest/change.go

@@ -16,10 +16,35 @@ import (
 // If an entry is created: Pre is nil and Post is not nil.
 // If an entry is updated: Pre is not nil and Post is not nil.
 // If an entry is removed: Pre is not nil and Post is nil.
+// If this change is caused by a operation in a transaction, include the operation information. Wont work when changes are compacted
 type Change struct {
-	Type xdr.LedgerEntryType
-	Pre  *xdr.LedgerEntry
-	Post *xdr.LedgerEntry
+	Type            xdr.LedgerEntryType
+	Pre             *xdr.LedgerEntry
+	Post            *xdr.LedgerEntry
+	reason          LedgerEntryChangeReason
+	TransactionData *TransactionEnvelopeAndResult
+	operationInfo   *OperationInfo
+}
+
+type LedgerEntryChangeReason uint16
+
+const (
+	Unknown LedgerEntryChangeReason = iota
+	Operation
+	Transaction
+	FeeChange
+	ProtocolUpgrade
+	Eviction
+)
+
+type TransactionEnvelopeAndResult struct {
+	Envelope *xdr.TransactionEnvelope
+	Result   *xdr.TransactionResultPair
+}
+
+type OperationInfo struct {
+	operationIdx uint32
+	operation    *xdr.Operation
 }
 
 // String returns a best effort string representation of the change.

ingest/ledger_change_reader.go

@@ -185,9 +185,10 @@ func (r *LedgerChangeReader) Read() (Change, error) {
 			entry := entries[i]
 			// when a ledger entry is evicted it is removed from the ledger
 			changes[i] = Change{
-				Type: entry.Data.Type,
-				Pre:  &entry,
-				Post: nil,
+				Type:   entry.Data.Type,
+				Pre:    &entry,
+				Post:   nil,
+				reason: Eviction,
 			}
 		}
 		sortChanges(changes)
@@ -200,6 +201,9 @@ func (r *LedgerChangeReader) Read() (Change, error) {
 			changes := GetChangesFromLedgerEntryChanges(
 				r.LedgerTransactionReader.lcm.UpgradesProcessing()[r.upgradeIndex].Changes,
 			)
+			for _, change := range changes {
+				change.reason = ProtocolUpgrade // Is there any other information that we can add here?
+			}
 			r.pending = append(r.pending, changes...)
 			r.upgradeIndex++
 			return r.Read()

ingest/ledger_transaction.go

@@ -26,13 +26,30 @@ func (t *LedgerTransaction) txInternalError() bool {
 // GetFeeChanges returns a developer friendly representation of LedgerEntryChanges
 // connected to fees.
 func (t *LedgerTransaction) GetFeeChanges() []Change {
-	return GetChangesFromLedgerEntryChanges(t.FeeChanges)
+	changes := GetChangesFromLedgerEntryChanges(t.FeeChanges)
+	txData := &TransactionEnvelopeAndResult{Envelope: &t.Envelope, Result: &t.Result}
+	for _, change := range changes {
+		change.reason = FeeChange
+		change.TransactionData = txData
+	}
+	return changes
 }
 
 // GetChanges returns a developer friendly representation of LedgerEntryChanges.
 // It contains transaction changes and operation changes in that order. If the
 // transaction failed with TxInternalError, operations and txChangesAfter are
 // omitted. It doesn't support legacy TransactionMeta.V=0.
+
+func (t *LedgerTransaction) getTransactionChanges(ledgerEntryChanges xdr.LedgerEntryChanges) []Change {
+	changes := GetChangesFromLedgerEntryChanges(ledgerEntryChanges)
+	txData := &TransactionEnvelopeAndResult{Envelope: &t.Envelope, Result: &t.Result}
+	for _, change := range changes {
+		change.reason = Transaction
+		change.TransactionData = txData
+	}
+	return changes
+}
+
 func (t *LedgerTransaction) GetChanges() ([]Change, error) {
 	var changes []Change
 
@@ -42,42 +59,48 @@ func (t *LedgerTransaction) GetChanges() ([]Change, error) {
 		return changes, errors.New("TransactionMeta.V=0 not supported")
 	case 1:
 		v1Meta := t.UnsafeMeta.MustV1()
-		txChanges := GetChangesFromLedgerEntryChanges(v1Meta.TxChanges)
+		// The var `txChanges` reflect the ledgerEntryChanges that are changed because of the transaction as a whole
+		txChanges := t.getTransactionChanges(v1Meta.TxChanges)
 		changes = append(changes, txChanges...)
 
 		// Ignore operations meta if txInternalError https://github.com/stellar/go/issues/2111
 		if t.txInternalError() && t.LedgerVersion <= 12 {
 			return changes, nil
 		}
 
-		for _, operationMeta := range v1Meta.Operations {
-			opChanges := GetChangesFromLedgerEntryChanges(
-				operationMeta.Changes,
-			)
+		// These changes reflect the ledgerEntry changes that were caused by the operations in the transaction
+		// Populate the operationInfo for these changes in the `Change` struct
+
+		operationMeta := v1Meta.Operations
+		//	operationMeta is a list of lists.
+		//	Each element in operationMeta is a list of ledgerEntryChanges
+		//	caused by the operation at that index of the element
+		for opIdx := range operationMeta {
+			opChanges := t.operationChanges(v1Meta.Operations, uint32(opIdx))
 			changes = append(changes, opChanges...)
 		}
 	case 2, 3:
 		var (
-			beforeChanges, afterChanges xdr.LedgerEntryChanges
-			operationMeta               []xdr.OperationMeta
+			txBeforeChanges, txAfterChanges xdr.LedgerEntryChanges
+			operationMeta                   []xdr.OperationMeta
 		)
 
 		switch t.UnsafeMeta.V {
 		case 2:
 			v2Meta := t.UnsafeMeta.MustV2()
-			beforeChanges = v2Meta.TxChangesBefore
-			afterChanges = v2Meta.TxChangesAfter
+			txBeforeChanges = v2Meta.TxChangesBefore
+			txAfterChanges = v2Meta.TxChangesAfter
 			operationMeta = v2Meta.Operations
 		case 3:
 			v3Meta := t.UnsafeMeta.MustV3()
-			beforeChanges = v3Meta.TxChangesBefore
-			afterChanges = v3Meta.TxChangesAfter
+			txBeforeChanges = v3Meta.TxChangesBefore
+			txAfterChanges = v3Meta.TxChangesAfter
 			operationMeta = v3Meta.Operations
 		default:
 			panic("Invalid meta version, expected 2 or 3")
 		}
 
-		txChangesBefore := GetChangesFromLedgerEntryChanges(beforeChanges)
+		txChangesBefore := t.getTransactionChanges(txBeforeChanges)
 		changes = append(changes, txChangesBefore...)
 
 		// Ignore operations meta and txChangesAfter if txInternalError
@@ -86,14 +109,15 @@ func (t *LedgerTransaction) GetChanges() ([]Change, error) {
 			return changes, nil
 		}
 
-		for _, operationMeta := range operationMeta {
-			opChanges := GetChangesFromLedgerEntryChanges(
-				operationMeta.Changes,
-			)
+		//	operationMeta is a list of lists.
+		//	Each element in operationMeta is a list of ledgerEntryChanges
+		//	caused by the operation at that index of the element
+		for opIdx := range operationMeta {
+			opChanges := t.operationChanges(operationMeta, uint32(opIdx))
 			changes = append(changes, opChanges...)
 		}
 
-		txChangesAfter := GetChangesFromLedgerEntryChanges(afterChanges)
+		txChangesAfter := t.getTransactionChanges(txAfterChanges)
 		changes = append(changes, txChangesAfter...)
 	default:
 		return changes, errors.New("Unsupported TransactionMeta version")
@@ -114,15 +138,13 @@ func (t *LedgerTransaction) GetOperation(index uint32) (xdr.Operation, bool) {
 // GetOperationChanges returns a developer friendly representation of LedgerEntryChanges.
 // It contains only operation changes.
 func (t *LedgerTransaction) GetOperationChanges(operationIndex uint32) ([]Change, error) {
-	changes := []Change{}
-
 	if t.UnsafeMeta.V == 0 {
-		return changes, errors.New("TransactionMeta.V=0 not supported")
+		return []Change{}, errors.New("TransactionMeta.V=0 not supported")
 	}
 
 	// Ignore operations meta if txInternalError https://github.com/stellar/go/issues/2111
 	if t.txInternalError() && t.LedgerVersion <= 12 {
-		return changes, nil
+		return []Change{}, nil
 	}
 
 	var operationMeta []xdr.OperationMeta
@@ -134,21 +156,37 @@ func (t *LedgerTransaction) GetOperationChanges(operationIndex uint32) ([]Change
 	case 3:
 		operationMeta = t.UnsafeMeta.MustV3().Operations
 	default:
-		return changes, errors.New("Unsupported TransactionMeta version")
+		return []Change{}, errors.New("Unsupported TransactionMeta version")
 	}
 
-	return operationChanges(operationMeta, operationIndex), nil
+	return t.operationChanges(operationMeta, operationIndex), nil
 }
 
-func operationChanges(ops []xdr.OperationMeta, index uint32) []Change {
+func (t *LedgerTransaction) operationChanges(ops []xdr.OperationMeta, index uint32) []Change {
 	if int(index) >= len(ops) {
-		return []Change{}
+		return []Change{} // TODO - operations_processor somehow seems to be failing without this
 	}
 
 	operationMeta := ops[index]
-	return GetChangesFromLedgerEntryChanges(
-		operationMeta.Changes,
-	)
+	changes := GetChangesFromLedgerEntryChanges(operationMeta.Changes)
+	op, found := t.GetOperation(index)
+	operationInfo := &OperationInfo{
+		operationIdx: index,
+		operation:    &op,
+	}
+	txData := &TransactionEnvelopeAndResult{Envelope: &t.Envelope, Result: &t.Result}
+
+	res := make([]Change, 0, len(changes))
+	for _, change := range changes {
+		if !found {
+			continue
+		}
+		change.operationInfo = operationInfo
+		change.reason = Operation
+		change.TransactionData = txData
+		res = append(res, change)
+	}
+	return res
 }
 
 // GetDiagnosticEvents returns all contract events emitted by a given operation.

xdr/transaction_envelope.go

@@ -215,6 +215,10 @@ func (e TransactionEnvelope) Preconditions() Preconditions {
 // Note for fee bump transactions, Operations() returns the operations
 // of the inner transaction
 func (e TransactionEnvelope) Operations() []Operation {
+	// This is not expected to happen.
+	if (e == TransactionEnvelope{}) {
+		return []Operation{}
+	}
 	switch e.Type {
 	case EnvelopeTypeEnvelopeTypeTxFeeBump:
 		return e.FeeBump.Tx.InnerTx.V1.Tx.Operations