Smoke test on westend (#1291)

* Initialize for westend

* Update beacon checkpoint

* add back in para threads

* fix out of bounds error

* Smoke tests on westend

* Load config from env

* Cleanup env

* Remove penpal code

* Cleanup

* Update smoke tests

* Add westend env

* crontab smoke tests

* Split as two tests

* Fix typo

* Remove assets/parachain non-exist

* Revert change

* Wait config from env

* Load interval from env

* Add alarm check no transfer

* Adds paseo UI (#1276)

* adds paseo UI

* remove muse and bump versions

* remove muse and bump versions

* remove veth token

* paseo things

* fix subscan urls

* revert version

* fix versions

* Update api package

* Fix the merge

* Remove unused

* Fix find on-chain checkpoint (#1294)

* fix wrap around

* logs

* doesnt have to be in the same period

* testing something

* fix

* adds test and config

* writer

* fix compilation

* remove temp building relayer

* comment

* bump version

---------

Co-authored-by: Alistair Singh <alistair.singh7@gmail.com>
Co-authored-by: Clara van Staden <claravanstaden64@gmail.com>

.github/workflows/release-relayer.yml

@@ -4,7 +4,6 @@ on:
   push:
     branches:
       - main
-      - release-v1.0.0
   workflow_dispatch:
 
 env:

relayer/cmd/generate_beacon_data.go

@@ -132,7 +132,7 @@ func generateBeaconCheckpoint(cmd *cobra.Command, _ []string) error {
 			return err
 		}
 
-		p := protocol.New(conf.Source.Beacon.Spec)
+		p := protocol.New(conf.Source.Beacon.Spec, conf.Sink.Parachain.HeaderRedundancy)
 		store := store.New(conf.Source.Beacon.DataStore.Location, conf.Source.Beacon.DataStore.MaxEntries, *p)
 		store.Connect()
 		defer store.Close()
@@ -193,7 +193,7 @@ func generateBeaconTestFixture(cmd *cobra.Command, _ []string) error {
 			return err
 		}
 
-		p := protocol.New(conf.Source.Beacon.Spec)
+		p := protocol.New(conf.Source.Beacon.Spec, conf.Sink.Parachain.HeaderRedundancy)
 
 		store := store.New(conf.Source.Beacon.DataStore.Location, conf.Source.Beacon.DataStore.MaxEntries, *p)
 		err = store.Connect()
@@ -504,7 +504,7 @@ func generateExecutionUpdate(cmd *cobra.Command, _ []string) error {
 		}
 		log.WithFields(log.Fields{"endpoint": conf.Source.Beacon.Endpoint}).Info("connecting to beacon API")
 
-		p := protocol.New(conf.Source.Beacon.Spec)
+		p := protocol.New(conf.Source.Beacon.Spec, conf.Sink.Parachain.HeaderRedundancy)
 
 		store := store.New(conf.Source.Beacon.DataStore.Location, conf.Source.Beacon.DataStore.MaxEntries, *p)
 		store.Connect()
@@ -695,7 +695,7 @@ func generateInboundFixture(cmd *cobra.Command, _ []string) error {
 			return err
 		}
 
-		p := protocol.New(beaconConf.Source.Beacon.Spec)
+		p := protocol.New(beaconConf.Source.Beacon.Spec, beaconConf.Sink.Parachain.HeaderRedundancy)
 
 		store := store.New(beaconConf.Source.Beacon.DataStore.Location, beaconConf.Source.Beacon.DataStore.MaxEntries, *p)
 		store.Connect()

relayer/cmd/import_beacon_state.go

@@ -71,7 +71,7 @@ func importBeaconState(cmd *cobra.Command, _ []string) error {
 		return fmt.Errorf("open finalized state file: %w", err)
 	}
 
-	p := protocol.New(conf.Source.Beacon.Spec)
+	p := protocol.New(conf.Source.Beacon.Spec, conf.Sink.Parachain.HeaderRedundancy)
 	store := store.New(conf.Source.Beacon.DataStore.Location, conf.Source.Beacon.DataStore.MaxEntries, *p)
 	beaconClient := api.NewBeaconClient(conf.Source.Beacon.Endpoint, conf.Source.Beacon.StateEndpoint)
 	syncer := syncer.New(beaconClient, &store, p)

relayer/cmd/import_execution_header.go

@@ -109,7 +109,7 @@ func importExecutionHeaderFn(cmd *cobra.Command, _ []string) error {
 
 		log.WithField("hash", beaconHeader).Info("will be syncing execution header for beacon hash")
 
-		p := protocol.New(conf.Source.Beacon.Spec)
+		p := protocol.New(conf.Source.Beacon.Spec, conf.Sink.Parachain.HeaderRedundancy)
 		store := store.New(conf.Source.Beacon.DataStore.Location, conf.Source.Beacon.DataStore.MaxEntries, *p)
 		store.Connect()
 		defer store.Close()

relayer/cmd/list_beacon_states.go

@@ -49,7 +49,7 @@ func listBeaconState(cmd *cobra.Command, _ []string) error {
 		return err
 	}
 
-	p := protocol.New(conf.Source.Beacon.Spec)
+	p := protocol.New(conf.Source.Beacon.Spec, conf.Sink.Parachain.HeaderRedundancy)
 	store := store.New(conf.Source.Beacon.DataStore.Location, conf.Source.Beacon.DataStore.MaxEntries, *p)
 
 	err = store.Connect()

relayer/cmd/store_beacon_state.go

@@ -49,7 +49,7 @@ func storeBeaconState(cmd *cobra.Command, _ []string) error {
 		return err
 	}
 
-	p := protocol.New(conf.Source.Beacon.Spec)
+	p := protocol.New(conf.Source.Beacon.Spec, conf.Sink.Parachain.HeaderRedundancy)
 	store := store.New(conf.Source.Beacon.DataStore.Location, conf.Source.Beacon.DataStore.MaxEntries, *p)
 	beaconClient := api.NewBeaconClient(conf.Source.Beacon.Endpoint, conf.Source.Beacon.StateEndpoint)
 	syncer := syncer.New(beaconClient, &store, p)

relayer/relays/beacon/config/config.go

@@ -3,7 +3,6 @@ package config
 import (
 	"errors"
 	"fmt"
-	"github.com/snowfork/snowbridge/relayer/config"
 )
 
 type Config struct {
@@ -35,8 +34,16 @@ type BeaconConfig struct {
 }
 
 type SinkConfig struct {
-	Parachain          config.ParachainConfig `mapstructure:"parachain"`
-	UpdateSlotInterval uint64                 `mapstructure:"updateSlotInterval"`
+	Parachain          ParachainConfig `mapstructure:"parachain"`
+	UpdateSlotInterval uint64          `mapstructure:"updateSlotInterval"`
+}
+
+type ParachainConfig struct {
+	Endpoint             string `mapstructure:"endpoint"`
+	MaxWatchedExtrinsics int64  `mapstructure:"maxWatchedExtrinsics"`
+	// The max number of header in the FinalizedBeaconStateBuffer on-chain.
+	// https://github.com/paritytech/polkadot-sdk/blob/master/bridges/snowbridge/pallets/ethereum-client/src/types.rs#L23
+	HeaderRedundancy uint64 `mapstructure:"headerRedundancy"`
 }
 
 func (c Config) Validate() error {
@@ -81,3 +88,16 @@ func (b BeaconConfig) Validate() error {
 	}
 	return nil
 }
+
+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")
+	}
+	if p.HeaderRedundancy == 0 {
+		return errors.New("[HeaderRedundancy] is not set")
+	}
+	return nil
+}

relayer/relays/beacon/header/header.go

@@ -523,32 +523,32 @@ func (h *Header) findLatestCheckPoint(slot uint64) (state.FinalizedHeader, error
 		return beaconState, fmt.Errorf("GetLastFinalizedStateIndex error: %w", err)
 	}
 	startIndex := uint64(lastIndex)
-	endIndex := uint64(0)
+	endIndex := startIndex + 1
 
 	syncCommitteePeriod := h.protocol.Settings.SlotsInEpoch * h.protocol.Settings.EpochsPerSyncCommitteePeriod
-	slotPeriodIndex := slot / syncCommitteePeriod
-
-	for index := startIndex; index >= endIndex; index-- {
+	totalStates := syncCommitteePeriod * h.protocol.HeaderRedundancy // Total size of the circular buffer,
+	// https://github.com/paritytech/polkadot-sdk/blob/master/bridges/snowbridge/pallets/ethereum-client/src/lib.rs#L75
+	for index := startIndex; index != endIndex; index = (index - 1 + totalStates) % totalStates {
 		beaconRoot, err := h.writer.GetFinalizedBeaconRootByIndex(uint32(index))
 		if err != nil {
 			return beaconState, fmt.Errorf("GetFinalizedBeaconRootByIndex %d, error: %w", index, err)
 		}
 		beaconState, err = h.writer.GetFinalizedHeaderStateByBlockRoot(beaconRoot)
 		if err != nil {
-			return beaconState, fmt.Errorf("GetFinalizedHeaderStateByBlockRoot %s, error: %w", beaconRoot.Hex(), err)
+			// As soon as it can't find a block root, it means the circular wrap around array is empty.
+			log.WithFields(log.Fields{"index": index, "blockRoot": beaconRoot.Hex()}).WithError(err).Info("searching for checkpoint on-chain failed")
+			break
 		}
-		statePeriodIndex := beaconState.BeaconSlot / syncCommitteePeriod
+
 		if beaconState.BeaconSlot < slot {
+			log.WithFields(log.Fields{"index": index, "blockRoot": beaconRoot.Hex()}).WithError(err).Debug("unable to find a relevant on-chain header")
 			break
 		}
 		// Found the beaconState
-		if beaconState.BeaconSlot > slot && beaconState.BeaconSlot < slot+syncCommitteePeriod && slotPeriodIndex == statePeriodIndex {
-			break
+		if beaconState.BeaconSlot > slot && beaconState.BeaconSlot < slot+syncCommitteePeriod {
+			return beaconState, nil
 		}
 	}
-	if beaconState.BeaconSlot > slot && beaconState.BeaconSlot < slot+syncCommitteePeriod {
-		return beaconState, nil
-	}
 
 	return beaconState, fmt.Errorf("no checkpoint on chain for slot %d", slot)
 }

relayer/relays/beacon/header/header_test.go

@@ -3,6 +3,7 @@ package header
 import (
 	"context"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/snowfork/go-substrate-rpc-client/v4/types"
 	"github.com/snowfork/snowbridge/relayer/relays/beacon/config"
 	"github.com/snowfork/snowbridge/relayer/relays/beacon/header/syncer/api"
 	"github.com/snowfork/snowbridge/relayer/relays/beacon/mock"
@@ -15,14 +16,16 @@ import (
 	"testing"
 )
 
+const MaxRedundancy = 20
+
 // Verifies that the closest checkpoint is populated successfully if it is not populated in the first place.
 func TestSyncInterimFinalizedUpdate_WithDataFromAPI(t *testing.T) {
 	settings := config.SpecSettings{
 		SlotsInEpoch:                 32,
 		EpochsPerSyncCommitteePeriod: 256,
 		DenebForkEpoch:               0,
 	}
-	p := protocol.New(settings)
+	p := protocol.New(settings, MaxRedundancy)
 	client := mock.API{}
 	beaconStore := mock.Store{}
 
@@ -80,7 +83,7 @@ func TestSyncInterimFinalizedUpdate_WithDataFromStore(t *testing.T) {
 		EpochsPerSyncCommitteePeriod: 256,
 		DenebForkEpoch:               0,
 	}
-	p := protocol.New(settings)
+	p := protocol.New(settings, MaxRedundancy)
 	client := mock.API{}
 	beaconStore := mock.Store{}
 
@@ -146,7 +149,7 @@ func TestSyncInterimFinalizedUpdate_WithDataFromStoreWithDifferentBlocks(t *test
 		EpochsPerSyncCommitteePeriod: 256,
 		DenebForkEpoch:               0,
 	}
-	p := protocol.New(settings)
+	p := protocol.New(settings, MaxRedundancy)
 	client := mock.API{}
 	beaconStore := mock.Store{}
 
@@ -212,7 +215,7 @@ func TestSyncInterimFinalizedUpdate_BeaconStateNotAvailableInAPIAndStore(t *test
 		EpochsPerSyncCommitteePeriod: 256,
 		DenebForkEpoch:               0,
 	}
-	p := protocol.New(settings)
+	p := protocol.New(settings, MaxRedundancy)
 	client := mock.API{}
 	beaconStore := mock.Store{}
 
@@ -256,7 +259,7 @@ func TestSyncInterimFinalizedUpdate_NoValidBlocksFound(t *testing.T) {
 		EpochsPerSyncCommitteePeriod: 256,
 		DenebForkEpoch:               0,
 	}
-	p := protocol.New(settings)
+	p := protocol.New(settings, MaxRedundancy)
 	client := mock.API{}
 	beaconStore := mock.Store{}
 
@@ -324,3 +327,102 @@ func TestShouldUpdate(t *testing.T) {
 		assert.Equal(t, tt.result, result, "expected %t but found %t", tt.result, result)
 	}
 }
+
+func TestFindLatestCheckPoint(t *testing.T) {
+	settings := config.SpecSettings{
+		SlotsInEpoch:                 4,
+		EpochsPerSyncCommitteePeriod: 2,
+		DenebForkEpoch:               0,
+	}
+	maxRedundancy := uint64(2)
+	p := protocol.New(settings, maxRedundancy)
+	// Total circular array would be 4 * 2 * 2 = 16
+	client := mock.API{}
+	beaconStore := mock.Store{}
+
+	headerIndex5 := common.HexToHash("0xd118e1464716db841f14ac1c3245f2b7900ee6f896ac85362deae3ff90c14c78")
+	headerIndex4 := common.HexToHash("0xe9d993e257b0d7ac775b8a03827209db2c7314a780c24a7fad64fd9fcee529f7")
+	headerIndex3 := common.HexToHash("0x7f2c1240dd714f3d74050638c642f14bf49f541d42f0808b7ae0c188c7edbb08")
+	headerIndex2 := common.HexToHash("0x01eaa6cbb00311f19c84965f3a9e8ddf56dd5443dfa8ea35c3e6d0b6306554b3")
+	headerIndex1 := common.HexToHash("0xa106b85508139ad0417cc521f41943a74908bfedbc6f548b3d1acddf60548493")
+	headerIndex0 := common.HexToHash("0xefef79bf51c3e02c19f9cbe718c6e226ad516153622a500bf783fce2aa8ec7c6")
+	headerIndex15 := common.HexToHash("0x416f890494e218d3cb32ce1ef3bd08e3acccf6e112b66db544cfcc6295bbdc2a")
+	headerIndex14 := common.HexToHash("0x74c4e67ca468722a7c3af52c5f96f4bbdd60b4d237ae7693863dca308e3c354c")
+
+	h := New(
+		&mock.Writer{
+			LastFinalizedState: state.FinalizedHeader{
+				BeaconBlockRoot:       common.Hash{},
+				BeaconSlot:            50,
+				InitialCheckpointRoot: common.Hash{},
+				InitialCheckpointSlot: 0,
+			},
+			LastFinalizedStateIndex: 5,
+			FinalizedBeaconRootByIndex: map[uint32]types.H256{
+				5:  types.H256(headerIndex5),
+				4:  types.H256(headerIndex4),
+				3:  types.H256(headerIndex3),
+				2:  types.H256(headerIndex2),
+				1:  types.H256(headerIndex1),
+				0:  types.H256(headerIndex0),
+				15: types.H256(headerIndex15),
+				14: types.H256(headerIndex14),
+			},
+			FinalizedHeaderStateByBlockRoot: map[types.H256]state.FinalizedHeader{
+				types.H256(headerIndex5): state.FinalizedHeader{
+					BeaconBlockRoot: headerIndex5,
+					BeaconSlot:      50,
+				},
+				types.H256(headerIndex4): state.FinalizedHeader{
+					BeaconBlockRoot: headerIndex4,
+					BeaconSlot:      46,
+				},
+				types.H256(headerIndex3): state.FinalizedHeader{
+					BeaconBlockRoot: headerIndex3,
+					BeaconSlot:      42,
+				},
+				types.H256(headerIndex2): state.FinalizedHeader{
+					BeaconBlockRoot: headerIndex2,
+					BeaconSlot:      38,
+				},
+				types.H256(headerIndex1): state.FinalizedHeader{
+					BeaconBlockRoot: headerIndex1,
+					BeaconSlot:      30,
+				},
+				types.H256(headerIndex0): state.FinalizedHeader{
+					BeaconBlockRoot: headerIndex0,
+					BeaconSlot:      32,
+				},
+				types.H256(headerIndex15): state.FinalizedHeader{
+					BeaconBlockRoot: headerIndex15,
+					BeaconSlot:      20,
+				},
+				types.H256(headerIndex14): state.FinalizedHeader{
+					BeaconBlockRoot: headerIndex14,
+					BeaconSlot:      18,
+				},
+			},
+		},
+		&client,
+		settings,
+		&beaconStore,
+		p,
+		316,
+	)
+
+	// Slot 20 would be usable to prove slot 19
+	header, err := h.findLatestCheckPoint(19)
+	assert.NoError(t, err)
+	assert.Equal(t, headerIndex15, header.BeaconBlockRoot)
+	assert.Equal(t, uint64(20), header.BeaconSlot)
+
+	// No header would be within range to prove slot 4
+	_, err = h.findLatestCheckPoint(4)
+	assert.Error(t, err)
+
+	// Slot 46 would be usable to prove slot 19
+	header, err = h.findLatestCheckPoint(40)
+	assert.NoError(t, err)
+	assert.Equal(t, headerIndex4, header.BeaconBlockRoot)
+	assert.Equal(t, uint64(46), header.BeaconSlot)
+}

relayer/relays/beacon/header/syncer/syncer_test.go

@@ -19,13 +19,14 @@ import (
 )
 
 const TestUrl = "https://lodestar-sepolia.chainsafe.io"
+const MaxRedundancy = 20
 
 func newTestRunner() *Syncer {
 	return New(api.NewBeaconClient(TestUrl, TestUrl), &mock.Store{}, protocol.New(config.SpecSettings{
 		SlotsInEpoch:                 32,
 		EpochsPerSyncCommitteePeriod: 256,
 		DenebForkEpoch:               0,
-	}))
+	}, MaxRedundancy))
 }
 
 // Verifies that the Lodestar provided finalized endpoint matches the manually constructed finalized endpoint
@@ -110,7 +111,7 @@ func TestGetFinalizedUpdateWithSyncCommitteeUpdateAtSlot(t *testing.T) {
 		SlotsInEpoch:                 32,
 		EpochsPerSyncCommitteePeriod: 256,
 		DenebForkEpoch:               0,
-	}))
+	}, MaxRedundancy))
 
 	// Manually construct a finalized update
 	manualUpdate, err := syncer.GetFinalizedUpdateAtAttestedSlot(129, 0, true)
@@ -165,7 +166,7 @@ func TestFindAttestedAndFinalizedHeadersAtBoundary(t *testing.T) {
 		SlotsInEpoch:                 32,
 		EpochsPerSyncCommitteePeriod: 256,
 		DenebForkEpoch:               0,
-	}))
+	}, MaxRedundancy))
 
 	attested, err := syncer.FindValidAttestedHeader(8000, 8160)
 	assert.NoError(t, err)
@@ -195,7 +196,7 @@ func TestFindAttestedAndFinalizedHeadersAtBoundary(t *testing.T) {
 		SlotsInEpoch:                 32,
 		EpochsPerSyncCommitteePeriod: 256,
 		DenebForkEpoch:               0,
-	}))
+	}, MaxRedundancy))
 
 	attested, err = syncer.FindValidAttestedHeader(32576, 32704)
 	assert.NoError(t, err)
@@ -225,7 +226,7 @@ func TestFindAttestedAndFinalizedHeadersAtBoundary(t *testing.T) {
 		SlotsInEpoch:                 32,
 		EpochsPerSyncCommitteePeriod: 256,
 		DenebForkEpoch:               0,
-	}))
+	}, MaxRedundancy))
 
 	attested, err = syncer.FindValidAttestedHeader(25076, 32736)
 	assert.NoError(t, err)
@@ -249,7 +250,7 @@ func TestFindAttestedAndFinalizedHeadersAtBoundary(t *testing.T) {
 		SlotsInEpoch:                 32,
 		EpochsPerSyncCommitteePeriod: 256,
 		DenebForkEpoch:               0,
-	}))
+	}, MaxRedundancy))
 
 	attested, err = syncer.FindValidAttestedHeader(32540, 32768)
 	assert.Error(t, err)