finish handlers

app/rpc/rpchandlers/get_accepting_blockhashes_of_txs.go

@@ -36,7 +36,7 @@ func HandleGetAcceptingBlockHashesOfTxs(context *rpccontext.Context, _ *router.R
 		if !errors.As(err, &rpcError) {
 			return nil, err
 		}
-		errorMessage := &appmessage.GetUTXOsByAddressesResponseMessage{}
+		errorMessage := &appmessage.GetAcceptingBlockHashesOfTxsResponseMessage{}
 		errorMessage.Error = rpcError
 		return errorMessage, nil
 	}

app/rpc/rpchandlers/get_accepting_blocks_of_txs.go

@@ -37,7 +37,7 @@ func HandleGetAcceptingBlocksOfTx(context *rpccontext.Context, _ *router.Router,
 		if !errors.As(err, &rpcError) {
 			return nil, err
 		}
-		errorMessage := &appmessage.GetUTXOsByAddressesResponseMessage{}
+		errorMessage := &appmessage.GetAcceptingBlocksOfTxsResponseMessage{}
 		errorMessage.Error = rpcError
 		return errorMessage, nil
 	}

app/rpc/rpchandlers/get_txs.go

@@ -1,12 +1,81 @@
 package rpchandlers
 
 import (
+	"errors"
+
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
 // HandleGetTxs handles the respectively named RPC command
 func HandleGetTxs(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	return nil, nil
+	var err error
+
+	if !context.Config.TXIndex {
+		errorMessage := &appmessage.GetTxsResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Method unavailable when kaspad is run without --txindex")
+		return errorMessage, nil
+	}
+
+	getTxsRequest := request.(*appmessage.GetTxsRequestMessage)
+
+	domainTxIDs := make([]*externalapi.DomainTransactionID, len(getTxsRequest.TxIDs))
+
+	for i := range domainTxIDs {
+		domainTxIDs[i], err = externalapi.NewDomainTransactionIDFromString(getTxsRequest.TxIDs[i])
+		if err != nil {
+			errorMessage := &appmessage.GetTxsConfirmationsResponseMessage{}
+			errorMessage.Error = appmessage.RPCErrorf("error parsing txID: %s", getTxsRequest.TxIDs[i])
+			return errorMessage, nil
+		}
+	}
+
+	transactions, _, err := context.TXIndex.GetTXs(domainTxIDs)
+	if err != nil {
+		rpcError := &appmessage.RPCError{}
+		if !errors.As(err, &rpcError) {
+			return nil, err
+		}
+		errorMessage := &appmessage.GetTxsResponseMessage{}
+		errorMessage.Error = rpcError
+		return errorMessage, nil
+	}
+
+	rpcTransactions := make([]*appmessage.RPCTransaction, len(transactions))
+
+	for i := range transactions {
+		rpcTransactions[i] = appmessage.DomainTransactionToRPCTransaction(transactions[i])
+		blockForVerboseData, found, err := context.TXIndex.TXAcceptingBlock(consensushashing.TransactionID(transactions[i]))
+		if err != nil {
+			rpcError := &appmessage.RPCError{}
+			if !errors.As(err, &rpcError) {
+				return nil, err
+			}
+			errorMessage := &appmessage.GetTxsResponseMessage{}
+			errorMessage.Error = rpcError
+			return errorMessage, nil
+		}
+		if !found {
+			errorMessage := &appmessage.GetTxsResponseMessage{}
+			errorMessage.Error = appmessage.RPCErrorf("Could not find accepting block in the txindex database for txID: %s", consensushashing.TransactionID(transactions[i]).String())
+			return errorMessage, nil
+		}
+
+		err = context.PopulateTransactionWithVerboseData(rpcTransactions[i], blockForVerboseData.Header)
+		if err != nil {
+			if errors.Is(err, rpccontext.ErrBuildBlockVerboseDataInvalidBlock) {
+				errorMessage := &appmessage.GetTxsResponseMessage{}
+				errorMessage.Error = appmessage.RPCErrorf("Block %s is invalid", consensushashing.BlockHash(blockForVerboseData).String())
+				return errorMessage, nil
+			}
+			return nil, err
+		}
+	}
+
+	response := appmessage.NewGetTxsResponse(rpcTransactions)
+
+	return response, nil
 }

app/rpc/rpchandlers/get_txs_confirmations.go

@@ -1,12 +1,60 @@
 package rpchandlers
 
 import (
+	"errors"
+
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
 // HandleGetTxsConfirmations handles the respectively named RPC command
 func HandleGetTxsConfirmations(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	return nil, nil
+	var err error
+
+	if !context.Config.TXIndex {
+		errorMessage := &appmessage.GetTxsConfirmationsResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Method unavailable when kaspad is run without --txindex")
+		return errorMessage, nil
+	}
+
+	getTxsConfirmationsRequest := request.(*appmessage.GetTxsConfirmationsRequestMessage)
+
+	domainTxIDs := make([]*externalapi.DomainTransactionID, len(getTxsConfirmationsRequest.TxIDs))
+
+	for i := range domainTxIDs {
+		domainTxIDs[i], err = externalapi.NewDomainTransactionIDFromString(getTxsConfirmationsRequest.TxIDs[i])
+		if err != nil {
+			errorMessage := &appmessage.GetTxsConfirmationsResponseMessage{}
+			errorMessage.Error = appmessage.RPCErrorf("error parsing txID: %s", getTxsConfirmationsRequest.TxIDs[i])
+			return errorMessage, nil
+		}
+	}
+
+	txIDsToConfirmations, _, err := context.TXIndex.GetTXsConfirmations(domainTxIDs)
+	if err != nil {
+		rpcError := &appmessage.RPCError{}
+		if !errors.As(err, &rpcError) {
+			return nil, err
+		}
+		errorMessage := &appmessage.GetTxsConfirmationsResponseMessage{}
+		errorMessage.Error = rpcError
+		return errorMessage, nil
+	}
+
+	txIDConfirmationPairs := make([]*appmessage.TxIDConfirmationsPair, len(txIDsToConfirmations))
+
+	i := 0
+	for txID, Confirmations := range txIDsToConfirmations {
+		txIDConfirmationPairs[i] = &appmessage.TxIDConfirmationsPair{
+			TxID:          txID.String(),
+			Confirmations: Confirmations,
+		}
+		i++
+	}
+
+	response := appmessage.NewGetTxsConfirmationsResponse(txIDConfirmationPairs)
+
+	return response, nil
 }