Add unit-test for chainsync reorg capabilities

.pre-commit-config.yaml

@@ -13,7 +13,7 @@ repos:
         require_serial: true
 
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
+    rev: v4.5.0
     hooks:
       - id: check-added-large-files
         args: ["--maxkb=1000"]
@@ -33,7 +33,7 @@ repos:
       - id: trailing-whitespace
 
   - repo: https://github.com/pre-commit/mirrors-prettier
-    rev: v3.0.1
+    rev: v3.1.0
     hooks:
       - id: prettier
         additional_dependencies:
@@ -59,12 +59,12 @@ repos:
           ]
 
   - repo: https://github.com/pre-commit/mirrors-eslint
-    rev: "v8.4.1"
+    rev: "v8.56.0"
     hooks:
       - id: eslint
 
   - repo: https://github.com/shutter-network/pre-commit-go-hooks
-    rev: "7a66f5523b34139615a0c95f2b8a441dbc1778dc"
+    rev: "53239641ec106cda9a7acf9150c98be8d5ffa1ec"
     hooks:
       - id: shfmt
         args: ["-i", "4"]

.tool-versions

@@ -7,7 +7,7 @@ golangci-lint 1.55.2
 java temurin-17.0.5+8
 nodejs 18.17.0
 postgres 14.2
-pre-commit 3.3.3
+pre-commit 3.6.0
 protoc 22.3
 shfmt 3.7.0
 solidity 0.8.9

docker/build-src/optimism/Dockerfile

@@ -0,0 +1,26 @@
+FROM golang:1.21 as builder
+ENV GOMODCACHE=/root/.cache/mod
+
+# Fetch go modules separately to improve cache usage
+RUN mkdir /gomod
+COPY /rolling-shutter/go.* /gomod/
+WORKDIR /gomod
+RUN --mount=type=cache,target=/root/.cache go mod download
+
+# Build binary
+COPY / /src
+WORKDIR /src/rolling-shutter
+
+
+RUN go env
+RUN --mount=type=cache,target=/root/.cache CGO_ENABLED=0 GOOS=linux GOARCH=amd64 GOFLAGS=-v  make build
+
+FROM scratch as runner
+
+COPY --from=builder /src/rolling-shutter/bin/rolling-shutter /rolling-shutter
+
+# Use 'uclibc' flavor to avoid https://github.com/docker-library/busybox/issues/155#issuecomment-1344375664
+RUN --mount=from=busybox:uclibc,src=/bin,dst=/bin mkdir -p /etc/ssl
+COPY --from=builder /etc/ssl/certs /etc/ssl/certs
+
+ENTRYPOINT ["/rolling-shutter"]

rolling-shutter/app/app.go

@@ -306,7 +306,6 @@ func (ShutterApp) decodeTx(tx []byte) (signer common.Address, msg *shmsg.Message
 	}
 
 	msg, err = shmsg.GetMessage(signedMsg)
-
 	if err != nil {
 		return
 	}

rolling-shutter/app/messages.go

@@ -4,7 +4,7 @@ import (
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
-	bn256 "github.com/ethereum/go-ethereum/crypto/bn256/cloudflare"
+	"github.com/ethereum/go-ethereum/crypto/bls12381"
 	"github.com/pkg/errors"
 
 	"github.com/shutter-network/shutter/shlib/shcrypto"
@@ -54,14 +54,17 @@ func ParsePolyEvalMsg(msg *shmsg.PolyEval, sender common.Address) (*PolyEval, er
 
 // ParsePolyCommitmentMsg converts a shmsg.PolyCommitmentMsg to an app.PolyCommitmentMsg.
 func ParsePolyCommitmentMsg(msg *shmsg.PolyCommitment, sender common.Address) (*PolyCommitment, error) {
+	g2 := bls12381.NewG2()
 	gammas := shcrypto.Gammas{}
 	for _, g := range msg.Gammas {
-		g2 := new(bn256.G2)
-		_, err := g2.Unmarshal(g)
+		p, err := g2.FromBytes(g)
 		if err != nil {
 			return nil, err
 		}
-		gammas = append(gammas, g2)
+		if !g2.IsOnCurve(p) {
+			return nil, errors.Errorf("invalid gamma value %x", g)
+		}
+		gammas = append(gammas, p)
 	}
 	return &PolyCommitment{
 		Sender: sender,

rolling-shutter/chainobserver/db/keyper/extend.go

@@ -0,0 +1,51 @@
+package database
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/pkg/errors"
+
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/shdb"
+)
+
+// GetIndex returns the index of the given address in the KeyperSet.
+func (s *KeyperSet) GetIndex(address common.Address) (uint64, error) {
+	encodedAddress := shdb.EncodeAddress(address)
+	for i, m := range s.Keypers {
+		if m == encodedAddress {
+			return uint64(i), nil
+		}
+	}
+	return 0, errors.Errorf("keyper %s not found", address.String())
+}
+
+// Contains checks if the given address is present in the KeyperSet.
+// It returns true if the address is found, otherwise false.
+func (s *KeyperSet) Contains(address common.Address) bool {
+	encodedAddress := shdb.EncodeAddress(address)
+	for _, m := range s.Keypers {
+		if m == encodedAddress {
+			return true
+		}
+	}
+	return false
+}
+
+// GetSubset returns a subset of addresses from the KeyperSet based on the given indices.
+// The return value is ordered according to the order of the given indices. If indices contains
+// duplicates, the return value will do so as well. If at least one of the given indices is out of
+// range, an error is returned.
+func (s *KeyperSet) GetSubset(indices []uint64) ([]common.Address, error) {
+	subset := []common.Address{}
+	for _, i := range indices {
+		if i >= uint64(len(s.Keypers)) {
+			return nil, errors.Errorf("keyper index %d out of range (size %d)", i, len(s.Keypers))
+		}
+		addressStr := s.Keypers[i]
+		address, err := shdb.DecodeAddress(addressStr)
+		if err != nil {
+			return nil, err
+		}
+		subset = append(subset, address)
+	}
+	return subset, nil
+}

rolling-shutter/chainobserver/db/keyper/extend_test.go

@@ -0,0 +1,75 @@
+package database
+
+import (
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"gotest.tools/v3/assert"
+
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/shdb"
+)
+
+func makeTestKeyperSet() KeyperSet {
+	return KeyperSet{
+		KeyperConfigIndex:     0,
+		ActivationBlockNumber: 0,
+		Keypers: []string{
+			shdb.EncodeAddress(common.HexToAddress("0x0000000000000000000000000000000000000000")),
+			shdb.EncodeAddress(common.HexToAddress("0x5555555555555555555555555555555555555555")),
+			shdb.EncodeAddress(common.HexToAddress("0xaAaAaAaaAaAaAaaAaAAAAAAAAaaaAaAaAaaAaaAa")),
+		},
+		Threshold: 2,
+	}
+}
+
+func TestKeyperSetGetIndex(t *testing.T) {
+	keyperSet := makeTestKeyperSet()
+	addresses, err := shdb.DecodeAddresses(keyperSet.Keypers)
+	assert.NilError(t, err)
+
+	for i, address := range addresses {
+		index, err := keyperSet.GetIndex(address)
+		assert.NilError(t, err)
+		assert.Equal(t, uint64(i), index)
+	}
+	_, err = keyperSet.GetIndex(common.HexToAddress("0xffffffffffffffffffffffffffffffffffffffff"))
+	assert.ErrorContains(t, err, "keyper 0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF not found")
+}
+
+func TestKeyperSetContains(t *testing.T) {
+	keyperSet := makeTestKeyperSet()
+	addresses, err := shdb.DecodeAddresses(keyperSet.Keypers)
+	assert.NilError(t, err)
+
+	for _, address := range addresses {
+		assert.Assert(t, keyperSet.Contains(address))
+	}
+	assert.Assert(t, !keyperSet.Contains(common.HexToAddress("0xffffffffffffffffffffffffffffffffffffffff")))
+}
+
+func TestKeyperSetSubset(t *testing.T) {
+	keyperSet := makeTestKeyperSet()
+	testCases := []struct {
+		indices []uint64
+		valid   bool
+	}{
+		{indices: []uint64{0, 1, 2}, valid: true},
+		{indices: []uint64{}, valid: true},
+		{indices: []uint64{1, 0}, valid: true},
+		{indices: []uint64{0, 0}, valid: true},
+		{indices: []uint64{0, 0, 0, 0}, valid: true},
+		{indices: []uint64{3}, valid: false},
+	}
+
+	for _, tc := range testCases {
+		subset, err := keyperSet.GetSubset(tc.indices)
+		if tc.valid {
+			assert.Assert(t, len(subset) == len(tc.indices))
+			for _, i := range tc.indices {
+				assert.Assert(t, shdb.EncodeAddress(subset[i]) == keyperSet.Keypers[tc.indices[i]])
+			}
+		} else {
+			assert.Assert(t, err != nil)
+		}
+	}
+}

rolling-shutter/chainobserver/db/keyper/sql/queries/keyper.sql

@@ -15,3 +15,7 @@ SELECT * FROM keyper_set WHERE keyper_config_index=$1;
 SELECT * FROM keyper_set
 WHERE activation_block_number <= $1
 ORDER BY activation_block_number DESC LIMIT 1;
+
+-- name: GetKeyperSets :many
+SELECT * FROM keyper_set
+ORDER BY activation_block_number ASC;

rolling-shutter/chainobserver/observer.go

@@ -79,7 +79,7 @@ func (c *ChainObserver) Start(ctx context.Context, runner service.Runner) error
 	log.Info().Uint64("from-block", fromBlock).Uint64("from-log-index", fromLogIndex).
 		Msg("starting event syncing")
 	syncer := eventsyncer.New(c.Client, finalityOffset, eventTypes, fromBlock, fromLogIndex)
-	handleSyncLoop := func(ctx context.Context) error {
+	handleSyncLoop := func(ctx context.Context, _ service.Runner) error {
 		for {
 			select {
 			case <-ctx.Done():
@@ -102,5 +102,5 @@ func (c *ChainObserver) Start(ctx context.Context, runner service.Runner) error
 			}
 		}
 	}
-	return runner.StartService(syncer, service.ServiceFn{Fn: handleSyncLoop})
+	return runner.StartService(syncer, service.Function{Func: handleSyncLoop})
 }

rolling-shutter/cmd/bootstrap/bootstrap.go

@@ -83,6 +83,10 @@ chain's genesis config.`,
 	return cmd
 }
 
+// TODO: deprecate this command and split this up in 2 stages:
+//  1. gather initial keyperset information e.g. from contracts
+//     (could be different from optimism, rollupshutter,snapshot)
+//  2. send the batch-config / new block seen message based on that info.
 func bootstrap(config *Config) error {
 	ctx := context.Background()
 	ethereumClient, err := ethclient.DialContext(ctx, config.EthereumURL)