add rpc function to fetch transactions by hashes

Author: iuwqyir

internal/common/transaction.go

@@ -11,6 +11,8 @@ import (
 	"github.com/rs/zerolog/log"
 )
 
+type RawTransaction = map[string]interface{}
+
 type Transaction struct {
 	ChainId               *big.Int  `json:"chain_id" ch:"chain_id" swaggertype:"string"`
 	Hash                  string    `json:"hash" ch:"hash"`

internal/rpc/batcher.go

@@ -19,7 +19,7 @@ type RPCFetchBatchResult[T any] struct {
 
 func RPCFetchInBatches[T any](rpc *Client, blockNumbers []*big.Int, batchSize int, batchDelay int, method string, argsFunc func(*big.Int) []interface{}) []RPCFetchBatchResult[T] {
 	if len(blockNumbers) <= batchSize {
-		return RPCFetchBatch[T](rpc, blockNumbers, method, argsFunc)
+		return RPCFetchSingleBatch[*big.Int, T](rpc, blockNumbers, method, argsFunc)
 	}
 	chunks := common.BigIntSliceToChunks(blockNumbers, batchSize)
 
@@ -32,7 +32,7 @@ func RPCFetchInBatches[T any](rpc *Client, blockNumbers []*big.Int, batchSize in
 		wg.Add(1)
 		go func(chunk []*big.Int) {
 			defer wg.Done()
-			resultsCh <- RPCFetchBatch[T](rpc, chunk, method, argsFunc)
+			resultsCh <- RPCFetchSingleBatch[*big.Int, T](rpc, chunk, method, argsFunc)
 			if batchDelay > 0 {
 				time.Sleep(time.Duration(batchDelay) * time.Millisecond)
 			}
@@ -51,17 +51,15 @@ func RPCFetchInBatches[T any](rpc *Client, blockNumbers []*big.Int, batchSize in
 	return results
 }
 
-func RPCFetchBatch[T any](rpc *Client, blockNumbers []*big.Int, method string, argsFunc func(*big.Int) []interface{}) []RPCFetchBatchResult[T] {
-	batch := make([]gethRpc.BatchElem, len(blockNumbers))
-	results := make([]RPCFetchBatchResult[T], len(blockNumbers))
+func RPCFetchSingleBatch[K any, T any](rpc *Client, keys []K, method string, argsFunc func(K) []interface{}) []RPCFetchBatchResult[T] {
+	batch := make([]gethRpc.BatchElem, len(keys))
+	results := make([]RPCFetchBatchResult[T], len(keys))
 
-	for i, blockNum := range blockNumbers {
-		results[i] = RPCFetchBatchResult[T]{
-			BlockNumber: blockNum,
-		}
+	for i, key := range keys {
+		results[i] = RPCFetchBatchResult[T]{}
 		batch[i] = gethRpc.BatchElem{
 			Method: method,
-			Args:   argsFunc(blockNum),
+			Args:   argsFunc(key),
 			Result: new(T),
 		}
 	}

internal/rpc/params.go

@@ -10,6 +10,10 @@ func GetBlockWithTransactionsParams(blockNum *big.Int) []interface{} {
 	return []interface{}{hexutil.EncodeBig(blockNum), true}
 }
 
+func GetTransactionParams(txHash string) []interface{} {
+	return []interface{}{txHash}
+}
+
 func GetBlockWithoutTransactionsParams(blockNum *big.Int) []interface{} {
 	return []interface{}{hexutil.EncodeBig(blockNum), false}
 }

internal/rpc/rpc.go

@@ -27,6 +27,11 @@ type GetBlocksResult struct {
 	Data        common.Block
 }
 
+type GetTransactionsResult struct {
+	Error error
+	Data  common.Transaction
+}
+
 type BlocksPerRequestConfig struct {
 	Blocks   int
 	Logs     int
@@ -37,13 +42,15 @@ type BlocksPerRequestConfig struct {
 type IRPCClient interface {
 	GetFullBlocks(blockNumbers []*big.Int) []GetFullBlockResult
 	GetBlocks(blockNumbers []*big.Int) []GetBlocksResult
+	GetTransactions(txHashes []string) []GetTransactionsResult
 	GetLatestBlockNumber() (*big.Int, error)
 	GetChainID() *big.Int
 	GetURL() string
 	GetBlocksPerRequest() BlocksPerRequestConfig
 	IsWebsocket() bool
 	SupportsTraceBlock() bool
 	HasCode(address string) (bool, error)
+	Close()
 }
 
 type Client struct {
@@ -221,7 +228,7 @@ func (rpc *Client) GetFullBlocks(blockNumbers []*big.Int) []GetFullBlockResult {
 
 	go func() {
 		defer wg.Done()
-		result := RPCFetchBatch[common.RawBlock](rpc, blockNumbers, "eth_getBlockByNumber", GetBlockWithTransactionsParams)
+		result := RPCFetchSingleBatch[*big.Int, common.RawBlock](rpc, blockNumbers, "eth_getBlockByNumber", GetBlockWithTransactionsParams)
 		blocks = result
 	}()
 
@@ -261,13 +268,28 @@ func (rpc *Client) GetBlocks(blockNumbers []*big.Int) []GetBlocksResult {
 
 	go func() {
 		defer wg.Done()
-		blocks = RPCFetchBatch[common.RawBlock](rpc, blockNumbers, "eth_getBlockByNumber", GetBlockWithoutTransactionsParams)
+		blocks = RPCFetchSingleBatch[*big.Int, common.RawBlock](rpc, blockNumbers, "eth_getBlockByNumber", GetBlockWithoutTransactionsParams)
 	}()
 	wg.Wait()
 
 	return SerializeBlocks(rpc.chainID, blocks)
 }
 
+func (rpc *Client) GetTransactions(txHashes []string) []GetTransactionsResult {
+	var wg sync.WaitGroup
+	var transactions []RPCFetchBatchResult[common.RawTransaction]
+
+	wg.Add(1)
+
+	go func() {
+		defer wg.Done()
+		transactions = RPCFetchSingleBatch[string, common.RawTransaction](rpc, txHashes, "eth_getTransactionByHash", GetTransactionParams)
+	}()
+	wg.Wait()
+
+	return SerializeTransactions(rpc.chainID, transactions)
+}
+
 func (rpc *Client) GetLatestBlockNumber() (*big.Int, error) {
 	blockNumber, err := rpc.EthClient.BlockNumber(context.Background())
 	if err != nil {

internal/rpc/serializer.go

@@ -473,3 +473,15 @@ func interfaceToJsonString(value interface{}) string {
 	}
 	return string(jsonString)
 }
+
+func SerializeTransactions(chainId *big.Int, transactions []RPCFetchBatchResult[common.RawTransaction]) []GetTransactionsResult {
+	results := make([]GetTransactionsResult, 0, len(transactions))
+	for _, transaction := range transactions {
+		result := GetTransactionsResult{
+			Error: transaction.Error,
+			Data:  serializeTransaction(chainId, transaction.Result, time.Time{}, nil),
+		}
+		results = append(results, result)
+	}
+	return results
+}