finish wasm watcher engine

pkg/super_node/eth/converter.go

@@ -71,8 +71,8 @@ func (pc *PayloadConverter) Convert(payload shared.RawChainData) (shared.Convert
 			return nil, err
 		}
 		txMeta := TxModel{
-			Dst:    handleNullAddr(trx.To()),
-			Src:    handleNullAddr(&from),
+			Dst:    shared.HandleNullAddr(trx.To()),
+			Src:    shared.HandleNullAddr(&from),
 			TxHash: trx.Hash().String(),
 			Index:  int64(i),
 		}
@@ -169,10 +169,3 @@ func (pc *PayloadConverter) Convert(payload shared.RawChainData) (shared.Convert
 	}
 	return convertedPayload, nil
 }
-
-func handleNullAddr(to *common.Address) string {
-	if to == nil {
-		return "0x0000000000000000000000000000000000000000000000000000000000000000"
-	}
-	return to.Hex()
-}

pkg/super_node/eth/filterer.go

@@ -51,6 +51,7 @@ func (s *ResponseFilterer) Filter(filter shared.SubscriptionSettings, payload sh
 	}
 	if checkRange(ethFilters.Start.Int64(), ethFilters.End.Int64(), ethPayload.Block.Number().Int64()) {
 		response := new(IPLDs)
+		response.TotalDifficulty = ethPayload.TotalDifficulty
 		if err := s.filterHeaders(ethFilters.HeaderFilter, response, ethPayload); err != nil {
 			return IPLDs{}, err
 		}

pkg/super_node/eth/ipld_fetcher.go

@@ -20,6 +20,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ipfs/go-block-format"
@@ -58,9 +59,13 @@ func (f *IPLDFetcher) Fetch(cids shared.CIDsForFetching) (shared.IPLDs, error) {
 		return nil, fmt.Errorf("eth fetcher: expected cids type %T got %T", &CIDWrapper{}, cids)
 	}
 	log.Debug("fetching iplds")
-	iplds := IPLDs{}
-	iplds.BlockNumber = cidWrapper.BlockNumber
 	var err error
+	iplds := IPLDs{}
+	iplds.TotalDifficulty, ok = new(big.Int).SetString(cidWrapper.Header.TotalDifficulty, 10)
+	if !ok {
+		return nil, errors.New("eth fetcher: unable to set total difficulty")
+	}
+	iplds.BlockNumber = cidWrapper.BlockNumber
 	iplds.Header, err = f.FetchHeader(cidWrapper.Header)
 	if err != nil {
 		return nil, err

pkg/super_node/eth/ipld_fetcher_test.go

@@ -51,7 +51,8 @@ var (
 	mockCIDWrapper    = &eth.CIDWrapper{
 		BlockNumber: big.NewInt(9000),
 		Header: eth.HeaderModel{
-			CID: mockHeaderBlock.Cid().String(),
+			TotalDifficulty: "1337",
+			CID:             mockHeaderBlock.Cid().String(),
 		},
 		Uncles: []eth.UncleModel{
 			{
@@ -104,6 +105,7 @@ var _ = Describe("Fetcher", func() {
 			Expect(err).ToNot(HaveOccurred())
 			iplds, ok := i.(eth.IPLDs)
 			Expect(ok).To(BeTrue())
+			Expect(iplds.TotalDifficulty).To(Equal(big.NewInt(1337)))
 			Expect(iplds.BlockNumber).To(Equal(mockCIDWrapper.BlockNumber))
 			Expect(iplds.Header).To(Equal(ipfs.BlockModel{
 				Data: mockHeaderBlock.RawData(),

pkg/super_node/eth/publisher.go

@@ -64,7 +64,7 @@ func (pub *IPLDPublisher) Publish(payload shared.ConvertedData) (shared.CIDsForI
 	if err != nil {
 		return nil, err
 	}
-	reward := common2.CalcEthBlockReward(ipldPayload.Block, ipldPayload.Receipts)
+	reward := common2.CalcEthBlockReward(ipldPayload.Block.Header(), ipldPayload.Block.Uncles(), ipldPayload.Block.Transactions(), ipldPayload.Receipts)
 	header := HeaderModel{
 		CID:             headerCid,
 		ParentHash:      ipldPayload.Block.ParentHash().String(),

pkg/super_node/eth/types.go

@@ -78,13 +78,14 @@ type CIDWrapper struct {
 // IPLDs is used to package raw IPLD block data fetched from IPFS and returned by the server
 // Returned by IPLDFetcher and ResponseFilterer
 type IPLDs struct {
-	BlockNumber  *big.Int
-	Header       ipfs.BlockModel
-	Uncles       []ipfs.BlockModel
-	Transactions []ipfs.BlockModel
-	Receipts     []ipfs.BlockModel
-	StateNodes   []StateNode
-	StorageNodes []StorageNode
+	BlockNumber     *big.Int
+	TotalDifficulty *big.Int
+	Header          ipfs.BlockModel
+	Uncles          []ipfs.BlockModel
+	Transactions    []ipfs.BlockModel
+	Receipts        []ipfs.BlockModel
+	StateNodes      []StateNode
+	StorageNodes    []StorageNode
 }
 
 // Height satisfies the StreamedIPLDs interface