Make transaction tracing timeout configurable

The rpc.reqTimeout value is now passed to the blockchain node as the
timeout parameter when tracing transactions.

analyzer/txtracer.go

@@ -18,31 +18,36 @@ import (
 	"context"
 	"fmt"
 	"math/big"
+	"time"
 
 	"github.com/celo-org/celo-blockchain/common"
 	"github.com/celo-org/celo-blockchain/core/types"
+	"github.com/celo-org/celo-blockchain/eth"
 	"github.com/celo-org/celo-blockchain/log"
 	"github.com/celo-org/kliento/client"
+	"github.com/celo-org/kliento/client/debug"
 	"github.com/celo-org/kliento/contracts"
 	"github.com/celo-org/kliento/registry"
 	"github.com/celo-org/rosetta/db"
 	"github.com/celo-org/rosetta/internal/utils"
 )
 
 type Tracer struct {
-	ctx    context.Context
-	cc     *client.CeloClient
-	db     db.RosettaDBReader
-	logger log.Logger
+	ctx          context.Context
+	cc           *client.CeloClient
+	db           db.RosettaDBReader
+	logger       log.Logger
+	traceTimeout time.Duration
 }
 
-func NewTracer(ctx context.Context, cc *client.CeloClient, db db.RosettaDBReader) *Tracer {
+func NewTracer(ctx context.Context, cc *client.CeloClient, db db.RosettaDBReader, traceTimeout time.Duration) *Tracer {
 	logger := log.New("module", "tracer")
 	return &Tracer{
-		ctx:    ctx,
-		cc:     cc,
-		db:     db,
-		logger: logger,
+		ctx:          ctx,
+		cc:           cc,
+		db:           db,
+		logger:       logger,
+		traceTimeout: traceTimeout,
 	}
 }
 
@@ -160,12 +165,14 @@ func (tr *Tracer) TxTransfers(tx *types.Transaction, receipt *types.Receipt, tob
 		return nil, nil
 	}
 
-	internalTransfers, err := tr.cc.Debug.TransactionTransfers(tr.ctx, tx.Hash())
+	res := debug.TransferTracerResponse{}
+	timeout := tr.traceTimeout.String()
+	cfg := &eth.TraceConfig{Tracer: &debug.TransferTracer, Timeout: &timeout}
+	err := tr.cc.Debug.TraceTransaction(tr.ctx, &res, tx.Hash(), cfg)
 	if err != nil {
 		return nil, fmt.Errorf("can't run celo-rpc tx-tracer: %w", err)
 	}
-
-	return InternalTransfersToOperations(internalTransfers, tobinTax), nil
+	return InternalTransfersToOperations(res.Transfers, tobinTax), nil
 }
 
 func (tr *Tracer) TxOpsFromLogs(tx *types.Transaction, receipt *types.Receipt, tobinTax *TobinTax, contractMap map[string]common.Address) ([]Operation, error) {

cmd/run.go

@@ -64,7 +64,7 @@ func init() {
 	// RPC Service Flags
 	flagSet.Uint("rpc.port", 8080, "Listening port for http server")
 	flagSet.String("rpc.address", "", "Listening address for http server")
-	flagSet.Duration("rpc.reqTimeout", 25*time.Second, "Timeout when serving a request")
+	flagSet.Duration("rpc.reqTimeout", 25*time.Second, "Timeout for requests to this service, this also controls the timeout sent to the blockchain node for trace transaction requests")
 
 	// Geth Service Flags
 	flagSet.String("geth.binary", "", "Path to the celo-blockchain binary")

go.mod

@@ -5,8 +5,9 @@ go 1.14
 require (
 	github.com/allegro/bigcache v1.2.1 // indirect
 	github.com/aristanetworks/goarista v0.0.0-20190912214011-b54698eaaca6 // indirect
+	github.com/celo-org/bls-zexe/go v0.0.0-20200502082044-230d2f4866d5 // indirect
 	github.com/celo-org/celo-blockchain v1.3.2
-	github.com/celo-org/kliento v0.2.1-0.20210510184328-accba0f45060
+	github.com/celo-org/kliento v0.2.1-0.20220118184311-83bd0da5cb6c
 	github.com/coinbase/rosetta-sdk-go v0.5.9
 	github.com/felixge/httpsnoop v1.0.1
 	github.com/google/addlicense v0.0.0-20200622132530-df58acafd6d5 // indirect

go.sum

@@ -76,6 +76,8 @@ github.com/celo-org/kliento v0.2.1-0.20210315135015-d8610134da4d h1:RazqXGLcNM2Q
 github.com/celo-org/kliento v0.2.1-0.20210315135015-d8610134da4d/go.mod h1:SNanwzazM/kQHHM4xgC2wKCc+c4+rdxrBYM03q19w7g=
 github.com/celo-org/kliento v0.2.1-0.20210510184328-accba0f45060 h1:N6BUoTXYC7uVQ1bJqkrjnaNrf7Gj5K8yHu+rq0miths=
 github.com/celo-org/kliento v0.2.1-0.20210510184328-accba0f45060/go.mod h1:M/HTJUVMSAdqynAJHQD3mwsE8lAl6vT/EXED6jqEKSo=
+github.com/celo-org/kliento v0.2.1-0.20220118184311-83bd0da5cb6c h1:AT/P4o61ttp88T4dOYAr9XsyEWHYvEVtixWg1XpYjOo=
+github.com/celo-org/kliento v0.2.1-0.20220118184311-83bd0da5cb6c/go.mod h1:6aoUqGKc/g1blbbJeYi/ZXnbyrk5Yujyt5QTcukeTs4=
 github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4=
 github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=

service/rpc/rpc.go

@@ -56,7 +56,7 @@ func NewRosettaServer(cc *client.CeloClient, db db.RosettaDBReader, cfg *Rosetta
 	var mainHandler http.Handler
 	var err error
 
-	mainHandler, err = createRouter(cc, db, chainParams)
+	mainHandler, err = createRouter(cc, db, cfg, chainParams)
 	if err != nil {
 		return nil, err
 	}
@@ -117,8 +117,8 @@ func requestLogHandler(handler http.Handler) http.Handler {
 	})
 }
 
-func createRouter(celoClient *client.CeloClient, db db.RosettaDBReader, chainParams *chain.ChainParameters) (http.Handler, error) {
-	servicer, err := NewServicer(celoClient, db, chainParams)
+func createRouter(celoClient *client.CeloClient, db db.RosettaDBReader, cfg *RosettaServerConfig, chainParams *chain.ChainParameters) (http.Handler, error) {
+	servicer, err := NewServicer(celoClient, db, cfg, chainParams)
 	if err != nil {
 		return nil, err
 	}

service/rpc/servicer.go

@@ -19,6 +19,7 @@ import (
 	"errors"
 	"fmt"
 	"math/big"
+	"time"
 
 	"github.com/celo-org/celo-blockchain/accounts/abi/bind"
 	"github.com/celo-org/celo-blockchain/common"
@@ -43,10 +44,12 @@ type Servicer struct {
 	db          db.RosettaDBReader
 	chainParams *chain.ChainParameters
 	airgap      airgap.Server
+	// The timeout to use when performing transaction traces.
+	txTraceTimeout time.Duration
 }
 
 // NewServicer creates a default api service
-func NewServicer(celoClient *client.CeloClient, db db.RosettaDBReader, cp *chain.ChainParameters) (*Servicer, error) {
+func NewServicer(celoClient *client.CeloClient, db db.RosettaDBReader, cfg *RosettaServerConfig, cp *chain.ChainParameters) (*Servicer, error) {
 	srvCtx, err := server.NewServerContext(celoClient)
 	if err != nil {
 		return nil, err
@@ -58,10 +61,11 @@ func NewServicer(celoClient *client.CeloClient, db db.RosettaDBReader, cp *chain
 	}
 
 	return &Servicer{
-		cc:          celoClient,
-		db:          db,
-		chainParams: cp,
-		airgap:      airgap,
+		cc:             celoClient,
+		db:             db,
+		chainParams:    cp,
+		airgap:         airgap,
+		txTraceTimeout: cfg.RequestTimeout,
 	}, nil
 }
 
@@ -364,9 +368,9 @@ func (s *Servicer) Block(ctx context.Context, request *types.BlockRequest) (*typ
 }
 
 // BlockTransaction - Get a Block Transaction
-func (s *Servicer) BlockTransaction(ctx context.Context, request *types.BlockTransactionRequest) (*types.BlockTransactionResponse, *types.Error) {
+func (S *Servicer) BlockTransaction(ctx context.Context, request *types.BlockTransactionRequest) (*types.BlockTransactionResponse, *types.Error) {
 
-	blockHeader, err := s.blockHeader(ctx, FullToPartialBlockIdentifier(request.BlockIdentifier))
+	blockHeader, err := S.blockHeader(ctx, FullToPartialBlockIdentifier(request.BlockIdentifier))
 	if err != nil {
 		return nil, err
 	}
@@ -375,8 +379,8 @@ func (s *Servicer) BlockTransaction(ctx context.Context, request *types.BlockTra
 
 	var operations []*types.Operation
 	// Check If it's block transaction (imaginary transaction)
-	if s.chainParams.IsLastBlockOfEpoch(blockHeader.Number.Uint64()) && txHash == blockHeader.Hash() {
-		rewards, err := analyzer.ComputeEpochRewards(ctx, s.cc, s.db, &blockHeader.Header)
+	if S.chainParams.IsLastBlockOfEpoch(blockHeader.Number.Uint64()) && txHash == blockHeader.Hash() {
+		rewards, err := analyzer.ComputeEpochRewards(ctx, S.cc, S.db, &blockHeader.Header)
 		if err != nil {
 			return nil, LogErrCeloClient("ComputeEpochRewards", err)
 		}
@@ -388,17 +392,17 @@ func (s *Servicer) BlockTransaction(ctx context.Context, request *types.BlockTra
 			return nil, LogErrInternal(ErrMissingTxInBlock, "blockNumber", blockHeader.Number, "txHash", txHash.Hex())
 		}
 
-		tx, _, err := s.cc.Eth.TransactionByHash(ctx, txHash)
+		tx, _, err := S.cc.Eth.TransactionByHash(ctx, txHash)
 		if err != nil {
 			return nil, LogErrCeloClient("TransactionByHash", err)
 		}
 
-		receipt, err := s.cc.Eth.TransactionReceipt(ctx, tx.Hash())
+		receipt, err := S.cc.Eth.TransactionReceipt(ctx, tx.Hash())
 		if err != nil {
 			return nil, LogErrCeloClient("TransactionReceipt", err)
 		}
 
-		tracer := analyzer.NewTracer(ctx, s.cc, s.db)
+		tracer := analyzer.NewTracer(ctx, S.cc, S.db, S.txTraceTimeout)
 
 		ops, err := tracer.TraceTransaction(&blockHeader.Header, tx, receipt)
 		if err != nil {