Sync finalized headers on demand

relayer/chain/parachain/writer.go

@@ -16,7 +16,7 @@ import (
 )
 
 type ChainWriter interface {
-	BatchCall(ctx context.Context, extrinsic string, calls []interface{}) error
+	BatchCall(ctx context.Context, extrinsic []string, calls []interface{}) error
 	WriteToParachainAndRateLimit(ctx context.Context, extrinsicName string, payload ...interface{}) error
 	WriteToParachainAndWatch(ctx context.Context, extrinsicName string, payload ...interface{}) error
 	GetLastFinalizedHeaderState() (state.FinalizedHeader, error)
@@ -34,19 +34,16 @@ type ParachainWriter struct {
 	pool                 *ExtrinsicPool
 	genesisHash          types.Hash
 	maxWatchedExtrinsics int64
-	maxBatchCallSize     int64
 	mu                   sync.Mutex
 }
 
 func NewParachainWriter(
 	conn *Connection,
 	maxWatchedExtrinsics int64,
-	maxBatchCallSize int64,
 ) *ParachainWriter {
 	return &ParachainWriter{
 		conn:                 conn,
 		maxWatchedExtrinsics: maxWatchedExtrinsics,
-		maxBatchCallSize:     maxBatchCallSize,
 	}
 }
 
@@ -69,8 +66,8 @@ func (wr *ParachainWriter) Start(ctx context.Context, eg *errgroup.Group) error
 	return nil
 }
 
-func (wr *ParachainWriter) BatchCall(ctx context.Context, extrinsic string, calls []interface{}) error {
-	batchSize := int(wr.maxBatchCallSize)
+func (wr *ParachainWriter) BatchCall(ctx context.Context, extrinsic []string, calls []interface{}) error {
+	batchSize := int(wr.maxWatchedExtrinsics)
 	var j int
 	for i := 0; i < len(calls); i += batchSize {
 		j += batchSize
@@ -80,13 +77,13 @@ func (wr *ParachainWriter) BatchCall(ctx context.Context, extrinsic string, call
 		slicedCalls := append([]interface{}{}, calls[i:j]...)
 		encodedCalls := make([]types.Call, len(slicedCalls))
 		for k := range slicedCalls {
-			call, err := wr.prepCall(extrinsic, slicedCalls[k])
+			call, err := wr.prepCall(extrinsic[k], slicedCalls[k])
 			if err != nil {
 				return err
 			}
 			encodedCalls[k] = *call
 		}
-		err := wr.WriteToParachainAndRateLimit(ctx, "Utility.batch_all", encodedCalls)
+		err := wr.WriteToParachainAndWatch(ctx, "Utility.batch_all", encodedCalls)
 		if err != nil {
 			return fmt.Errorf("batch call failed: %w", err)
 		}

relayer/cmd/import_execution_header.go

@@ -101,7 +101,7 @@ func importExecutionHeaderFn(cmd *cobra.Command, _ []string) error {
 			return fmt.Errorf("connect to parachain: %w", err)
 		}
 
-		writer := parachain.NewParachainWriter(paraconn, 8, 8)
+		writer := parachain.NewParachainWriter(paraconn, 8)
 		err = writer.Start(ctx, eg)
 		if err != nil {
 			return fmt.Errorf("start parachain conn: %w", err)

relayer/cmd/run/beacon/command.go

@@ -2,6 +2,7 @@ package beacon
 
 import (
 	"context"
+	"fmt"
 	"log"
 	"os"
 	"os/signal"
@@ -54,11 +55,16 @@ func run(_ *cobra.Command, _ []string) error {
 	}
 
 	var config config.Config
-	err := viper.Unmarshal(&config)
+	err := viper.UnmarshalExact(&config)
 	if err != nil {
 		return err
 	}
 
+	err = config.Validate()
+	if err != nil {
+		return fmt.Errorf("config file validation failed: %w", err)
+	}
+
 	keypair, err := parachain.ResolvePrivateKey(privateKey, privateKeyFile, privateKeyID)
 	if err != nil {
 		return err

relayer/cmd/run/beefy/command.go

@@ -2,6 +2,7 @@ package beefy
 
 import (
 	"context"
+	"fmt"
 	"log"
 	"os"
 	"os/signal"
@@ -50,11 +51,16 @@ func run(_ *cobra.Command, _ []string) error {
 	}
 
 	var config beefy.Config
-	err := viper.Unmarshal(&config)
+	err := viper.UnmarshalExact(&config)
 	if err != nil {
 		return err
 	}
 
+	err = config.Validate()
+	if err != nil {
+		return fmt.Errorf("config file validation failed: %w", err)
+	}
+
 	keypair, err := ethereum.ResolvePrivateKey(privateKey, privateKeyFile, privateKeyID)
 	if err != nil {
 		return err

relayer/cmd/run/execution/command.go

@@ -3,6 +3,7 @@ package execution
 import (
 	"context"
 	"encoding/hex"
+	"fmt"
 	"log"
 	"os"
 	"os/signal"
@@ -41,7 +42,6 @@ func Command() *cobra.Command {
 	cmd.Flags().StringVar(&privateKeyFile, "substrate.private-key-file", "", "The file from which to read the private key URI")
 	cmd.Flags().StringVar(&privateKeyID, "substrate.private-key-id", "", "The secret id to lookup the private key in AWS Secrets Manager")
 
-
 	return cmd
 }
 
@@ -57,11 +57,16 @@ func run(_ *cobra.Command, _ []string) error {
 	}
 
 	var config execution.Config
-	err := viper.Unmarshal(&config, viper.DecodeHook(HexHookFunc()))
+	err := viper.UnmarshalExact(&config, viper.DecodeHook(HexHookFunc()))
 	if err != nil {
 		return err
 	}
 
+	err = config.Validate()
+	if err != nil {
+		return fmt.Errorf("config file validation failed: %w", err)
+	}
+
 	keypair, err := parachain.ResolvePrivateKey(privateKey, privateKeyFile, privateKeyID)
 	if err != nil {
 		return err

relayer/cmd/run/parachain/command.go

@@ -3,6 +3,7 @@ package parachain
 import (
 	"context"
 	"encoding/hex"
+	"fmt"
 	"log"
 	"os"
 	"os/signal"
@@ -41,7 +42,6 @@ func Command() *cobra.Command {
 	cmd.Flags().StringVar(&privateKeyFile, "ethereum.private-key-file", "", "The file from which to read the private key")
 	cmd.Flags().StringVar(&privateKeyID, "ethereum.private-key-id", "", "The secret id to lookup the private key in AWS Secrets Manager")
 
-
 	return cmd
 }
 
@@ -55,11 +55,16 @@ func run(_ *cobra.Command, _ []string) error {
 	}
 
 	var config parachain.Config
-	err := viper.Unmarshal(&config, viper.DecodeHook(HexHookFunc()))
+	err := viper.UnmarshalExact(&config, viper.DecodeHook(HexHookFunc()))
 	if err != nil {
 		return err
 	}
 
+	err = config.Validate()
+	if err != nil {
+		return fmt.Errorf("config file validation failed: %w", err)
+	}
+
 	keypair, err := ethereum.ResolvePrivateKey(privateKey, privateKeyFile, privateKeyID)
 	if err != nil {
 		return err

relayer/config/config.go

@@ -1,13 +1,14 @@
 package config
 
+import "errors"
+
 type PolkadotConfig struct {
 	Endpoint string `mapstructure:"endpoint"`
 }
 
 type ParachainConfig struct {
 	Endpoint             string `mapstructure:"endpoint"`
 	MaxWatchedExtrinsics int64  `mapstructure:"maxWatchedExtrinsics"`
-	MaxBatchCallSize     int64  `mapstructure:"maxBatchCallSize"`
 }
 
 type EthereumConfig struct {
@@ -16,3 +17,27 @@ type EthereumConfig struct {
 	GasTipCap uint64 `mapstructure:"gas-tip-cap"`
 	GasLimit  uint64 `mapstructure:"gas-limit"`
 }
+
+func (p ParachainConfig) Validate() error {
+	if p.Endpoint == "" {
+		return errors.New("[endpoint] is not set")
+	}
+	if p.MaxWatchedExtrinsics == 0 {
+		return errors.New("[maxWatchedExtrinsics] is not set")
+	}
+	return nil
+}
+
+func (e EthereumConfig) Validate() error {
+	if e.Endpoint == "" {
+		return errors.New("[endpoint] config is not set")
+	}
+	return nil
+}
+
+func (p PolkadotConfig) Validate() error {
+	if p.Endpoint == "" {
+		return errors.New("[endpoint] config is not set")
+	}
+	return nil
+}

relayer/relays/beacon/config/config.go

@@ -1,6 +1,8 @@
 package config
 
 import (
+	"errors"
+	"fmt"
 	"github.com/snowfork/snowbridge/relayer/config"
 )
 
@@ -33,5 +35,49 @@ type BeaconConfig struct {
 }
 
 type SinkConfig struct {
-	Parachain config.ParachainConfig `mapstructure:"parachain"`
+	Parachain          config.ParachainConfig `mapstructure:"parachain"`
+	UpdateSlotInterval uint64                 `mapstructure:"updateSlotInterval"`
+}
+
+func (c Config) Validate() error {
+	err := c.Source.Beacon.Validate()
+	if err != nil {
+		return fmt.Errorf("source beacon config: %w", err)
+	}
+	err = c.Sink.Parachain.Validate()
+	if err != nil {
+		return fmt.Errorf("sink parachain config: %w", err)
+	}
+	if c.Sink.UpdateSlotInterval == 0 {
+		return errors.New("parachain [updateSlotInterval] config is not set")
+	}
+	return nil
+}
+
+func (b BeaconConfig) Validate() error {
+	// spec settings
+	if b.Spec.EpochsPerSyncCommitteePeriod == 0 {
+		return errors.New("source beacon setting [epochsPerSyncCommitteePeriod] is not set")
+	}
+	if b.Spec.SlotsInEpoch == 0 {
+		return errors.New("source beacon setting [slotsInEpoch] is not set")
+	}
+	if b.Spec.SyncCommitteeSize == 0 {
+		return errors.New("source beacon setting [syncCommitteeSize] is not set")
+	}
+	// data store
+	if b.DataStore.Location == "" {
+		return errors.New("source beacon datastore [location] is not set")
+	}
+	if b.DataStore.MaxEntries == 0 {
+		return errors.New("source beacon datastore [maxEntries] is not set")
+	}
+	// api endpoints
+	if b.Endpoint == "" {
+		return errors.New("source beacon setting [endpoint] is not set")
+	}
+	if b.StateEndpoint == "" {
+		return errors.New("source beacon setting [stateEndpoint] is not set")
+	}
+	return nil
 }