Merge branch 'gnosis' into main-gnosis-merge

Author: jannikluhn

.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

@@ -2,12 +2,12 @@ babashka 1.3.182
 binaryen 114
 circleci 0.1.28811
 clojure 1.11.1.1386
-golang 1.21.3
+golang 1.21.4
 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/addrseq.go

@@ -0,0 +1,29 @@
+package chainobserver
+
+import (
+	"context"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/pkg/errors"
+
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/contract"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/retry"
+)
+
+func RetryGetAddrs(ctx context.Context, addrsSeq *contract.AddrsSeq, n uint64) ([]common.Address, error) {
+	callOpts := &bind.CallOpts{
+		Pending: false,
+		// We call for the current height instead of the height at which the event was emitted,
+		// because the sets cannot change retroactively and we won't need an archive node.
+		BlockNumber: nil,
+		Context:     ctx,
+	}
+	addrs, err := retry.FunctionCall(ctx, func(_ context.Context) ([]common.Address, error) {
+		return addrsSeq.GetAddrs(callOpts, n)
+	})
+	if err != nil {
+		return []common.Address{}, errors.Wrapf(err, "failed to query address set from contract")
+	}
+	return addrs, nil
+}

rolling-shutter/chainobserver/db/collator/handler.go

@@ -0,0 +1,51 @@
+package database
+
+import (
+	"context"
+	"math"
+
+	"github.com/jackc/pgx/v4"
+	"github.com/pkg/errors"
+	"github.com/rs/zerolog/log"
+
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/chainobserver"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/contract"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/shdb"
+)
+
+type Handler struct {
+	CollatorContract *contract.AddrsSeq
+}
+
+func (h *Handler) PutDB(
+	ctx context.Context, tx pgx.Tx, event contract.CollatorConfigsListNewConfig,
+) error {
+	addrs, err := chainobserver.RetryGetAddrs(ctx, h.CollatorContract, event.CollatorSetIndex)
+	if err != nil {
+		return err
+	}
+	log.Info().
+		Uint64("block-number", event.Raw.BlockNumber).
+		Uint64("collator-config-index", event.CollatorConfigIndex).
+		Uint64("activation-block-number", event.ActivationBlockNumber).
+		Msg("handling NewConfig event from collator config contract")
+	if event.ActivationBlockNumber > math.MaxInt64 {
+		return errors.Errorf(
+			"activation block number %d from config contract would overflow int64",
+			event.ActivationBlockNumber,
+		)
+	}
+	if len(addrs) > 1 {
+		return errors.Errorf("got multiple collators from collator addrs set contract: %s", addrs)
+	} else if len(addrs) == 1 {
+		db := New(tx)
+		err := db.InsertChainCollator(ctx, InsertChainCollatorParams{
+			ActivationBlockNumber: int64(event.ActivationBlockNumber),
+			Collator:              shdb.EncodeAddress(addrs[0]),
+		})
+		if err != nil {
+			return errors.Wrapf(err, "failed to insert collator into db")
+		}
+	}
+	return nil
+}

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/handler.go

@@ -0,0 +1,49 @@
+package database
+
+import (
+	"context"
+	"math"
+
+	"github.com/jackc/pgx/v4"
+	"github.com/pkg/errors"
+	"github.com/rs/zerolog/log"
+
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/chainobserver"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/contract"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/shdb"
+)
+
+type Handler struct {
+	KeyperContract *contract.AddrsSeq
+}
+
+func (h *Handler) PutDB(
+	ctx context.Context, tx pgx.Tx, event contract.KeypersConfigsListNewConfig,
+) error {
+	addrs, err := chainobserver.RetryGetAddrs(ctx, h.KeyperContract, event.KeyperSetIndex)
+	if err != nil {
+		return err
+	}
+	log.Info().
+		Uint64("block-number", event.Raw.BlockNumber).
+		Uint64("keyper-config-index", event.KeyperConfigIndex).
+		Uint64("activation-block-number", event.ActivationBlockNumber).
+		Msg("handling NewConfig event from keypers config contract")
+
+	if event.ActivationBlockNumber > math.MaxInt64 {
+		return errors.Errorf(
+			"activation block number %d from config contract would overflow int64",
+			event.ActivationBlockNumber)
+	}
+	db := New(tx)
+	err = db.InsertKeyperSet(ctx, InsertKeyperSetParams{
+		KeyperConfigIndex:     int64(event.KeyperConfigIndex),
+		ActivationBlockNumber: int64(event.ActivationBlockNumber),
+		Keypers:               shdb.EncodeAddresses(addrs),
+		Threshold:             int32(event.Threshold),
+	})
+	if err != nil {
+		return errors.Wrapf(err, "failed to insert keyper set into db")
+	}
+	return nil
+}