github.com/supragya/TendermintConnector@v0.0.0-20210619045051-113e32b84fb1/chains/cosmos/handlerCOSMOS.go

package cosmos

import (

	// "bytes"

	"bufio"
	"crypto/sha256"
	b64 "encoding/base64"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"net"
	"net/http"
	"os"
	"runtime"
	"strconv"
	"strings"
	"time"

	"github.com/gogo/protobuf/proto"
	lru "github.com/hashicorp/golang-lru"
	log "github.com/sirupsen/logrus"
	"github.com/supragya/TendermintConnector/chains"
	"github.com/supragya/TendermintConnector/chains/cosmos/conn"
	"github.com/supragya/TendermintConnector/chains/cosmos/crypto/ed25519"
	"github.com/supragya/TendermintConnector/chains/cosmos/crypto/merkle"
	"github.com/supragya/TendermintConnector/chains/cosmos/libs/bits"
	flow "github.com/supragya/TendermintConnector/chains/cosmos/libs/flowrate"
	tmmath "github.com/supragya/TendermintConnector/chains/cosmos/libs/math"
	"github.com/supragya/TendermintConnector/chains/cosmos/libs/protoio"
	"github.com/supragya/TendermintConnector/chains/cosmos/libs/timer"
	tmcons "github.com/supragya/TendermintConnector/chains/cosmos/proto/tendermint/consensus"
	tmp2p "github.com/supragya/TendermintConnector/chains/cosmos/proto/tendermint/p2p"
	tmproto "github.com/supragya/TendermintConnector/chains/cosmos/proto/tendermint/types"
	"github.com/supragya/TendermintConnector/marlin"
	marlinTypes "github.com/supragya/TendermintConnector/types"
)

// ServicedTMCore is a string associated with each TM core handler
// to decipher which handler is to be attached.
var ServicedTMCore chains.NodeType = chains.NodeType{Version: "", Network: "cosmoshub-4", ProtocolVersionApp: "0", ProtocolVersionBlock: "11", ProtocolVersionP2p: "8"}

// ---------------------- DATA CONNECT INTERFACE --------------------------------

func RunDataConnect(peerAddr string,
	marlinTo chan marlinTypes.MarlinMessage,
	marlinFrom chan marlinTypes.MarlinMessage,
	isConnectionOutgoing bool,
	keyFile string,
	listenPort int) {
	log.Info("Starting cosmos Tendermint Core Handler - Vanilla Tendermint")

	if keyFile != "" {
		isKeyFileUsed = true
		keyFileLocation = keyFile
	}

	for {
		handler, err := createTMHandler(peerAddr, "0.0.0.0:0", marlinTo, marlinFrom, isConnectionOutgoing, listenPort, true)

		if err != nil {
			log.Error("Error encountered while creating TM Handler: ", err)
			os.Exit(1)
		}

		if isConnectionOutgoing {
			err = handler.dialPeer()
		} else {
			err = handler.acceptPeer()
		}
		if err != nil {
			log.Error("Base Connection establishment with peer unsuccessful: ", err)
			goto REATTEMPT_CONNECTION
		}

		err = handler.upgradeConnectionAndHandshake()
		if err != nil {
			log.Error("Error while upgrading connection and handshaking with peer: ", err)
			goto REATTEMPT_CONNECTION
		}

		handler.beginServicing()

		select {
		case <-handler.signalConnError:
			handler.signalShutSend <- struct{}{}
			handler.signalShutRecv <- struct{}{}
			handler.signalShutThroughput <- struct{}{}
			goto REATTEMPT_CONNECTION
		}

	REATTEMPT_CONNECTION:
		handler.baseConnection.Close()
		handler.secretConnection.Close()
		log.Info("Error encountered with connection to the peer. Attempting reconnect post 1 second.")
		time.Sleep(1 * time.Second)
	}
}

func (h *TendermintHandler) dialPeer() error {
	var err error
	h.baseConnection, err = net.DialTimeout("tcp", h.peerAddr, 2000*time.Millisecond)
	if err != nil {
		return err
	}

	return nil
}

func (h *TendermintHandler) acceptPeer() error {

	listener, err := net.Listen("tcp", "0.0.0.0:"+strconv.Itoa(h.listenPort))
	if err != nil {
		return err
	}

	log.Info("TMCore side listening for dials to ",
		string(hex.EncodeToString(h.privateKey.PubKey().Address())), "@<SYSTEM-IP-ADDR>:", h.listenPort)

	h.baseConnection, err = listener.Accept()
	if err != nil {
		return err
	}

	return nil
}

func (h *TendermintHandler) upgradeConnectionAndHandshake() error {
	log.Info("Handshaking procedure")
	var err error
	h.secretConnection, err = conn.MakeSecretConnection(h.baseConnection, h.privateKey)
	if err != nil {
		return err
	}

	err = h.handshake()
	if err != nil {
		return err
	}

	log.Info("Established connection with TM peer [" +
		string(hex.EncodeToString(h.secretConnection.RemotePubKey().Address())) +
		"] a.k.a. " + h.peerNodeInfo.Moniker)
	return nil
}

func (h *TendermintHandler) handshake() error {
	var (
		errc                              = make(chan error, 2)
		ourNodeInfo tmp2p.DefaultNodeInfo = tmp2p.DefaultNodeInfo{
			tmp2p.ProtocolVersion{App: 0, Block: 11, P2P: 8},
			string(hex.EncodeToString(h.privateKey.PubKey().Address())),
			"tcp://127.0.0.1:20026", //TODO Correct this - v0.2 prerelease
			"cosmoshub-4",
			"",
			[]byte{channelBc, channelCsSt, channelCsDc, channelCsVo,
				channelCsVs, channelMm, channelEv},
			"marlin-tendermint-connector",
			tmp2p.DefaultNodeInfoOther{"on", "tcp://0.0.0.0:26667"}, // TODO: Correct this - v0.2 prerelease
		}
	)

	go func(errc chan<- error, c net.Conn) {
		_, err := protoio.NewDelimitedWriter(c).WriteMsg(&ourNodeInfo)
		if err != nil {
			log.Error("Error encountered while sending handshake message ", err)
		}
		errc <- err
	}(errc, h.secretConnection)

	go func(errc chan<- error, c net.Conn) {
		protoReader := protoio.NewDelimitedReader(c, 10240)
		_, err := protoReader.ReadMsg(&h.peerNodeInfo)
		if err != nil {
			log.Error("Error encountered while recieving handshake message ", err)
		}
		errc <- err
	}(errc, h.secretConnection)

	for i := 0; i < cap(errc); i++ {
		err := <-errc
		if err != nil {
			log.Error("Encountered error in handshake with TM core: ", err)
			return err
		}
	}
	return nil
}

func (h *TendermintHandler) beginServicing() error {
	// Create a P2P Connection
	h.p2pConnection = P2PConnection{
		conn:            h.secretConnection,
		bufConnReader:   bufio.NewReaderSize(h.secretConnection, 65535),
		bufConnWriter:   bufio.NewWriterSize(h.secretConnection, 65535),
		sendMonitor:     flow.New(0, 0),
		recvMonitor:     flow.New(0, 0),
		send:            make(chan struct{}, 1),
		pong:            make(chan struct{}, 1),
		doneSendRoutine: make(chan struct{}, 1),
		quitSendRoutine: make(chan struct{}, 1),
		quitRecvRoutine: make(chan struct{}, 1),
		flushTimer:      timer.NewThrottleTimer("flush", 100*time.Millisecond),
		pingTimer:       time.NewTicker(30 * time.Second),
		pongTimeoutCh:   make(chan bool, 1),
	}

	// Start P2P Send and recieve routines + Status messages for message throughput
	go h.sendRoutine()
	go h.recvRoutine()
	go h.throughput.presentThroughput(5, h.signalShutThroughput)

	// Allow cosmosnet messages from marlin Relay
	marlin.AllowServicedChainMessages(h.servicedChainId)
	return nil
}

func (h *TendermintHandler) sendRoutine() {
	protoWriter := protoio.NewDelimitedWriter(h.p2pConnection.bufConnWriter)
	for {
		var _n int
		var err error
		select {
		case <-h.p2pConnection.pong:
			// log.Info("Send Pong")
			_n, err = protoWriter.WriteMsg(mustWrapPacket(&tmp2p.PacketPong{}))
			if err != nil {
				log.Error("Failed to send PacketPong", "err", err)
				h.flush()
				h.signalConnError <- struct{}{}
				return
			}
			h.p2pConnection.sendMonitor.Update(_n)
			h.flush()

		// Actual message packets from Marlin Relay (encoded in Marlin Tendermint Data Transfer Protocol v1)
		case marlinMsg := <-h.marlinFrom:
			switch marlinMsg.Channel {
			case channelCsSt:
				msgEncoded, err := h.getBytesFromMarlinMessage(&marlinMsg)
				if err != nil {
					log.Debug("Cannot get bytes from marlin to a valid Consensus Message: ", err)
				}
				msg, err := decodeMsg(msgEncoded)
				if err != nil {
					log.Debug("Cannot decode messages to CsSt: ", err)
				}
				switch msg.(type) {
				case *NewRoundStepMessage:
					for _, pkt := range marlinMsg.Packets {
						_n, err := protoWriter.WriteMsg(mustWrapPacket(&tmp2p.PacketMsg{
							ChannelID: int32(channelCsSt),
							EOF:       pkt.EOF == 1,
							Data:      pkt.Bytes,
						}))
						if err != nil {
							log.Error("Error occurred in sending data to TMCore: ", err)
							// h.signalConnError <- struct{}{}
						}
						h.p2pConnection.sendMonitor.Update(int(_n))
						err = h.p2pConnection.bufConnWriter.Flush()
						if err != nil {
							log.Error("Cannot flush buffer: ", err)
						}
					}
				}
			}
		}
	}
}

func (h *TendermintHandler) getBytesFromMarlinMessage(marlinMsg *marlinTypes.MarlinMessage) ([]byte, error) {
	var databuf []byte
	for _, pkt := range marlinMsg.Packets {
		databuf = append(databuf, pkt.Bytes...)
	}
	return databuf, nil
}

func (h *TendermintHandler) flush() {
	err := h.p2pConnection.bufConnWriter.Flush()
	if err != nil {
		log.Error("BufConnWriter flush failed", "err", err)
	}
}

func (h *TendermintHandler) recvRoutine() {
	log.Info("TMCore -> Connector Routine Started")
	protoReader := protoio.NewDelimitedReader(h.p2pConnection.bufConnReader, 2000)

FOR_LOOP:
	for {
		select {
		case <-h.signalShutRecv:
			log.Info("TMCore -> Connector Routine shutdown")
			break FOR_LOOP
		default:
		}
		h.p2pConnection.recvMonitor.Limit(20000, 5120000, true)

		/*
			Peek into bufConnReader for debugging

			if numBytes := c.bufConnReader.Buffered(); numBytes > 0 {
				bz, err := c.bufConnReader.Peek(cmn.MinInt(numBytes, 100))
				if err == nil {
					// return
				} else {
					log.Debug("Error peeking connection buffer ", "err ", err)
					// return nil
				}
				log.Info("Peek connection buffer ", "numBytes ", numBytes, " bz ", bz)
			}
		*/

		// Read packet type
		var packet tmp2p.Packet
		_n, err := protoReader.ReadMsg(&packet)

		h.p2pConnection.recvMonitor.Update(int(_n))

		// Unmarshalling test
		if err != nil {
			if err == io.EOF {
				log.Error("TMCore -> Connector Connection is closed (likely by the other side) ", err)
			} else {
				log.Error("TMCore -> Connector Connection failed (reading byte): ", err)
			}
			h.signalConnError <- struct{}{}
			break FOR_LOOP
		}

		switch pkt := packet.Sum.(type) {
		case *tmp2p.Packet_PacketPing:
			// TODO: prevent abuse, as they cause flush()'s.
			// https://github.com/tendermint/tendermint/issues/1190
			// log.Info("Receive Ping ", pkt)
			select {
			case h.p2pConnection.pong <- struct{}{}:
			default:
				// never block
			}
		case *tmp2p.Packet_PacketPong:
			log.Info("Receive Pong")
			select {
			case h.p2pConnection.pongTimeoutCh <- false:
			default:
				// never block
			}
		case *tmp2p.Packet_PacketMsg:
			var eof uint32 = 0
			if pkt.PacketMsg.EOF {
				eof = 1
			}
			h.channelBuffer[byte(pkt.PacketMsg.ChannelID)] = append(h.channelBuffer[byte(pkt.PacketMsg.ChannelID)],
				marlinTypes.PacketMsg{
					EOF:   eof,
					Bytes: pkt.PacketMsg.Data,
				})

			// In case of incomplete message
			if !pkt.PacketMsg.EOF {
				log.Debug("TMCore -> Connector partial ", byte(pkt.PacketMsg.ChannelID))
				break
			}

			// Reach here only in case message has EOF. At this point the previous
			// messages are in h.channelBuffer[channel-idx]
			switch byte(pkt.PacketMsg.ChannelID) {
			case channelBc:
				h.throughput.putInfo("from", "=BcMSG", 1)
				log.Debug("TMCore -> Connector Blockhain is not serviced")
				h.channelBuffer[channelBc] = h.channelBuffer[channelBc][:0]
			case channelCsSt:
				log.Debug("TMCore -> Connector CsSt servicing")
				submessage, err := h.serviceConsensusStateMessage()
				if err != nil {
					log.Warning("Could not service consensus state message due to err: ", err)
				}
				h.throughput.putInfo("from", submessage, 1)
				h.channelBuffer[channelCsSt] = h.channelBuffer[channelCsSt][:0]
			case channelCsDc:
				log.Debug("TMCore -> Connector CsDc servicing")
				submessage, err := h.serviceConsensusDataMessage()
				if err != nil {
					log.Warning("Could not service consensus data message due to err: ", err)
				}
				h.throughput.putInfo("from", submessage, 1)
				h.channelBuffer[channelCsDc] = h.channelBuffer[channelCsDc][:0]
			case channelCsVo:
				log.Debug("TMCore -> Connector CsDo servicing")
				submessage, err := h.serviceConsensusVoteMessage()
				if err != nil {
					log.Warning("Could not service consensus vote message due to err: ", err)
				}
				h.throughput.putInfo("from", submessage, 1)
				h.channelBuffer[channelCsVo] = h.channelBuffer[channelCsVo][:0]
			case channelCsVs:
				h.throughput.putInfo("from", "=CsVsVSB", 1)
				log.Debug("TMCore -> Connector Consensus Vote Set Bits Channel is not serviced")
				h.channelBuffer[channelCsVs] = h.channelBuffer[channelCsVs][:0]
			case channelMm:
				h.throughput.putInfo("from", "=MmMSG", 1)
				log.Debug("TMCore -> Connector Mempool Channel is not serviced")
				h.channelBuffer[channelMm] = h.channelBuffer[channelMm][:0]
			case channelEv:
				h.throughput.putInfo("from", "=EvMSG", 1)
				log.Debug("TMCore -> Connector Evidence Channel is not serviced")
				h.channelBuffer[channelEv] = h.channelBuffer[channelEv][:0]
			default:
				h.throughput.putInfo("from", "=UnkUNK", 1)
				log.Warning("TMCore -> Connector Unknown ChannelID Message recieved: ", pkt.PacketMsg.ChannelID)
				h.channelBuffer[byte(pkt.PacketMsg.ChannelID)] = h.channelBuffer[byte(pkt.PacketMsg.ChannelID)][:0]
			}
		}
	}

	// Cleanup
	close(h.p2pConnection.pong)
	for range h.p2pConnection.pong {
		// Drain
	}
}

func (h *TendermintHandler) getBytesFromChannelBuffer(chanbuf []marlinTypes.PacketMsg) []byte {
	var databuf []byte
	for _, pkt := range chanbuf {
		databuf = append(databuf, pkt.Bytes...)
	}
	return databuf
}

func (h *TendermintHandler) serviceConsensusStateMessage() (string, error) {
	ch := channelCsSt
	msgBytes := h.getBytesFromChannelBuffer(h.channelBuffer[ch])
	msg, err := decodeMsg(msgBytes)
	if err != nil {
		return "", err
	}

	switch msg.(type) {
	case *NewRoundStepMessage:
		message := marlinTypes.MarlinMessage{
			ChainID: h.servicedChainId,
			Channel: ch,
			Packets: h.channelBuffer[ch],
		}
		// Send to marlin side
		// select {
		// case h.marlinTo <- message:
		// default:
		// 	log.Warning("Too many messages in channel marlinTo. Dropping oldest messages")
		// 	_ = <-h.marlinTo
		// 	h.marlinTo <- message
		// }
		// Reflect Back NRS message to get CsVoVOT messages
		select {
		case h.marlinFrom <- message:
		default:
			log.Warning("Too many messages in channel marlinFrom. Dropping oldest messages")
			_ = <-h.marlinFrom
			h.marlinFrom <- message
		}
		return "-CsStNRS", nil
	case *Proposal:
		return "-CsStPRO", nil
	case *NewValidBlockMessage:
		log.Debug("Found NewValidBlock, not servicing")
		return "-CsStNVB", nil
	case *HasVoteMessage:
		log.Debug("Found HasVote, not servicing")
		return "-CsStHVM", nil
	case *VoteSetMaj23Message:
		log.Debug("Found SetMaj23, not servicing")
		return "-CsStM23", nil
	default:
		log.Warning("Unknown Consensus state message ", msg)
		return "-CsStXXX", nil
	}
}

func (h *TendermintHandler) serviceConsensusDataMessage() (string, error) {
	ch := channelCsDc
	msgBytes := h.getBytesFromChannelBuffer(h.channelBuffer[ch])
	msg, err := decodeMsg(msgBytes)
	if err != nil {
		return "", err
	}

	switch msg.(type) {
	case *ProposalMessage:
		h.cahcedDcProposal = msg.(*ProposalMessage)
		h.cachedDcProposalPacket = make([]marlinTypes.PacketMsg, 0)
		for _, pkt := range h.channelBuffer[ch] {
			h.cachedDcProposalPacket = append(h.cachedDcProposalPacket, pkt)
		}
		return "@CsDcPRO", nil
	case *ProposalPOLMessage:
		log.Debug("Found Proposal POL, not servicing")
		return "-CsDcPOL", nil
	case *BlockPartMessage:

		if h.cahcedDcProposal == nil || msg.(*BlockPartMessage).Height != h.cahcedDcProposal.Proposal.Height || msg.(*BlockPartMessage).Round != h.cahcedDcProposal.Proposal.Round {
			// log.Info("Cannot find the bpm match ", msg.(*BlockPartMessage).Height, msg.(*BlockPartMessage).Round)
			return "-CsDcBPM", nil
		}
		// log.Info("Found the bpm match ", msg.(*BlockPartMessage).Height, msg.(*BlockPartMessage).Round)
		message := marlinTypes.MarlinMessage{
			ChainID:  h.servicedChainId,
			Channel:  byte(0x90),
			Packets:  h.cachedDcProposalPacket,
			Packets2: h.channelBuffer[ch],
		}

		// log.Info("Sending an Ox90 message ", len(message.Packets), len(message.Packets2))
		// Send to marlin side
		select {
		case h.marlinTo <- message:
		default:
			log.Warning("Too many messages in channel marlinTo. Dropping oldest messages")
			_ = <-h.marlinTo
			h.marlinTo <- message
		}
		log.Debug("Found BlockPart, not servicing")
		return "+CsDcBPM", nil
	default:
		log.Warning("Unknown Consensus data message ", msg)
		return "-CsDcXXX", nil
	}
}

func (h *TendermintHandler) serviceConsensusVoteMessage() (string, error) {
	ch := channelCsVo
	msgBytes := h.getBytesFromChannelBuffer(h.channelBuffer[ch])
	msg, err := decodeMsg(msgBytes)
	if err != nil {
		return "", err
	}

	switch msg.(type) {
	case *VoteMessage:
		message := marlinTypes.MarlinMessage{
			ChainID: h.servicedChainId,
			Channel: ch,
			Packets: h.channelBuffer[ch],
		}
		// Send to marlin side
		select {
		case h.marlinTo <- message:
		default:
			log.Warning("Too many messages in channel marlinTo. Dropping oldest messages")
			_ = <-h.marlinTo
			h.marlinTo <- message
		}
		return "+CsVoVOT", nil
	default:
		log.Warning("Unknown Consensus vote message ", msg)
		return "-CsVoXXX", nil
	}
}

// ---------------------- KEY GENERATION INTERFACE -----------------------------

var ServicedKeyFile string = "cosmos"
var isKeyFileUsed, memoized bool
var keyFileLocation string

var privateKey ed25519.PrivKey

func AsSha256(o interface{}) string {
	h := sha256.New()
	h.Write([]byte(fmt.Sprintf("%v", o)))

	return fmt.Sprintf("%x", h.Sum(nil))
}

func GenerateKeyFile(fileLocation string) {
	log.Info("Generating KeyPair for cosmoshub-4-mainnet")

	privateKey := ed25519.GenPrivKey()
	publicKey := privateKey.PubKey()

	key := keyData{
		Chain:      "cosmoshub-4-mainnet",
		IdString:   string(hex.EncodeToString(publicKey.Address())),
		PrivateKey: privateKey.Bytes(),
		PublicKey:  publicKey.Bytes(),
		Integrity:  "",
	}

	key.Integrity = AsSha256(key)

	log.Info("ID for node after generating KeyPair: ", key.IdString)

	encodedJson, err := json.MarshalIndent(&key, "", "    ")
	if err != nil {
		log.Error("Error generating KeyFile: ", err)
	}
	err = ioutil.WriteFile(fileLocation, encodedJson, 0644)
	if err != nil {
		log.Error("Error generating KeyFile: ", err)
	}

	log.Info("Successfully written keyfile ", fileLocation)
}

func VerifyKeyFile(fileLocation string) (bool, error) {
	log.Info("Accessing disk to extract info from KeyFile: ", fileLocation)
	jsonFile, err := os.Open(fileLocation)
	// if we os.Open returns an error then handle it
	if err != nil {
		log.Error("Error accessing file KeyFile: ", fileLocation, " error: ", err, ". exiting application.")
		os.Exit(1)
	}
	defer jsonFile.Close()

	byteValue, err := ioutil.ReadAll(jsonFile)
	if err != nil {
		log.Error("Error decoding KeyFile: ", fileLocation, " error: ", err, ". exiting application.")
		os.Exit(1)
	}
	var key keyData
	json.Unmarshal(byteValue, &key)

	integrity := key.Integrity
	key.Integrity = ""

	if key.Chain == "cosmoshub-4-mainnet" && integrity == AsSha256(key) {
		log.Info("Integrity for KeyFile: ", fileLocation, " checked. Integrity OK.")
		return true, nil
	} else {
		log.Error("Integrity for KeyFile: ", fileLocation, " checked. Integrity NOT OK.")
		return false, nil
	}
}

// ---------------------- COMMON UTILITIES ---------------------------------

func createTMHandler(peerAddr string,
	rpcAddr string,
	marlinTo chan marlinTypes.MarlinMessage,
	marlinFrom chan marlinTypes.MarlinMessage,
	isConnectionOutgoing bool,
	listenPort int,
	isDataConnect bool) (TendermintHandler, error) {
	chainId, ok := marlinTypes.ServicedChains["cosmoshub-4-mainnet"]
	if !ok {
		return TendermintHandler{}, errors.New("Cannot find cosmos in list of serviced chains by marlin connector")
	}

	privateKey := getPrivateKey()

	vCache, err := lru.New2Q(500)
	if err != nil {
		return TendermintHandler{}, err
	}

	return TendermintHandler{
		servicedChainId:      chainId,
		listenPort:           listenPort,
		isConnectionOutgoing: isConnectionOutgoing,
		peerAddr:             peerAddr,
		rpcAddr:              rpcAddr,
		privateKey:           privateKey,
		// codec:                amino.NewCodec(),
		validatorCache: vCache,
		marlinTo:       marlinTo,
		marlinFrom:     marlinFrom,
		channelBuffer:  make(map[byte][]marlinTypes.PacketMsg),
		proposerCache:  make(map[int64]Validator),
		throughput: throughPutData{
			isDataConnect: isDataConnect,
			toTMCore:      make(map[string]uint32),
			fromTMCore:    make(map[string]uint32),
			spam:          make(map[string]uint32),
		},
		signalConnError:      make(chan struct{}, 1),
		signalShutSend:       make(chan struct{}, 1),
		signalShutRecv:       make(chan struct{}, 1),
		signalShutThroughput: make(chan struct{}, 1),
	}, nil
}

func getPrivateKey() ed25519.PrivKey {
	if !isKeyFileUsed {
		return ed25519.GenPrivKey()
	} else {
		if !memoized {
			valid, err := VerifyKeyFile(keyFileLocation)
			if err != nil {
				log.Error("Error verifying keyfile integrity: ", keyFileLocation)
				os.Exit(1)
			} else if !valid {
				os.Exit(1)
			}
			log.Info("Accessing disk to extract info from KeyFile: ", keyFileLocation)
			jsonFile, err := os.Open(keyFileLocation)
			// if we os.Open returns an error then handle it
			if err != nil {
				log.Error("Error accessing file KeyFile: ", keyFileLocation, " error: ", err, ". exiting application.")
				os.Exit(1)
			}
			defer jsonFile.Close()

			byteValue, err := ioutil.ReadAll(jsonFile)
			if err != nil {
				log.Error("Error decoding KeyFile: ", keyFileLocation, " error: ", err, ". exiting application.")
				os.Exit(1)
			}
			var key keyData
			json.Unmarshal(byteValue, &key)
			log.Info("Connector assumes for all connections henceforth the ID: ", key.IdString)
			privateKey = key.PrivateKey
			memoized = true
		}
		return privateKey
	}
}

func (t *throughPutData) putInfo(direction string, key string, count uint32) {
	t.mu.Lock()
	switch direction {
	case "to":
		t.toTMCore[key] = t.toTMCore[key] + count
	case "from":
		t.fromTMCore[key] = t.fromTMCore[key] + count
	case "spam":
		t.spam[key] = t.spam[key] + count
	}
	t.mu.Unlock()
}

func (t *throughPutData) presentThroughput(sec time.Duration, shutdownCh chan struct{}) {
	for {
		time.Sleep(sec * time.Second)

		select {
		case <-shutdownCh:
			return
		default:
		}
		t.mu.Lock()
		if t.isDataConnect {
			log.Info(fmt.Sprintf("[DataConnect stats] To TMCore %v\tFrom TMCore %v", t.toTMCore, t.fromTMCore))
		} else {
			log.Info(fmt.Sprintf("[SpamFilter stats] Served %v", t.spam))
		}
		t.toTMCore = make(map[string]uint32)
		t.fromTMCore = make(map[string]uint32)
		t.spam = make(map[string]uint32)
		t.mu.Unlock()
	}
}

//-----------------------------------------------------------------------------
// Messages

// Message is a message that can be sent and received on the Reactor
type Message interface {
	// ValidateBasic() error // No restrictions
}

func decodeMsg(bz []byte) (msg Message, err error) {
	pb := &tmcons.Message{}
	if err = proto.Unmarshal(bz, pb); err != nil {
		return msg, err
	}

	return MsgFromProto(pb)
}

// MsgFromProto takes a consensus proto message and returns the native go type
func MsgFromProto(msg *tmcons.Message) (Message, error) {
	if msg == nil {
		return nil, errors.New("consensus: nil message")
	}
	var pb Message

	switch msg := msg.Sum.(type) {
	case *tmcons.Message_NewRoundStep:
		rs, err := tmmath.SafeConvertUint8(int64(msg.NewRoundStep.Step))
		// deny message based on possible overflow
		if err != nil {
			return nil, fmt.Errorf("denying message due to possible overflow: %w", err)
		}
		pb = &NewRoundStepMessage{
			Height:                msg.NewRoundStep.Height,
			Round:                 msg.NewRoundStep.Round,
			Step:                  int8(rs),
			SecondsSinceStartTime: msg.NewRoundStep.SecondsSinceStartTime,
			LastCommitRound:       msg.NewRoundStep.LastCommitRound,
		}
	case *tmcons.Message_NewValidBlock:
		pbPartSetHeader, err := PartSetHeaderFromProto(&msg.NewValidBlock.BlockPartSetHeader)
		if err != nil {
			return nil, fmt.Errorf("parts to proto error: %w", err)
		}

		pbBits := new(bits.BitArray)
		pbBits.FromProto(msg.NewValidBlock.BlockParts)

		pb = &NewValidBlockMessage{
			Height:             msg.NewValidBlock.Height,
			Round:              msg.NewValidBlock.Round,
			BlockPartSetHeader: *pbPartSetHeader,
			BlockParts:         pbBits,
			IsCommit:           msg.NewValidBlock.IsCommit,
		}
	case *tmcons.Message_Proposal:
		pbP, err := ProposalFromProto(&msg.Proposal.Proposal)
		if err != nil {
			return nil, fmt.Errorf("proposal msg to proto error: %w", err)
		}

		pb = &ProposalMessage{
			Proposal: pbP,
		}
	case *tmcons.Message_ProposalPol:
		pbBits := new(bits.BitArray)
		pbBits.FromProto(&msg.ProposalPol.ProposalPol)
		pb = &ProposalPOLMessage{
			Height:           msg.ProposalPol.Height,
			ProposalPOLRound: msg.ProposalPol.ProposalPolRound,
			ProposalPOL:      pbBits,
		}
	case *tmcons.Message_BlockPart:
		parts, err := PartFromProto(&msg.BlockPart.Part)
		if err != nil {
			return nil, fmt.Errorf("blockpart msg to proto error: %w", err)
		}
		pb = &BlockPartMessage{
			Height: msg.BlockPart.Height,
			Round:  msg.BlockPart.Round,
			Part:   parts,
		}
	case *tmcons.Message_Vote:
		vote, err := VoteFromProto(msg.Vote.Vote)
		if err != nil {
			return nil, fmt.Errorf("vote msg to proto error: %w", err)
		}

		pb = &VoteMessage{
			Vote: vote,
		}
	case *tmcons.Message_HasVote:
		pb = &HasVoteMessage{
			Height: msg.HasVote.Height,
			Round:  msg.HasVote.Round,
			Type:   msg.HasVote.Type,
			Index:  msg.HasVote.Index,
		}
	case *tmcons.Message_VoteSetMaj23:
		bi, err := BlockIDFromProto(&msg.VoteSetMaj23.BlockID)
		if err != nil {
			return nil, fmt.Errorf("voteSetMaj23 msg to proto error: %w", err)
		}
		pb = &VoteSetMaj23Message{
			Height:  msg.VoteSetMaj23.Height,
			Round:   msg.VoteSetMaj23.Round,
			Type:    msg.VoteSetMaj23.Type,
			BlockID: *bi,
		}
	case *tmcons.Message_VoteSetBits:
		bi, err := BlockIDFromProto(&msg.VoteSetBits.BlockID)
		if err != nil {
			return nil, fmt.Errorf("voteSetBits msg to proto error: %w", err)
		}
		bits := new(bits.BitArray)
		bits.FromProto(&msg.VoteSetBits.Votes)

		pb = &VoteSetBitsMessage{
			Height:  msg.VoteSetBits.Height,
			Round:   msg.VoteSetBits.Round,
			Type:    msg.VoteSetBits.Type,
			BlockID: *bi,
			Votes:   bits,
		}
	default:
		return nil, fmt.Errorf("consensus: message not recognized: %T", msg)
	}

	// if err := pb.ValidateBasic(); err != nil {
	// 	return nil, err
	// }

	return pb, nil
}

// FromProto sets a protobuf PartSetHeader to the given pointer
func PartSetHeaderFromProto(ppsh *tmproto.PartSetHeader) (*PartSetHeader, error) {
	if ppsh == nil {
		return nil, errors.New("nil PartSetHeader")
	}
	psh := new(PartSetHeader)
	psh.Total = ppsh.Total
	psh.Hash = ppsh.Hash

	return psh, nil
}

// FromProto sets a protobuf BlockID to the given pointer.
// It returns an error if the block id is invalid.
func BlockIDFromProto(bID *tmproto.BlockID) (*BlockID, error) {
	if bID == nil {
		return nil, errors.New("nil BlockID")
	}

	blockID := new(BlockID)
	ph, err := PartSetHeaderFromProto(&bID.PartSetHeader)
	if err != nil {
		return nil, err
	}

	blockID.PartSetHeader = *ph
	blockID.Hash = bID.Hash

	return blockID, nil
}

// FromProto sets a protobuf Proposal to the given pointer.
// It returns an error if the proposal is invalid.
func ProposalFromProto(pp *tmproto.Proposal) (*Proposal, error) {
	if pp == nil {
		return nil, errors.New("nil proposal")
	}

	p := new(Proposal)

	blockID, err := BlockIDFromProto(&pp.BlockID)
	if err != nil {
		return nil, err
	}

	p.BlockID = *blockID
	p.Type = pp.Type
	p.Height = pp.Height
	p.Round = pp.Round
	p.POLRound = pp.PolRound
	p.Timestamp = pp.Timestamp
	p.Signature = pp.Signature

	return p, nil
}

func PartFromProto(pb *tmproto.Part) (*Part, error) {
	if pb == nil {
		return nil, errors.New("nil part")
	}

	part := new(Part)
	proof, err := merkle.ProofFromProto(&pb.Proof)
	if err != nil {
		return nil, err
	}
	part.Index = pb.Index
	part.Bytes = pb.Bytes
	part.Proof = *proof

	return part, nil
}

// FromProto converts a proto generetad type to a handwritten type
// return type, nil if everything converts safely, otherwise nil, error
func VoteFromProto(pv *tmproto.Vote) (*Vote, error) {
	if pv == nil {
		return nil, errors.New("nil vote")
	}

	blockID, err := BlockIDFromProto(&pv.BlockID)
	if err != nil {
		return nil, err
	}

	vote := new(Vote)
	vote.Type = pv.Type
	vote.Height = pv.Height
	vote.Round = pv.Round
	vote.BlockID = *blockID
	vote.Timestamp = pv.Timestamp
	vote.ValidatorAddress = pv.ValidatorAddress
	vote.ValidatorIndex = pv.ValidatorIndex
	vote.Signature = pv.Signature

	return vote, nil
}

//----------------------------------------
// Packet

// mustWrapPacket takes a packet kind (oneof) and wraps it in a tmp2p.Packet message.
func mustWrapPacket(pb proto.Message) *tmp2p.Packet {
	var msg tmp2p.Packet

	switch pb := pb.(type) {
	case *tmp2p.Packet: // already a packet
		msg = *pb
	case *tmp2p.PacketPing:
		msg = tmp2p.Packet{
			Sum: &tmp2p.Packet_PacketPing{
				PacketPing: pb,
			},
		}
	case *tmp2p.PacketPong:
		msg = tmp2p.Packet{
			Sum: &tmp2p.Packet_PacketPong{
				PacketPong: pb,
			},
		}
	case *tmp2p.PacketMsg:
		msg = tmp2p.Packet{
			Sum: &tmp2p.Packet_PacketMsg{
				PacketMsg: pb,
			},
		}
	default:
		panic(fmt.Errorf("unknown packet type %T", pb))
	}

	return &msg
}

// ---------------------- SPAM FILTER INTERFACE --------------------------------

// RunSpamFilter serves as the entry point for a TM Core handler when serving as a spamfilter
func RunSpamFilter(rpcAddr string,
	marlinTo chan marlinTypes.MarlinMessage,
	marlinFrom chan marlinTypes.MarlinMessage) {
	log.Info("Starting Cosmoshub-4 Tendermint SpamFilter")

	handler, err := createTMHandler("0.0.0.0:0", rpcAddr, marlinTo, marlinFrom, false, 0, false)
	if err != nil {
		log.Error("Error encountered while creating TM Handler: ", err)
		os.Exit(1)
	}

	marlin.AllowServicedChainMessages(handler.servicedChainId)

	coreCount := runtime.NumCPU()
	multiple := 2
	log.Info("Runtime found number of CPUs on machine to be ", coreCount, ". Hence, running ", multiple*coreCount, " spamfilter handlers.")

	for i := 0; i < multiple*coreCount; i++ {
		go handler.beginServicingSpamFilter(i)
	}

	handler.throughput.presentThroughput(5, handler.signalShutThroughput)
}

func (h *TendermintHandler) beginServicingSpamFilter(id int) {
	log.Info("Running TM side spam filter handler ", id)
	// Blocking all except CsVoVOT
	for marlinMsg := range h.marlinFrom {
		switch marlinMsg.Channel {
		case channelBc:
			h.throughput.putInfo("spam", "-CsBc", 1)
			log.Debug("TMCore <-> Marlin Blockhain is not serviced")
			h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
		case channelCsSt:
			msgBytes := h.getBytesFromChannelBuffer(marlinMsg.Packets)
			msg, err := decodeMsg(msgBytes)
			if err != nil {
				h.throughput.putInfo("spam", "-CsStUNK", uint32(len(marlinMsg.Packets)))
				h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
			} else {
				switch msg.(type) {
				case *NewRoundStepMessage:
					h.throughput.putInfo("spam", "+CsStNRS", uint32(len(marlinMsg.Packets)))
					h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
				default:
					h.throughput.putInfo("spam", "-CsStUNK", uint32(len(marlinMsg.Packets)))
					h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
				}
			}
		case channelCsVo:
			// log.Info("consensus vote")
			msgBytes := h.getBytesFromChannelBuffer(marlinMsg.Packets)
			msg, err := decodeMsg(msgBytes)
			if err != nil {
				h.throughput.putInfo("spam", "-CsVoUNK", uint32(len(marlinMsg.Packets)))
				h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
			} else {
				switch msg.(type) {
				case *VoteMessage:
					if h.thoroughMessageCheck(msg) {
						h.marlinTo <- h.spamVerdictMessage(marlinMsg, true)
						h.throughput.putInfo("spam", "+CsVoVOT", uint32(len(marlinMsg.Packets)))
					} else {
						h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
						h.throughput.putInfo("spam", "-CsVoVOT", uint32(len(marlinMsg.Packets)))
					}
				default:
					h.throughput.putInfo("spam", "-CsVoUNK", uint32(len(marlinMsg.Packets)))
					h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
				}
			}
		case channelCsDc:
			msgBytes := h.getBytesFromChannelBuffer(marlinMsg.Packets)
			msg, err := decodeMsg(msgBytes)
			if err != nil {
				h.throughput.putInfo("spam", "-CsDcUNK(bare)", uint32(len(marlinMsg.Packets)))
				h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
			} else {
				switch msg.(type) {
				case *ProposalMessage:
					h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
					h.throughput.putInfo("spam", "-CsDcPRO(bare)", uint32(len(marlinMsg.Packets)))
				case *BlockPartMessage:
					h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
					h.throughput.putInfo("spam", "-CsDcBPM(bare)", uint32(len(marlinMsg.Packets)))
				default:
					h.throughput.putInfo("spam", "-CsVoUNK", uint32(len(marlinMsg.Packets)))
					h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
				}
			}
		case byte(0x90):
			// Special case: here the Proposal message comes bundled with a block part message
			// log.Info("0x90 channel -- ", len(marlinMsg.Packets), len(marlinMsg.Packets2))
			msgBytes := h.getBytesFromChannelBuffer(marlinMsg.Packets)
			msg, err := decodeMsg(msgBytes)
			if err != nil {
				h.throughput.putInfo("spam", "-CsDcUNK", uint32(len(marlinMsg.Packets)))
				h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
			}
			// log.Info("here ", msg)
			msgBytes2 := h.getBytesFromChannelBuffer(marlinMsg.Packets2)
			msg2, err := decodeMsg(msgBytes2)
			if err != nil {
				h.throughput.putInfo("spam", "-CsDcUNK", uint32(len(marlinMsg.Packets2)))
				h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
			}
			// log.Info("here2 ", msg2)
			switch msg.(type) {
			case *ProposalMessage:
				switch msg2.(type) {
				case *BlockPartMessage:
					pro := msg.(*ProposalMessage)
					bpm := msg2.(*BlockPartMessage)

					if pro.Proposal.Height != bpm.Height || pro.Proposal.Round != bpm.Round {
						log.Info("PRO BPM height round mismatch")
						h.throughput.putInfo("spam", "-CsDcBPM", 1)
						h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
						break
					}

					val, ok := h.getProposerAtHeight(pro.Proposal.Height)
					if !ok {
						log.Info("error getting proposer at height")
						h.throughput.putInfo("spam", "-CsDcBPM", 1)
						h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
						break
					}

					p := pro.Proposal.ToProto()
					ok = val.PublicKey.VerifySignature(ProposalSignBytes("cosmoshub-4", p), pro.Proposal.Signature)
					if !ok {
						log.Info("PRO signature mismatch ", pro.Proposal.Height, pro.Proposal.Round, val.Address)
						h.throughput.putInfo("spam", "-CsDcBPM", 1)
						h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
						break
					}

					err := bpm.Part.Proof.Verify(pro.Proposal.BlockID.PartSetHeader.Hash, bpm.Part.Bytes)
					if err != nil {
						log.Info("PRO BPM merkle verification error")
						h.throughput.putInfo("spam", "-CsDcBPM", 1)
						h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
						break
					}

					h.throughput.putInfo("spam", "+CsDcBPM", 1)
					h.marlinTo <- h.spamVerdictMessage(marlinMsg, true)

				default:
					h.throughput.putInfo("spam", "-CsDcBPM", 1)
					h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
				}
			default:
				h.throughput.putInfo("spam", "-CsDcBPM", 1)
				h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
			}

		case channelCsVs:
			h.throughput.putInfo("spam", "-CsVs", 1)
			h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
			log.Debug("TMCore <-> Marlin Consensensus Vote Set Bits Channel is not serviced")
		case channelMm:
			h.throughput.putInfo("spam", "-CsMm", 1)
			h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
			log.Debug("TMCore <-> Marlin Mempool Channel is not serviced")
		case channelEv:
			h.throughput.putInfo("spam", "-CsEv", 1)
			h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
			log.Debug("TMCore <-> MarlinEvidence Channel is not serviced")
		default:
			h.throughput.putInfo("spam", "-UnkUNK", 1)
			h.marlinTo <- h.spamVerdictMessage(marlinMsg, false)
		}
	}
}

func (h *TendermintHandler) thoroughMessageCheck(msg Message) bool {
	switch msg.(type) {
	case *VoteMessage:
		if validator, ok := h.getValidators(msg.(*VoteMessage).Vote.Height); ok {
			vidx := msg.(*VoteMessage).Vote.ValidatorIndex
			vaddr := msg.(*VoteMessage).Vote.ValidatorAddress.String()
			if vidx >= int32(len(validator)) || vaddr != validator[vidx].Address ||
				!validator[vidx].PublicKey.VerifySignature(VoteSignBytes("cosmoshub-4", msg.(*VoteMessage).Vote.ToProto()), msg.(*VoteMessage).Vote.Signature) {
				return false
			}
			return true
		}
		return false
	case *BlockPartMessage:
		log.Info("Block part message: ", msg)
		// Cache hash verification, needs Proposal message support
		return false
	case *ProposalMessage:
		// log.Info("Block proposal message: ", msg)
		_, ok := h.getProposerAtHeight(msg.(ProposalMessage).Proposal.Height)
		if !ok {
			return false
		}

		// if _, ok := h.getValidators(msg.(*ProposalMessage).Proposal.Height); ok {
		// 	// Check signature, add to map so that BPM messages can be verified
		// 	return true
		// }
		return false
	default:
		return false
	}
}

func (h *TendermintHandler) getProposerAtHeight(height int64) (Validator, bool) {
	if val, ok := h.proposerCache[height]; ok {
		// Let clear some stuff from cache
		delete(h.proposerCache, height-10)

		return val, true
	}
	// Find stuff from RPC

	if validatorlist, ok := h.getValidators(height); ok {
		type ConsensusResponse struct {
			Result struct {
				RoundState struct {
					HeightRoundStep string `json:"height/round/step"`
					Proposer        struct {
						Address string `json:"address"`
						Index   int    `json:"index"`
					} `json:"proposer"`
				} `json:"round_state"`
			} `json:"result"`
		}

		response, err := http.Get("http://" + h.rpcAddr + "/consensus_state")
		if err != nil {
			log.Error("Error while sending request to get blockchain status")
			return Validator{}, false
		}

		bodyBytes, err := ioutil.ReadAll(response.Body)
		var jsonResult ConsensusResponse
		err = json.Unmarshal(bodyBytes, &jsonResult)
		if err != nil {
			log.Error("Undecodable response from rpc for next validator search")
			return Validator{}, false
		}
		response.Body.Close()

		heightString := strings.Split(jsonResult.Result.RoundState.HeightRoundStep, "/")[0]
		heightFromResponse, err := strconv.ParseInt(heightString, 10, 64)
		if heightFromResponse != height {
			log.Error("Cannot find height match. Not newest proposal")
			return Validator{}, false
		}

		candidateValidator := validatorlist[jsonResult.Result.RoundState.Proposer.Index]
		if strings.ToUpper(candidateValidator.Address) == jsonResult.Result.RoundState.Proposer.Address {
			return candidateValidator, true
		}

		for _, val := range validatorlist {
			if strings.ToUpper(val.Address) == jsonResult.Result.RoundState.Proposer.Address {
				return val, true
			}
		}

	}
	return Validator{}, false
}

func (h *TendermintHandler) getValidators(height int64) ([]Validator, bool) {
	if height+10 < h.maxValidHeight {
		// Don't service messages too old
		return []Validator{}, false
	} else if h.validatorCache.Contains(height) {
		value, ok := h.validatorCache.Get(height)
		return value.([]Validator), ok
	} else {
		var validatorSet []Validator
		// log.Info("Asked about height: ", height)
		for i := 1; i < 3; i++ {
			// log.Info(len(validatorSet), height)
			response, err := http.Get("http://" + h.rpcAddr + "/validators?height=" + strconv.Itoa((int)(height)) + "&per_page=100&page=" + strconv.Itoa((int)(i)))
			if err != nil {
				log.Error("Error while sending request to get validators at height: ", height, " err: ", err)
				return []Validator{}, false
			} else {
				bodyBytes, err := ioutil.ReadAll(response.Body)
				if err != nil {
					log.Error("Error while parsing request to get validators at height: ", height, " err: ", err)
					return []Validator{}, false
				}
				var jsonResult map[string]interface{}
				json.Unmarshal(bodyBytes, &jsonResult)
				// verify interface for errors
				if _, errorFieldFound := jsonResult["error"]; errorFieldFound {
					return []Validator{}, false
				}
				validatorInfo := jsonResult["result"].(map[string]interface{})["validators"].([]interface{})

				for _, v := range validatorInfo {
					if v.(map[string]interface{})["pub_key"].(map[string]interface{})["type"] != "tendermint/PubKeyEd25519" {
						log.Error("Not all keys of validators are tendermint/PubKeyEd25519. Cannot continue with this validator set from TMCore")
						return []Validator{}, false
					}
					decodedSlice, err := b64.StdEncoding.DecodeString(v.(map[string]interface{})["pub_key"].(map[string]interface{})["value"].(string))
					if err != nil {
						log.Error("Could not decode base64 pubkey")
						return []Validator{}, false
					}
					decodedArray := make(ed25519.PubKey, 32)
					// log.Info(decodedSlice[:32])
					for i := 0; i < 32; i++ {
						decodedArray[i] = decodedSlice[i]
					}
					validatorSet = append(validatorSet,
						Validator{
							PublicKey: decodedArray,
							Address:   v.(map[string]interface{})["address"].(string),
						})
				}
			}
			response.Body.Close()
		}
		// log.Info("ht ", height, " validator set ", len(validatorSet))
		h.validatorCache.Add(height, validatorSet)

		h.maxValidHeight = height
		return validatorSet, true
	}
}

func (h *TendermintHandler) spamVerdictMessage(msg marlinTypes.MarlinMessage, allow bool) marlinTypes.MarlinMessage {
	if allow {
		return marlinTypes.MarlinMessage{
			ChainID:  h.servicedChainId,
			Channel:  byte(0x01),
			PacketId: msg.PacketId,
		}
	} else {
		return marlinTypes.MarlinMessage{
			ChainID:  h.servicedChainId,
			Channel:  byte(0x00),
			PacketId: msg.PacketId,
		}
	}
}