Merge remote-tracking branch 'harmony/main' into traceDB

go.mod

@@ -30,12 +30,12 @@ require (
 	github.com/hashicorp/golang-lru v0.5.4
 	github.com/ipfs/go-ds-badger v0.2.4
 	github.com/json-iterator/go v1.1.10
-	github.com/libp2p/go-libp2p v0.14.0
+	github.com/libp2p/go-libp2p v0.14.2
 	github.com/libp2p/go-libp2p-core v0.8.5
 	github.com/libp2p/go-libp2p-crypto v0.1.0
 	github.com/libp2p/go-libp2p-discovery v0.5.0
-	github.com/libp2p/go-libp2p-kad-dht v0.11.1
+	github.com/libp2p/go-libp2p-kad-dht v0.12.1
-	github.com/libp2p/go-libp2p-pubsub v0.4.0
+	github.com/libp2p/go-libp2p-pubsub v0.4.1
 	github.com/multiformats/go-multiaddr v0.3.1
 	github.com/multiformats/go-multiaddr-dns v0.3.1
 	github.com/natefinch/lumberjack v2.0.0+incompatible

hmy/tracer.go

@@ -342,10 +342,84 @@ func (hmy *Harmony) TraceChain(ctx context.Context, start, end *types.Block, con
 	return sub, nil
 }
 
+// same as TraceBlock, but only use 1 thread
+func (hmy *Harmony) traceBlockNoThread(ctx context.Context, block *types.Block, config *TraceConfig) ([]*TxTraceResult, error) {
+	// Create the parent state database
+	if err := hmy.BlockChain.Engine().VerifyHeader(hmy.BlockChain, block.Header(), true); err != nil {
+		return nil, err
+	}
+	parent := hmy.BlockChain.GetBlock(block.ParentHash(), block.NumberU64()-1)
+	if parent == nil {
+		return nil, fmt.Errorf("parent %#x not found", block.ParentHash())
+	}
+	reexec := defaultTraceReexec
+	if config != nil && config.Reexec != nil {
+		reexec = *config.Reexec
+	}
+	statedb, err := hmy.ComputeStateDB(parent, reexec)
+	if err != nil {
+		return nil, err
+	}
+	// Execute all the transaction contained within the block concurrently
+	var (
+		hmySigner = types.MakeSigner(hmy.BlockChain.Config(), block.Number())
+		ethSigner = types.NewEIP155Signer(hmy.BlockChain.Config().EthCompatibleChainID)
+		txs       = block.Transactions()
+		results   = make([]*TxTraceResult, len(txs))
+	)
+
+	blockHash := block.Hash()
+	// Feed the transactions into the tracers and return
+	var failed error
+traceLoop:
+	for i, tx := range txs {
+		signer := hmySigner
+		if tx.IsEthCompatible() {
+			signer = ethSigner
+		}
+		// Generate the next state snapshot fast without tracing
+		msg, _ := tx.AsMessage(signer)
+
+		ethTx := tx.ConvertToEth()
+		statedb.Prepare(ethTx.Hash(), blockHash, i)
+		vmctx := core.NewEVMContext(msg, block.Header(), hmy.BlockChain, nil)
+		res, err := hmy.TraceTx(ctx, msg, vmctx, statedb, config)
+		if err != nil {
+			results[i] = &TxTraceResult{Error: err.Error()}
+			failed = err
+			break
+		}
+		results[i] = &TxTraceResult{Result: res}
+		// Finalize the state so any modifications are written to the trie
+		statedb.Finalise(true)
+		select {
+		case <-ctx.Done():
+			failed = errors.New("trace task was canceled!")
+			break traceLoop
+		default:
+		}
+	}
+
+	// If execution failed in between, abort
+	if failed != nil {
+		return nil, failed
+	}
+	return results, nil
+}
+
 // TraceBlock configures a new tracer according to the provided configuration, and
 // executes all the transactions contained within. The return value will be one item
 // per transaction, dependent on the requested tracer.
 func (hmy *Harmony) TraceBlock(ctx context.Context, block *types.Block, config *TraceConfig) ([]*TxTraceResult, error) {
+	select {
+	case <-ctx.Done():
+		return nil, errors.New("canceled!")
+	default:
+	}
+
+	if *config.Tracer == "ParityBlockTracer" {
+		return hmy.traceBlockNoThread(ctx, block, config)
+	}
 	// Create the parent state database
 	if err := hmy.BlockChain.Engine().VerifyHeader(hmy.BlockChain, block.Header(), true); err != nil {
 		return nil, err

p2p/types/peerAddr.go

@@ -86,7 +86,8 @@ func resolveMultiAddrString(addrStr string) ([]libp2p_peer.AddrInfo, error) {
 
 func resolveMultiAddr(raw ma.Multiaddr) ([]ma.Multiaddr, error) {
 	if madns.Matches(raw) {
-		ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
+		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
 		mas, err := madns.Resolve(ctx, raw)
 		if err != nil {
 			return nil, err