feat: ability to inspect drep vote delegation operations.

api/src/main/java/org/cardanofoundation/rosetta/RosettaApiApplication.java

@@ -12,14 +12,14 @@
 import org.springframework.context.annotation.Profile;
 import org.springframework.core.Ordered;
 import org.springframework.scheduling.annotation.EnableScheduling;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
 import org.springframework.web.client.RestTemplate;
 import org.springframework.web.filter.CommonsRequestLoggingFilter;
 import org.springframework.web.filter.ForwardedHeaderFilter;
 import io.swagger.v3.oas.annotations.OpenAPIDefinition;
 import io.swagger.v3.oas.annotations.info.Info;
 import org.openapitools.jackson.nullable.JsonNullableModule;
 
-
 @SpringBootApplication
 @EntityScan({
     "org.cardanofoundation.rosetta.api.account.model.entity",
@@ -29,6 +29,7 @@
     "org.cardanofoundation.rosetta.api.common.model.entity"})
 @OpenAPIDefinition(info = @Info(title = "APIs", version = "1.0", description = "Rosetta APIs v1.0"))
 @EnableScheduling
+@EnableTransactionManagement
 public class RosettaApiApplication {
 
   public static void main(String[] args) {
@@ -44,6 +45,7 @@ public FilterRegistrationBean<ForwardedHeaderFilter> forwardedHeaderFilter() {
         DispatcherType.ERROR);
     registration.setOrder(Ordered.HIGHEST_PRECEDENCE);
     registration.setUrlPatterns(List.of("/**"));
+
     return registration;
   }
 

api/src/main/java/org/cardanofoundation/rosetta/api/block/mapper/TransactionMapper.java

@@ -35,14 +35,28 @@ public interface TransactionMapper {
 
   PoolRetirement mapEntityToPoolRetirement(PoolRetirementEntity entity);
 
+  @Mapping(source = "txHash", target = "txHash")
+  @Mapping(source = "certIndex", target = "certIndex")
+  @Mapping(source = "address", target = "address")
+  @Mapping(source = "drepHash", target = "drep.drepId") // no this is not a mistake we don't have bech32 representation in rosetta
+  @Mapping(source = "drepType", target = "drep.drepType")
+  DRepDelegation mapEntityToDRepDelegation(DrepDelegationVoteEntity entity);
+
+  @Mapping(source = "txHash", target = "txHash")
+  @Mapping(source = "certIndex", target = "certIndex")
+  @Mapping(source = "address", target = "address")
+  @Mapping(source = "drep.drepId", target = "drepHash")
+  @Mapping(source = "drep.drepType", target = "drepType")
+  DrepDelegationVoteEntity mapDRepDelegationToEntity(DRepDelegation dRepDelegation);
+
   @Mapping(target = "type", constant = Constants.OPERATION_TYPE_POOL_RETIREMENT)
   @Mapping(target = "status", source = "status.status")
   @Mapping(target = "account.address", source = "model.poolId")
   @Mapping(target = "metadata.epoch", source = "model.epoch")
   @Mapping(target = "operationIdentifier", source = "index", qualifiedByName = "OperationIdentifier")
   Operation mapPoolRetirementToOperation(PoolRetirement model, OperationStatus status, int index);
 
-  StakePoolDelegation mapDelegationEntityToDelegation(DelegationEntity entity);
+  StakePoolDelegation mapPoolDelegationEntityToDelegation(PoolDelegationEntity entity);
 
   @Mapping(target = "status", source = "status.status")
   @Mapping(target = "type", constant = Constants.OPERATION_TYPE_STAKE_DELEGATION)

api/src/main/java/org/cardanofoundation/rosetta/api/block/model/domain/DRepDelegation.java

@@ -10,6 +10,7 @@
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor
+@Setter
 public class DRepDelegation {
 
     private String txHash;
@@ -20,10 +21,10 @@ public class DRepDelegation {
     @AllArgsConstructor
     @NoArgsConstructor
     @Getter
+    @Setter
     public static class DRep {
 
         private String drepId;
-
         private DRepType drepType;
 
         public static DRepDelegation.DRep convertDRepToRosetta(DRepParams dRepParams) {

api/src/main/java/org/cardanofoundation/rosetta/api/block/model/entity/DelegationId.java

@@ -9,4 +9,5 @@ public class DelegationId implements Serializable {
 
   private String txHash;
   private long certIndex;
+
 }

api/src/main/java/org/cardanofoundation/rosetta/api/block/model/entity/DelegationVoteId.java

@@ -0,0 +1,17 @@
+package org.cardanofoundation.rosetta.api.block.model.entity;
+
+import java.io.Serializable;
+import jakarta.persistence.Column;
+
+import lombok.EqualsAndHashCode;
+
+@EqualsAndHashCode
+public class DelegationVoteId implements Serializable {
+
+    @Column(name = "tx_hash")
+    private String txHash;
+
+    @Column(name = "cert_index")
+    private long certIndex;
+
+}

api/src/main/java/org/cardanofoundation/rosetta/api/block/model/entity/DrepDelegationVoteEntity.java

@@ -0,0 +1,66 @@
+package org.cardanofoundation.rosetta.api.block.model.entity;
+
+import java.time.LocalDateTime;
+import jakarta.persistence.*;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import com.bloxbean.cardano.client.transaction.spec.cert.StakeCredType;
+import com.bloxbean.cardano.yaci.core.model.governance.DrepType;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Entity
+@Table(name = "delegation_vote")
+@IdClass(DelegationVoteId.class)
+public class DrepDelegationVoteEntity {
+
+    @jakarta.persistence.Id
+    @Column(name = "tx_hash")
+    private String txHash;
+
+    @jakarta.persistence.Id
+    @Column(name = "cert_index")
+    private long certIndex;
+
+    @Column(name = "slot")
+    private Long slot;
+
+    @Column(name = "block")
+    private Long blockNumber;
+
+    @Column(name = "block_time")
+    private Long blockTime;
+
+    @Column(name = "update_datetime")
+    private LocalDateTime updateDateTime;
+
+    @Column(name = "address")
+    private String address;
+
+    @Column(name = "drep_hash") // actual drep id as hex hash
+    private String drepHash;
+
+    @Column(name = "drep_id") // bech 32
+    private String drepId;
+
+    @Column(name = "drep_type")
+    @Enumerated(EnumType.STRING)
+    private DrepType drepType;
+
+    @Column(name = "credential")
+    private String credential;
+
+    @Column(name = "cred_type")
+    @Enumerated(EnumType.STRING)
+    private StakeCredType credType;
+
+    @Column(name = "epoch")
+    private Integer epoch;
+
+}

api/src/main/java/org/cardanofoundation/rosetta/api/block/model/entity/DelegationEntity.java → api/src/main/java/org/cardanofoundation/rosetta/api/block/model/entity/PoolDelegationEntity.java

@@ -12,7 +12,7 @@
 @Entity
 @Table(name = "delegation")
 @IdClass(DelegationId.class)
-public class DelegationEntity {
+public class PoolDelegationEntity {
 
   @Id
   @Column(name = "tx_hash")

api/src/main/java/org/cardanofoundation/rosetta/api/block/model/entity/PoolRegistrationId.java

@@ -9,4 +9,5 @@ public class PoolRegistrationId implements Serializable {
 
   private String txHash;
   private int certIndex;
+
 }

api/src/main/java/org/cardanofoundation/rosetta/api/block/model/entity/StakeRegistrationId.java

@@ -9,4 +9,5 @@ public class StakeRegistrationId implements Serializable {
 
   private String txHash;
   private long certIndex;
+
 }

api/src/main/java/org/cardanofoundation/rosetta/api/block/model/repository/DRepVoteDelegationRepository.java

@@ -0,0 +1,15 @@
+package org.cardanofoundation.rosetta.api.block.model.repository;
+
+import java.util.List;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import org.cardanofoundation.rosetta.api.block.model.entity.DrepDelegationVoteEntity;
+
+@Repository
+public interface DRepVoteDelegationRepository extends JpaRepository<DrepDelegationVoteEntity, DrepDelegationVoteEntity>  {
+
+    List<DrepDelegationVoteEntity> findByTxHashIn(List<String> txHashes);
+
+}

api/src/main/java/org/cardanofoundation/rosetta/api/block/model/repository/DelegationRepository.java → api/src/main/java/org/cardanofoundation/rosetta/api/block/model/repository/PoolDelegationRepository.java

@@ -5,12 +5,12 @@
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 
-import org.cardanofoundation.rosetta.api.block.model.entity.DelegationEntity;
 import org.cardanofoundation.rosetta.api.block.model.entity.DelegationId;
+import org.cardanofoundation.rosetta.api.block.model.entity.PoolDelegationEntity;
 
 @Repository
-public interface DelegationRepository extends JpaRepository<DelegationEntity, DelegationId> {
+public interface PoolDelegationRepository extends JpaRepository<PoolDelegationEntity, DelegationId> {
 
-  List<DelegationEntity> findByTxHashIn(List<String> txHashes);
+  List<PoolDelegationEntity> findByTxHashIn(List<String> txHashes);
 
 }

api/src/main/java/org/cardanofoundation/rosetta/api/block/model/repository/StakeRegistrationRepository.java

@@ -11,4 +11,5 @@ public interface StakeRegistrationRepository extends
     JpaRepository<StakeRegistrationEntity, StakeRegistrationId> {
 
   List<StakeRegistrationEntity> findByTxHashIn(List<String> txHashes);
+
 }

api/src/main/java/org/cardanofoundation/rosetta/api/block/service/LedgerBlockServiceImpl.java

@@ -7,7 +7,6 @@
 import java.util.Optional;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.StructuredTaskScope;
-import java.util.concurrent.StructuredTaskScope.ShutdownOnFailure;
 import java.util.concurrent.TimeoutException;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -43,17 +42,18 @@ public class LedgerBlockServiceImpl implements LedgerBlockService {
   private final BlockRepository blockRepository;
   private final TxRepository txRepository;
   private final StakeRegistrationRepository stakeRegistrationRepository;
-  private final DelegationRepository delegationRepository;
   private final PoolRegistrationRepository poolRegistrationRepository;
+  private final PoolDelegationRepository poolDelegationRepository;
   private final PoolRetirementRepository poolRetirementRepository;
   private final WithdrawalRepository withdrawalRepository;
   private final AddressUtxoRepository addressUtxoRepository;
   private final InvalidTransactionRepository invalidTransactionRepository;
+  private final DRepVoteDelegationRepository dRepVoteDelegationRepository;
+  private final Clock clock;
 
   private final BlockMapper blockMapper;
   private final TransactionMapper transactionMapper;
   private final AddressUtxoEntityToUtxo addressUtxoEntityToUtxo;
-  private final Clock clock;
 
   private BlockIdentifierExtended cachedGenesisBlock;
 
@@ -186,13 +186,14 @@ private TransactionInfo findByTxHash(List<BlockTx> transactions) {
             .map(Utxo::getTxHash)
             .toList();
 
-    try (ShutdownOnFailure scope = new ShutdownOnFailure()) {
+    try (StructuredTaskScope.ShutdownOnFailure scope = new StructuredTaskScope.ShutdownOnFailure()) {
       StructuredTaskScope.Subtask<List<AddressUtxoEntity>> utxos = scope.fork(() -> addressUtxoRepository.findByTxHashIn(utxHashes));
       StructuredTaskScope.Subtask<List<StakeRegistrationEntity>> sReg = scope.fork(() -> stakeRegistrationRepository.findByTxHashIn(txHashes));
-      StructuredTaskScope.Subtask<List<DelegationEntity>> delegations = scope.fork(() -> delegationRepository.findByTxHashIn(txHashes));
+      StructuredTaskScope.Subtask<List<PoolDelegationEntity>> delegations = scope.fork(() -> poolDelegationRepository.findByTxHashIn(txHashes));
       StructuredTaskScope.Subtask<List<PoolRegistrationEntity>> pReg = scope.fork(() -> poolRegistrationRepository.findByTxHashIn(txHashes));
       StructuredTaskScope.Subtask<List<PoolRetirementEntity>> pRet = scope.fork(() -> poolRetirementRepository.findByTxHashIn(txHashes));
       StructuredTaskScope.Subtask<List<WithdrawalEntity>> withdrawals = scope.fork(() -> withdrawalRepository.findByTxHashIn(txHashes));
+      StructuredTaskScope.Subtask<List<DrepDelegationVoteEntity>> voteDelegations = scope.fork(() -> dRepVoteDelegationRepository.findByTxHashIn(txHashes));
 
       scope.joinUntil(Instant.now(clock).plusSeconds(blockFetchTimeoutInSeconds));
       scope.throwIfFailed(); // Propagate any failure
@@ -203,21 +204,26 @@ private TransactionInfo findByTxHash(List<BlockTx> transactions) {
               delegations.get(),
               pReg.get(),
               pRet.get(),
-              withdrawals.get()
+              withdrawals.get(),
+              voteDelegations.get()
       );
     } catch (ExecutionException e) {
-      log.error("Error fetching transaction data", e);
+      String errorMsg = "Error fetching transaction data, msg:%s".formatted(e.getMessage());
 
-      throw ExceptionFactory.unspecifiedError("Error fetching transaction data, msg:%s".formatted(e.getMessage()));
+      log.error(errorMsg);
+
+      throw ExceptionFactory.unspecifiedError(errorMsg);
     } catch (InterruptedException e) {
       Thread.currentThread().interrupt();
       log.error("Error fetching transaction data", e);
 
       throw ExceptionFactory.unspecifiedError("Error fetching transaction data, msg:%s".formatted(e.getMessage()));
     } catch (TimeoutException e) {
-      log.error("Error fetching transaction data", e);
+      String errorMsg = "Timeout while fetching transaction data from db, timeout(secs): %d".formatted(blockFetchTimeoutInSeconds);
 
-      throw ExceptionFactory.timeOut("timeout while fetching transaction data from db.");
+      log.error(errorMsg);
+
+      throw ExceptionFactory.timeOut(errorMsg);
     }
   }
 
@@ -245,10 +251,10 @@ void populateTransaction(BlockTx transaction,
                     .toList());
 
     transaction.setStakePoolDelegations(
-            fetched.delegations
+            fetched.stakePoolDelegations
                     .stream()
                     .filter(tx -> tx.getTxHash().equals(transaction.getHash()))
-                    .map(transactionMapper::mapDelegationEntityToDelegation)
+                    .map(transactionMapper::mapPoolDelegationEntityToDelegation)
                     .toList());
 
     transaction.setWithdrawals(
@@ -259,18 +265,27 @@ void populateTransaction(BlockTx transaction,
                     .toList());
 
     transaction.setPoolRegistrations(
-            fetched.poolRegistrations
+            fetched.stakePoolRegistrations
                     .stream()
                     .filter(tx -> tx.getTxHash().equals(transaction.getHash()))
                     .map(transactionMapper::mapEntityToPoolRegistration)
                     .toList());
 
     transaction.setPoolRetirements(
-            fetched.poolRetirements
+            fetched.stakePoolRetirements
                     .stream()
                     .filter(tx -> tx.getTxHash().equals(transaction.getHash()))
                     .map(transactionMapper::mapEntityToPoolRetirement)
                     .toList());
+
+    transaction.setDRepDelegations(
+            fetched.drepVoteDelegations
+                    .stream()
+                    .filter(tx -> tx.getTxHash().equals(transaction.getHash()))
+                    .filter(tx -> tx.getCertIndex() == 0) // 0 represents the single drep delegation
+                    .map(transactionMapper::mapEntityToDRepDelegation)
+                    .toList()
+    );
   }
 
   private void populateUtxo(Utxo utxo, Map<UtxoKey, AddressUtxoEntity> utxoMap) {
@@ -292,15 +307,14 @@ private static Map<UtxoKey, AddressUtxoEntity> getUtxoMapFromEntities(Transactio
 
   record TransactionInfo(List<AddressUtxoEntity> utxos,
                          List<StakeRegistrationEntity> stakeRegistrations,
-                         List<DelegationEntity> delegations,
-                         List<PoolRegistrationEntity> poolRegistrations,
-                         List<PoolRetirementEntity> poolRetirements,
-                         List<WithdrawalEntity> withdrawals) {
-
+                         List<PoolDelegationEntity> stakePoolDelegations,
+                         List<PoolRegistrationEntity> stakePoolRegistrations,
+                         List<PoolRetirementEntity> stakePoolRetirements,
+                         List<WithdrawalEntity> withdrawals,
+                         List<DrepDelegationVoteEntity> drepVoteDelegations) {
   }
 
   record UtxoKey(String txHash, Integer outputIndex) {
-
   }
 
 }