Group operations

Author: patrick-ogrady

parser/group_operations.go

@@ -0,0 +1,81 @@
+package parser
+
+import (
+	"github.com/coinbase/rosetta-sdk-go/types"
+)
+
+// OperationGroup is a group of related operations
+// If all operations in a group have the same operation.Type,
+// the Type is also populated.
+type OperationGroup struct {
+	Type       string
+	Operations []*types.Operation
+}
+
+func containsInt(valid []int, value int) bool {
+	for _, v := range valid {
+		if v == value {
+			return true
+		}
+	}
+
+	return false
+}
+
+// GroupOperations parses all of a transaction's opertations and returns a slice
+// of each group of related operations. This should ONLY be called on operations
+// that have already been asserted for correctness. Assertion ensures there are
+// no duplicate operation indexes, operations are sorted, and that operations
+// only reference operations with an index less than theirs.
+func GroupOperations(transaction *types.Transaction) []*OperationGroup {
+	ops := transaction.Operations
+	opGroups := map[int]*OperationGroup{} // using a map makes group merges much easier
+	opAssignments := make([]int, len(ops))
+	for i, op := range ops {
+		if len(op.RelatedOperations) == 0 {
+			opGroups[len(opGroups)] = &OperationGroup{
+				Type:       op.Type,
+				Operations: []*types.Operation{op},
+			}
+			opAssignments[i] = len(opGroups)
+			continue
+		}
+
+		// Find groups to merge
+		groupsToMerge := []int{}
+		for _, relatedOp := range op.RelatedOperations {
+			if !containsInt(groupsToMerge, opAssignments[relatedOp.Index]) {
+				groupsToMerge = append(groupsToMerge, opAssignments[relatedOp.Index])
+			}
+		}
+
+		// Merge Groups
+		mergedGroupIndex := groupsToMerge[0]
+		mergedGroup := opGroups[mergedGroupIndex]
+		for _, otherGroupIndex := range groupsToMerge[1:] {
+			otherGroup := opGroups[otherGroupIndex]
+
+			// Add otherGroup ops to mergedGroup
+			for _, otherOp := range otherGroup.Operations {
+				if otherOp.Type != mergedGroup.Type && mergedGroup.Type != "" {
+					mergedGroup.Type = ""
+				}
+
+				mergedGroup.Operations = append(mergedGroup.Operations, otherOp)
+				opAssignments[otherOp.OperationIdentifier.Index] = mergedGroupIndex
+			}
+
+			// Delete otherGroup
+			delete(opGroups, otherGroupIndex)
+		}
+	}
+
+	return func() []*OperationGroup {
+		sliceGroups := []*OperationGroup{}
+		for _, v := range opGroups {
+			sliceGroups = append(sliceGroups, v)
+		}
+
+		return sliceGroups
+	}()
+}

parser/group_operations_test.go

@@ -0,0 +1,86 @@
+package parser
+
+import (
+	"testing"
+
+	"github.com/coinbase/rosetta-sdk-go/types"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGroupOperations(t *testing.T) {
+	var tests = map[string]struct {
+		transaction *types.Transaction
+		groups      []*OperationGroup
+	}{
+		"no ops": {
+			transaction: &types.Transaction{},
+			groups:      []*OperationGroup{},
+		},
+		"unrelated ops": {
+			transaction: &types.Transaction{
+				Operations: []*types.Operation{
+					{
+						OperationIdentifier: &types.OperationIdentifier{
+							Index: 0,
+						},
+						Type: "op 0",
+					},
+					{
+						OperationIdentifier: &types.OperationIdentifier{
+							Index: 1,
+						},
+						Type: "op 1",
+					},
+					{
+						OperationIdentifier: &types.OperationIdentifier{
+							Index: 2,
+						},
+						Type: "op 2",
+					},
+				},
+			},
+			groups: []*OperationGroup{
+				{
+					Type: "op 0",
+					Operations: []*types.Operation{
+						{
+							OperationIdentifier: &types.OperationIdentifier{
+								Index: 0,
+							},
+							Type: "op 0",
+						},
+					},
+				},
+				{
+					Type: "op 1",
+					Operations: []*types.Operation{
+						{
+							OperationIdentifier: &types.OperationIdentifier{
+								Index: 1,
+							},
+							Type: "op 1",
+						},
+					},
+				},
+				{
+					Type: "op 2",
+					Operations: []*types.Operation{
+						{
+							OperationIdentifier: &types.OperationIdentifier{
+								Index: 2,
+							},
+							Type: "op 2",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	for name, test := range tests {
+		t.Run(name, func(t *testing.T) {
+			assert.Equal(t, test.groups, GroupOperations(test.transaction))
+		})
+	}
+}