fix init trace service (#2115)

* fix init trace service

* fix is contract

* fix trace updater

* fix trace scheduler

diff --git a/contract/trace_scheduler.go b/contract/trace_scheduler.go
index e06c2b2..0d3e35c 100644 (file)
--- a/contract/trace_scheduler.go
+++ b/contract/trace_scheduler.go
@@ -53,10 +53,13 @@ func (t *traceScheduler) processLoop() {
 
        for range ticker.C {
                jobs, beginHeight, beginHash := t.prepareJobs()
+               if beginHeight > t.tracerService.BestHeight() {
+                       continue
+               }
                t.tracer = newTracer(jobs[beginHash])
 
-               for t.currentHeight, t.currentHash = beginHeight, beginHash; len(jobs) != 0 ; {
-                       if bestHeight := t.tracerService.BestHeight(); t.currentHeight == bestHeight {
+               for t.currentHeight, t.currentHash = beginHeight, beginHash; len(jobs) != 0; {
+                       if t.currentHeight == t.tracerService.BestHeight() {
                                if ok, err := t.finishJobs(jobs); err != nil {
                                        log.WithField("err", err).Error("finish jobs")
                                } else if ok {

diff --git a/contract/trace_service.go b/contract/trace_service.go
index ff5d109..f1838b6 100644 (file)
--- a/contract/trace_service.go
+++ b/contract/trace_service.go
@@ -37,7 +37,8 @@ func NewTraceService(infra *Infrastructure) *TraceService {
 
        chainStatus := infra.Repository.GetChainStatus()
        if chainStatus == nil {
-               chainStatus.BlockHeight, chainStatus.BlockHash = infra.Chain.BestChain()
+               bestHeight, bestHash := infra.Chain.BestChain()
+               chainStatus = &ChainStatus{BlockHeight: bestHeight, BlockHash: bestHash}
                if err := infra.Repository.SaveChainStatus(chainStatus); err != nil {
                        logrus.WithField("err", err).Fatal("init chain status for trace service")
                }

diff --git a/contract/trace_updater.go b/contract/trace_updater.go
index c8c9eef..6d4ebac 100644 (file)
--- a/contract/trace_updater.go
+++ b/contract/trace_updater.go
@@ -37,11 +37,11 @@ func (t *TraceUpdater) Sync() {
                                log.WithFields(log.Fields{"module": logModule, "err": err}).Error("trace updater detach block")
                                return
                        }
-               }
-
-               if err := t.ApplyBlock(block); err != nil {
-                       log.WithFields(log.Fields{"module": logModule, "err": err}).Error("trace updater attach block")
-                       return
+               } else {
+                       if err := t.ApplyBlock(block); err != nil {
+                               log.WithFields(log.Fields{"module": logModule, "err": err}).Error("trace updater attach block")
+                               return
+                       }
                }
        }
 }

diff --git a/contract/tracer.go b/contract/tracer.go
index 3e5492b..49de1e7 100644 (file)
--- a/contract/tracer.go
+++ b/contract/tracer.go
@@ -6,6 +6,7 @@ import (
        "github.com/bytom/bytom/consensus/segwit"
        "github.com/bytom/bytom/protocol/bc"
        "github.com/bytom/bytom/protocol/bc/types"
+       "github.com/bytom/bytom/protocol/vm/vmutil"
 )
 
 type tracer struct {
@@ -110,13 +111,13 @@ func groupUTXOs(utxos []*UTXO) map[string][]*UTXO {
 func parseContractUTXOs(tx *types.Tx) ([]*UTXO, []*UTXO) {
        var inUTXOs, outUTXOs []*UTXO
        for i, input := range tx.Inputs {
-               if isContract(input.ControlProgram()) {
+               if isContract(input.ControlProgram()) && input.InputType() == types.SpendInputType {
                        inUTXOs = append(inUTXOs, inputToUTXO(tx, i))
                }
        }
 
        for i, output := range tx.Outputs {
-               if isContract(output.ControlProgram) {
+               if isContract(output.ControlProgram) && output.OutputType() == types.OriginalOutputType {
                        outUTXOs = append(outUTXOs, outputToUTXO(tx, i))
                }
        }
@@ -124,7 +125,7 @@ func parseContractUTXOs(tx *types.Tx) ([]*UTXO, []*UTXO) {
 }
 
 func isContract(program []byte) bool {
-       return !(segwit.IsP2WPKHScript(program) || segwit.IsP2WSHScript(program) || segwit.IsStraightforward(program))
+       return !(segwit.IsP2WScript(program) || vmutil.IsUnspendable(program))
 }
 
 func (t *tracer) saveInstances(instances []*Instance) {