feat: sort operations by index and add unit test

- Sort operations by operation_identifier.index before returning
  from getOperationsFromTransactionData() to ensure consistent
  ordering (0, 1, 2, ...)
- Add OperationOrdering test class with shouldReturnOperationsSortedByIndex
  test to verify sorting behavior

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: Mateusz Czeladka

api/src/main/java/org/cardanofoundation/rosetta/api/construction/service/TransactionOperationParserImpl.java

@@ -24,10 +24,7 @@
 import org.openapitools.client.model.OperationMetadata;
 import org.springframework.stereotype.Service;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Optional;
+import java.util.*;
 
 import static org.cardanofoundation.rosetta.common.enumeration.OperationType.POOL_GOVERNANCE_VOTE;
 import static org.cardanofoundation.rosetta.common.enumeration.OperationType.VOTE_DREP_DELEGATION;
@@ -58,8 +55,11 @@ public List<Operation> getOperationsFromTransactionData(TransactionData data, Ne
     fillOutputOperations(transactionBody, operations);
     fillCertOperations(transactionBody, extraData, network, operations);
     fillWithdrawalOperations(transactionBody, extraData, network, operations);
+    // if more voting operations are added consider to rename this to fillVotingOperations
     fillSpoVotingOperations(extraData, operations);
 
+    operations.sort(Comparator.comparingLong(op -> op.getOperationIdentifier().getIndex()));
+
     return operations;
   }
 

api/src/main/java/org/cardanofoundation/rosetta/common/model/cardano/transaction/TransactionData.java

@@ -2,6 +2,7 @@
 
 import com.bloxbean.cardano.client.transaction.spec.TransactionBody;
 
-public record TransactionData(TransactionBody transactionBody, TransactionExtraData transactionExtraData) {
+public record TransactionData(TransactionBody transactionBody,
+                              TransactionExtraData transactionExtraData) {
 
 }

api/src/test/java/org/cardanofoundation/rosetta/common/mapper/TransactionOperationParserImplTest.java

@@ -991,6 +991,64 @@ void shouldHandleNullOutputsList()
         assertThat(operations).isEmpty();
       }
     }
+
+    /**
+     * Tests for operation ordering/sorting behavior.
+     */
+    @Nested
+    class OperationOrdering {
+
+      @Test
+      void shouldReturnOperationsSortedByIndex()
+          throws CborException, CborDeserializationException, CborSerializationException {
+        // Create operations with non-sequential indices in extraData (index 2 before index 0)
+        Operation input1 = Operation.builder()
+            .type(OperationType.INPUT.getValue())
+            .operationIdentifier(OperationIdentifier.builder().index(2L).build())
+            .account(AccountIdentifier.builder().address("addr1").build())
+            .amount(Amount.builder().value("-1000000").currency(
+                CurrencyResponse.builder().symbol("ADA").decimals(6).build()).build())
+            .build();
+
+        Operation input2 = Operation.builder()
+            .type(OperationType.INPUT.getValue())
+            .operationIdentifier(OperationIdentifier.builder().index(0L).build())
+            .account(AccountIdentifier.builder().address("addr2").build())
+            .amount(Amount.builder().value("-2000000").currency(
+                CurrencyResponse.builder().symbol("ADA").decimals(6).build()).build())
+            .build();
+
+        Operation input3 = Operation.builder()
+            .type(OperationType.INPUT.getValue())
+            .operationIdentifier(OperationIdentifier.builder().index(1L).build())
+            .account(AccountIdentifier.builder().address("addr3").build())
+            .amount(Amount.builder().value("-3000000").currency(
+                CurrencyResponse.builder().symbol("ADA").decimals(6).build()).build())
+            .build();
+
+        // Pass operations in non-sorted order: [2, 0, 1]
+        TransactionExtraData extraData = new TransactionExtraData(List.of(input1, input2, input3));
+
+        TransactionBody transactionBody = TransactionBody.builder()
+            .inputs(List.of(new TransactionInput(), new TransactionInput(), new TransactionInput()))
+            .build();
+
+        TransactionData transactionData = new TransactionData(transactionBody, extraData);
+
+        List<Operation> operations = parser
+            .getOperationsFromTransactionData(transactionData, NetworkEnum.MAINNET.getNetwork());
+
+        // Verify operations are sorted by index (0, 1, 2)
+        assertThat(operations)
+            .extracting(op -> op.getOperationIdentifier().getIndex())
+            .isSorted();
+
+        // Verify the exact order
+        assertThat(operations.get(0).getOperationIdentifier().getIndex()).isEqualTo(0L);
+        assertThat(operations.get(1).getOperationIdentifier().getIndex()).isEqualTo(1L);
+        assertThat(operations.get(2).getOperationIdentifier().getIndex()).isEqualTo(2L);
+      }
+    }
   }
 
   // ========== Helper Methods ==========