Merge branch 'main' into fix/non-adjacent-light-client

cmd/root.go

@@ -22,8 +22,10 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"net/url"
 	"os"
 	"os/signal"
+	"path"
 	"path/filepath"
 	"runtime/debug"
 	"strings"
@@ -34,6 +36,7 @@ import (
 	"github.com/spf13/viper"
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
+	"gopkg.in/natefinch/lumberjack.v2"
 )
 
 const appName = "rly"
@@ -171,13 +174,32 @@ func Execute() {
 	}
 }
 
+type lumberjackSink struct {
+	*lumberjack.Logger
+}
+
+func (lumberjackSink) Sync() error { return nil }
+
 func newRootLogger(format string, debug bool) (*zap.Logger, error) {
 	config := zap.NewProductionEncoderConfig()
 	config.EncodeTime = func(ts time.Time, encoder zapcore.PrimitiveArrayEncoder) {
 		encoder.AppendString(ts.UTC().Format("2006-01-02T15:04:05.000000Z07:00"))
 	}
 	config.LevelKey = "lvl"
 
+	ll := lumberjack.Logger{
+		Filename:   path.Join(defaultHome, "relay.log"),
+		MaxSize:    50, //MB
+		MaxBackups: 30,
+		MaxAge:     28, //days
+		Compress:   true,
+	}
+	zap.RegisterSink("lumberjack", func(*url.URL) (zap.Sink, error) {
+		return lumberjackSink{
+			Logger: &ll,
+		}, nil
+	})
+
 	var enc zapcore.Encoder
 	switch format {
 	case "json":
@@ -195,15 +217,13 @@ func newRootLogger(format string, debug bool) (*zap.Logger, error) {
 		level = zap.DebugLevel
 	}
 
-	logFile, _ := os.OpenFile("log.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
-	writer := zapcore.AddSync(logFile)
+	w := zapcore.AddSync(&ll)
 
 	core := zapcore.NewTee(
-		zapcore.NewCore(enc,
-			writer,
-			level),
+		zapcore.NewCore(enc, w, level),
 		zapcore.NewCore(enc, os.Stderr, level),
 	)
+
 	return zap.New(core), nil
 }
 

cmd/tx.go

@@ -105,6 +105,8 @@ func createClientsCmd(a *appState) *cobra.Command {
 				return fmt.Errorf("key %s not found on dst chain %s", c[dst].ChainProvider.Key(), c[dst].ChainID())
 			}
 
+			// TODO: make iconStartHeight compulsory
+			// if iconStartHeight is not given it can create confusion as starting relay at any time could miss number of btp block update_client
 			clientSrc, clientDst, err := c[src].CreateClients(cmd.Context(), c[dst], allowUpdateAfterExpiry, allowUpdateAfterMisbehaviour, override, customClientTrustingPeriod, a.config.memo(cmd), iconStartHeight)
 			if err != nil {
 				return err
@@ -335,6 +337,7 @@ func upgradeClientsCmd(a *appState) *cobra.Command {
 	return cmd
 }
 
+// TODO: method has side_effect
 func createConnectionCmd(a *appState) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:     "connection path_name",

relayer/chains/archway/archway_chain_processor.go

@@ -1,6 +1,7 @@
 package archway
 
 import (
+	"bytes"
 	"context"
 	"errors"
 	"fmt"
@@ -16,6 +17,7 @@ import (
 	"github.com/cosmos/relayer/v2/relayer/provider"
 
 	ctypes "github.com/cometbft/cometbft/rpc/core/types"
+	"github.com/cometbft/cometbft/types"
 	"go.uber.org/zap"
 	"golang.org/x/sync/errgroup"
 )
@@ -53,6 +55,12 @@ type ArchwayChainProcessor struct {
 
 	// parsed gas prices accepted by the chain (only used for metrics)
 	parsedGasPrices *sdk.DecCoins
+
+	verifier *Verifier
+}
+
+type Verifier struct {
+	Header *types.LightBlock
 }
 
 func NewArchwayChainProcessor(log *zap.Logger, provider *ArchwayProvider, metrics *processor.PrometheusMetrics) *ArchwayChainProcessor {
@@ -74,6 +82,7 @@ const (
 	latestHeightQueryRetryDelay = 1 * time.Second
 	latestHeightQueryRetries    = 5
 
+	// TODO: review transfer to providerConfig
 	defaultMinQueryLoopDuration      = 1 * time.Second
 	defaultBalanceUpdateWaitDuration = 60 * time.Second
 	inSyncNumBlocksThreshold         = 2
@@ -214,7 +223,6 @@ func (ccp *ArchwayChainProcessor) Run(ctx context.Context, initialBlockHistory u
 			continue
 		}
 		persistence.latestHeight = status.SyncInfo.LatestBlockHeight
-		// ccp.chainProvider.setCometVersion(ccp.log, status.NodeInfo.Version)
 		break
 	}
 
@@ -227,6 +235,19 @@ func (ccp *ArchwayChainProcessor) Run(ctx context.Context, initialBlockHistory u
 
 	persistence.latestQueriedBlock = latestQueriedBlock
 
+	_, lightBlock, err := ccp.chainProvider.QueryLightBlock(ctx, persistence.latestQueriedBlock)
+	if err != nil {
+		ccp.log.Error("Failed to get ibcHeader",
+			zap.Int64("height", persistence.latestQueriedBlock),
+			zap.Any("error", err),
+		)
+		return err
+	}
+
+	ccp.verifier = &Verifier{
+		Header: lightBlock,
+	}
+
 	var eg errgroup.Group
 	eg.Go(func() error {
 		return ccp.initializeConnectionState(ctx)
@@ -238,7 +259,7 @@ func (ccp *ArchwayChainProcessor) Run(ctx context.Context, initialBlockHistory u
 		return err
 	}
 
-	ccp.log.Debug("Entering main query loop")
+	ccp.log.Debug("Entering Archway main query loop")
 
 	ticker := time.NewTicker(persistence.minQueryLoopDuration)
 	defer ticker.Stop()
@@ -305,6 +326,7 @@ func (ccp *ArchwayChainProcessor) initializeChannelState(ctx context.Context) er
 }
 
 func (ccp *ArchwayChainProcessor) queryCycle(ctx context.Context, persistence *queryCyclePersistence) error {
+	// TODO : review if redundent remove
 	status, err := ccp.nodeStatusWithRetry(ctx)
 	if err != nil {
 		// don't want to cause ArchwayChainProcessor to quit here, can retry again next cycle.
@@ -344,21 +366,20 @@ func (ccp *ArchwayChainProcessor) queryCycle(ctx context.Context, persistence *q
 	}
 
 	ibcMessagesCache := processor.NewIBCMessagesCache()
-
 	ibcHeaderCache := make(processor.IBCHeaderCache)
 
 	ppChanged := false
 
-	var latestHeader ArchwayIBCHeader
-
 	newLatestQueriedBlock := persistence.latestQueriedBlock
-
 	chainID := ccp.chainProvider.ChainId()
+	var latestHeader provider.IBCHeader
 
+	// TODO review: max block sync
+	//
 	for i := persistence.latestQueriedBlock + 1; i <= persistence.latestHeight; i++ {
 		var eg errgroup.Group
 		var blockRes *ctypes.ResultBlockResults
-		var ibcHeader provider.IBCHeader
+		var lightBlock *types.LightBlock
 		i := i
 		eg.Go(func() (err error) {
 			queryCtx, cancelQueryCtx := context.WithTimeout(ctx, blockResultsQueryTimeout)
@@ -370,7 +391,7 @@ func (ccp *ArchwayChainProcessor) queryCycle(ctx context.Context, persistence *q
 		eg.Go(func() (err error) {
 			queryCtx, cancelQueryCtx := context.WithTimeout(ctx, queryTimeout)
 			defer cancelQueryCtx()
-			ibcHeader, err = ccp.chainProvider.QueryIBCHeader(queryCtx, i)
+			latestHeader, lightBlock, err = ccp.chainProvider.QueryLightBlock(queryCtx, i)
 			return err
 		})
 
@@ -379,13 +400,18 @@ func (ccp *ArchwayChainProcessor) queryCycle(ctx context.Context, persistence *q
 			break
 		}
 
-		latestHeader = ibcHeader.(ArchwayIBCHeader)
+		if err := ccp.Verify(ctx, lightBlock); err != nil {
+			ccp.log.Error("failed to Verify Archway Header", zap.Int64("Height", blockRes.Height))
+			return err
+		}
+
+		ccp.log.Debug("Verified block ",
+			zap.Int64("height", lightBlock.Header.Height))
 
 		heightUint64 := uint64(i)
 
 		ccp.latestBlock = provider.LatestBlock{
 			Height: heightUint64,
-			// Time:   latestHeader.SignedHeader.Header.Time,
 		}
 
 		ibcHeaderCache[heightUint64] = latestHeader
@@ -451,6 +477,8 @@ func (ccp *ArchwayChainProcessor) queryCycle(ctx context.Context, persistence *q
 	return nil
 }
 
+// TODO: review add verifier
+
 func (ccp *ArchwayChainProcessor) CollectMetrics(ctx context.Context, persistence *queryCyclePersistence) {
 	ccp.CurrentBlockHeight(ctx, persistence)
 
@@ -465,6 +493,87 @@ func (ccp *ArchwayChainProcessor) CurrentBlockHeight(ctx context.Context, persis
 	ccp.metrics.SetLatestHeight(ccp.chainProvider.ChainId(), persistence.latestHeight)
 }
 
+func (ccp *ArchwayChainProcessor) Verify(ctx context.Context, untrusted *types.LightBlock) error {
+
+	if untrusted.Height != ccp.verifier.Header.Height+1 {
+		return errors.New("headers must be adjacent in height")
+	}
+
+	if err := verifyNewHeaderAndVals(untrusted.SignedHeader,
+		untrusted.ValidatorSet,
+		ccp.verifier.Header.SignedHeader,
+		time.Now(), 0); err != nil {
+		return fmt.Errorf("Failed to verify Header: %v", err)
+	}
+
+	if !bytes.Equal(untrusted.Header.ValidatorsHash, ccp.verifier.Header.NextValidatorsHash) {
+		err := fmt.Errorf("expected old header next validators (%X) to match those from new header (%X)",
+			ccp.verifier.Header.NextValidatorsHash,
+			untrusted.Header.ValidatorsHash,
+		)
+		return err
+	}
+
+	if !bytes.Equal(untrusted.Header.LastBlockID.Hash.Bytes(), ccp.verifier.Header.Commit.BlockID.Hash.Bytes()) {
+		err := fmt.Errorf("expected LastBlockId Hash (%X) of current header  to match those from trusted Header BlockID hash (%X)",
+			ccp.verifier.Header.NextValidatorsHash,
+			untrusted.Header.ValidatorsHash,
+		)
+		return err
+	}
+
+	// Ensure that +2/3 of new validators signed correctly.
+	if err := untrusted.ValidatorSet.VerifyCommitLight(ccp.verifier.Header.ChainID, untrusted.Commit.BlockID,
+		untrusted.Header.Height, untrusted.Commit); err != nil {
+		return fmt.Errorf("invalid header: %v", err)
+	}
+
+	ccp.verifier.Header = untrusted
+	return nil
+
+}
+
+func verifyNewHeaderAndVals(
+	untrustedHeader *types.SignedHeader,
+	untrustedVals *types.ValidatorSet,
+	trustedHeader *types.SignedHeader,
+	now time.Time,
+	maxClockDrift time.Duration) error {
+
+	if err := untrustedHeader.ValidateBasic(trustedHeader.ChainID); err != nil {
+		return fmt.Errorf("untrustedHeader.ValidateBasic failed: %w", err)
+	}
+
+	if untrustedHeader.Height <= trustedHeader.Height {
+		return fmt.Errorf("expected new header height %d to be greater than one of old header %d",
+			untrustedHeader.Height,
+			trustedHeader.Height)
+	}
+
+	if !untrustedHeader.Time.After(trustedHeader.Time) {
+		return fmt.Errorf("expected new header time %v to be after old header time %v",
+			untrustedHeader.Time,
+			trustedHeader.Time)
+	}
+
+	if !untrustedHeader.Time.Before(now.Add(maxClockDrift)) {
+		return fmt.Errorf("new header has a time from the future %v (now: %v; max clock drift: %v)",
+			untrustedHeader.Time,
+			now,
+			maxClockDrift)
+	}
+
+	if !bytes.Equal(untrustedHeader.ValidatorsHash, untrustedVals.Hash()) {
+		return fmt.Errorf("expected new header validators (%X) to match those that were supplied (%X) at height %d",
+			untrustedHeader.ValidatorsHash,
+			untrustedVals.Hash(),
+			untrustedHeader.Height,
+		)
+	}
+
+	return nil
+}
+
 // func (ccp *ArchwayChainProcessor) CurrentRelayerBalance(ctx context.Context) {
 // 	// memoize the current gas prices to only show metrics for "interesting" denoms
 // 	if ccp.parsedGasPrices == nil {

relayer/chains/archway/keys.go

@@ -59,7 +59,7 @@ func (cc *ArchwayProvider) KeystoreCreated(path string) bool {
 // AddKey generates a new mnemonic which is then converted to a private key and BIP-39 HD Path and persists it to the keystore.
 // It fails if there is an existing key with the same address.
 func (cc *ArchwayProvider) AddKey(name string, coinType uint32, signingAlgorithm string) (output *provider.KeyOutput, err error) {
-	ko, err := cc.KeyAddOrRestore(name, coinType, signingAlgorithm)
+	ko, err := cc.KeyAddOrRestore(name, coinType)
 	if err != nil {
 		return nil, err
 	}

relayer/chains/archway/query.go

@@ -135,6 +135,18 @@ func (ap *ArchwayProvider) QueryIBCHeader(ctx context.Context, h int64) (provide
 	return NewArchwayIBCHeaderFromLightBlock(lightBlock), nil
 }
 
+func (ap *ArchwayProvider) QueryLightBlock(ctx context.Context, h int64) (provider.IBCHeader, *tmtypes.LightBlock, error) {
+	if h == 0 {
+		return nil, nil, fmt.Errorf("No header at height 0")
+	}
+	lightBlock, err := ap.LightProvider.LightBlock(ctx, h)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return NewArchwayIBCHeaderFromLightBlock(lightBlock), lightBlock, nil
+}
+
 // query packet info for sequence
 func (ap *ArchwayProvider) QuerySendPacket(ctx context.Context, srcChanID, srcPortID string, sequence uint64) (provider.PacketInfo, error) {
 	return provider.PacketInfo{}, fmt.Errorf("Not implemented for Archway")

relayer/chains/archway/tx.go

@@ -72,7 +72,8 @@ func (ap *ArchwayProvider) TxFactory() tx.Factory {
 		WithGasAdjustment(ap.PCfg.GasAdjustment).
 		WithGasPrices(ap.PCfg.GasPrices).
 		WithKeybase(ap.Keybase).
-		WithSignMode(ap.PCfg.SignMode())
+		WithSignMode(ap.PCfg.SignMode()).
+		WithSimulateAndExecute(true)
 }
 
 // PrepareFactory mutates the tx factory with the appropriate account number, sequence number, and min gas settings.
@@ -772,8 +773,9 @@ func (ap *ArchwayProvider) SendMessagesToMempool(
 		ap.updateNextAccountSequence(sequence + 1)
 	}
 
-	//TODO: comment this on production
-	SaveMsgToFile(ArchwayDebugMessagePath, msgs)
+	//uncomment for saving msg
+	// SaveMsgToFile(ArchwayDebugMessagePath, msgs)
+
 	return nil
 
 }

relayer/chains/icon/cryptoutils/merkle_proof.go

@@ -5,7 +5,6 @@ import (
 	"math/bits"
 
 	"github.com/cosmos/relayer/v2/relayer/chains/icon/types"
-
 	"github.com/cosmos/relayer/v2/relayer/common"
 	"github.com/icon-project/IBC-Integration/libraries/go/common/icon"
 )

relayer/chains/icon/event_parser.go

@@ -32,7 +32,9 @@ func (pi *packetInfo) parseAttrs(log *zap.Logger, event types.EventLog) {
 	packetData := event.Indexed[1]
 	var packet icon.Packet
 	if err := proto.Unmarshal(packetData, &packet); err != nil {
+
 		log.Error("failed to unmarshal packet")
+		// TODO: review return if parseAttrs add panic
 	}
 	pi.SourcePort = packet.SourcePort
 	pi.SourceChannel = packet.SourceChannel