gnosisaccessnode: add synchandler for new chainsyncer

Author: ezdac

rolling-shutter/gnosisaccessnode/decryptionkeyshandler.go

@@ -10,19 +10,20 @@ import (
 
 	"github.com/shutter-network/shutter/shlib/shcrypto"
 
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/gnosisaccessnode/storage"
 	"github.com/shutter-network/rolling-shutter/rolling-shutter/keyperimpl/gnosis"
 	"github.com/shutter-network/rolling-shutter/rolling-shutter/p2pmsg"
 )
 
 type DecryptionKeysHandler struct {
 	config  *Config
-	storage *Storage
+	storage *storage.Memory
 }
 
-func NewDecryptionKeysHandler(config *Config, storage *Storage) *DecryptionKeysHandler {
+func NewDecryptionKeysHandler(config *Config, store *storage.Memory) *DecryptionKeysHandler {
 	return &DecryptionKeysHandler{
 		config:  config,
-		storage: storage,
+		storage: store,
 	}
 }
 

rolling-shutter/gnosisaccessnode/node.go

@@ -9,6 +9,7 @@ import (
 	"github.com/shutter-network/shutter/shlib/shcrypto"
 
 	obskeyperdatabase "github.com/shutter-network/rolling-shutter/rolling-shutter/chainobserver/db/keyper"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/gnosisaccessnode/storage"
 	chainsync "github.com/shutter-network/rolling-shutter/rolling-shutter/medley/legacychainsync"
 	syncevent "github.com/shutter-network/rolling-shutter/rolling-shutter/medley/legacychainsync/event"
 	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/metricsserver"
@@ -19,13 +20,13 @@ import (
 
 type GnosisAccessNode struct {
 	config  *Config
-	storage *Storage
+	storage *storage.Memory
 }
 
 func New(config *Config) *GnosisAccessNode {
 	return &GnosisAccessNode{
 		config:  config,
-		storage: NewStorage(),
+		storage: storage.NewMemory(),
 	}
 }
 

rolling-shutter/gnosisaccessnode/storage.go renamed to rolling-shutter/gnosisaccessnode/storage/storage.go

@@ -1,4 +1,4 @@
-package gnosisaccessnode
+package storage
 
 import (
 	"sync"
@@ -8,43 +8,43 @@ import (
 	obskeyperdatabase "github.com/shutter-network/rolling-shutter/rolling-shutter/chainobserver/db/keyper"
 )
 
-type Storage struct {
+type Memory struct {
 	mu         sync.Mutex
 	eonKeys    map[uint64]*shcrypto.EonPublicKey
 	keyperSets map[uint64]*obskeyperdatabase.KeyperSet
 }
 
-func NewStorage() *Storage {
-	return &Storage{
+func NewMemory() *Memory {
+	return &Memory{
 		mu:         sync.Mutex{},
 		eonKeys:    make(map[uint64]*shcrypto.EonPublicKey),
 		keyperSets: make(map[uint64]*obskeyperdatabase.KeyperSet),
 	}
 }
 
-func (s *Storage) AddEonKey(keyperConfigIndex uint64, key *shcrypto.EonPublicKey) {
+func (s *Memory) AddEonKey(keyperConfigIndex uint64, key *shcrypto.EonPublicKey) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
 	s.eonKeys[keyperConfigIndex] = key
 }
 
-func (s *Storage) GetEonKey(keyperConfigIndex uint64) (*shcrypto.EonPublicKey, bool) {
+func (s *Memory) GetEonKey(keyperConfigIndex uint64) (*shcrypto.EonPublicKey, bool) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
 	v, ok := s.eonKeys[keyperConfigIndex]
 	return v, ok
 }
 
-func (s *Storage) AddKeyperSet(keyperConfigIndex uint64, keyperSet *obskeyperdatabase.KeyperSet) {
+func (s *Memory) AddKeyperSet(keyperConfigIndex uint64, keyperSet *obskeyperdatabase.KeyperSet) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
 	s.keyperSets[keyperConfigIndex] = keyperSet
 }
 
-func (s *Storage) GetKeyperSet(keyperConfigIndex uint64) (*obskeyperdatabase.KeyperSet, bool) {
+func (s *Memory) GetKeyperSet(keyperConfigIndex uint64) (*obskeyperdatabase.KeyperSet, bool) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 

rolling-shutter/gnosisaccessnode/synchandler/eonkey.go

@@ -0,0 +1,89 @@
+package synchandler
+
+import (
+	"context"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/rs/zerolog/log"
+	"github.com/shutter-network/shop-contracts/bindings"
+
+	"github.com/shutter-network/shutter/shlib/shcrypto"
+
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/gnosisaccessnode/storage"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/chainsync/syncer"
+)
+
+func init() {
+	var err error
+	KeyBroadcastContractContractABI, err = bindings.KeyBroadcastContractMetaData.GetAbi()
+	if err != nil {
+		panic(err)
+	}
+}
+
+var KeyBroadcastContractContractABI *abi.ABI
+
+func NewEonKeyBroadcast(
+	store *storage.Memory,
+	contractAddress common.Address,
+) (syncer.ContractEventHandler, error) {
+	return syncer.WrapHandler(&EonKeyBroadcast{
+		evABI:               KeyBroadcastContractContractABI,
+		keyBroadcastAddress: contractAddress,
+		storage:             store,
+	})
+}
+
+type EonKeyBroadcast struct {
+	storage             *storage.Memory
+	evABI               *abi.ABI
+	keyBroadcastAddress common.Address
+}
+
+func (handler *EonKeyBroadcast) Address() common.Address {
+	return handler.keyBroadcastAddress
+}
+
+func (*EonKeyBroadcast) Event() string {
+	// TODO: look this up that his is correct
+	return "EonKeyBroadcast"
+}
+
+func (handler *EonKeyBroadcast) ABI() abi.ABI {
+	return *handler.evABI
+}
+
+func (handler *EonKeyBroadcast) Accept(
+	_ context.Context,
+	_ types.Header,
+	_ bindings.KeyBroadcastContractEonKeyBroadcast,
+) (bool, error) {
+	return true, nil
+}
+
+func (handler *EonKeyBroadcast) Handle(
+	_ context.Context,
+	_ syncer.ChainUpdateContext,
+	events []bindings.KeyBroadcastContractEonKeyBroadcast,
+) error {
+	for _, ev := range events {
+		key := new(shcrypto.EonPublicKey)
+		err := key.Unmarshal(ev.Key)
+		if err != nil {
+			log.Error().
+				Err(err).
+				Hex("key", ev.Key).
+				Int("keyper-config-index", int(ev.Eon)).
+				Msg("received invalid eon key")
+			return nil
+		}
+		log.Info().
+			Int("keyper-config-index", int(ev.Eon)).
+			Hex("key", ev.Key).
+			Msg("adding eon key")
+		handler.storage.AddEonKey(ev.Eon, key)
+	}
+	return nil
+}

rolling-shutter/gnosisaccessnode/synchandler/keypersetmanager.go

@@ -0,0 +1,112 @@
+package synchandler
+
+import (
+	"context"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/rs/zerolog/log"
+	"github.com/shutter-network/shop-contracts/bindings"
+
+	obskeyperdatabase "github.com/shutter-network/rolling-shutter/rolling-shutter/chainobserver/db/keyper"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/gnosisaccessnode/storage"
+	keypersetsync "github.com/shutter-network/rolling-shutter/rolling-shutter/keyper/synchandler"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/chainsync/client"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/chainsync/syncer"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/shdb"
+)
+
+func init() {
+	var err error
+	KeyperSetManagerContractABI, err = bindings.KeyperSetManagerMetaData.GetAbi()
+	if err != nil {
+		panic(err)
+	}
+}
+
+var KeyperSetManagerContractABI *abi.ABI
+
+func NewKeyperSetAdded(
+	ethClient client.Client,
+	store *storage.Memory,
+	contractAddress common.Address,
+) (syncer.ContractEventHandler, error) {
+	// we need access to an additional contract here in oder to pull in some more
+	// required information about the keyper sets:
+	ksm, err := bindings.NewKeyperSetManager(contractAddress, ethClient)
+	if err != nil {
+		return nil, err
+	}
+	return syncer.WrapHandler(&KeyperSetAdded{
+		storage:                 store,
+		evABI:                   KeyperSetManagerContractABI,
+		keyperSetManagerAddress: contractAddress,
+		keyperSetManager:        ksm,
+		ethClient:               ethClient,
+	})
+}
+
+type KeyperSetAdded struct {
+	storage                 *storage.Memory
+	evABI                   *abi.ABI
+	keyperSetManagerAddress common.Address
+	ethClient               client.Client
+	keyperSetManager        *bindings.KeyperSetManager
+}
+
+func (handler *KeyperSetAdded) Address() common.Address {
+	return handler.keyperSetManagerAddress
+}
+
+func (*KeyperSetAdded) Event() string {
+	return "KeyperSetAdded"
+}
+
+func (handler *KeyperSetAdded) ABI() abi.ABI {
+	return *handler.evABI
+}
+
+func (handler *KeyperSetAdded) Accept(
+	_ context.Context,
+	_ types.Header,
+	_ bindings.KeyperSetManagerKeyperSetAdded,
+) (bool, error) {
+	return true, nil
+}
+
+func (handler *KeyperSetAdded) Handle(
+	ctx context.Context,
+	update syncer.ChainUpdateContext,
+	events []bindings.KeyperSetManagerKeyperSetAdded,
+) error {
+	// TODO: handle reorgs here
+	_ = update
+
+	for _, ev := range events {
+		keyperSet, err := keypersetsync.QueryFullKeyperSetFromKeyperSetAddedEvent(
+			ctx,
+			handler.ethClient,
+			ev,
+			handler.keyperSetManager,
+		)
+		if err != nil {
+			log.Error().Err(err).Msg("KeyperSetAdded event, error querying keyperset-data")
+		}
+		// FIXME: integer overflow protection
+		obsKeyperSet := obskeyperdatabase.KeyperSet{
+			KeyperConfigIndex:     int64(keyperSet.Eon),
+			ActivationBlockNumber: int64(keyperSet.ActivationBlock),
+			Keypers:               shdb.EncodeAddresses(keyperSet.Members),
+			Threshold:             int32(keyperSet.Threshold),
+		}
+		log.Info().
+			Uint64("keyper-config-index", keyperSet.Eon).
+			Uint64("activation-block-number", keyperSet.ActivationBlock).
+			Int("num-keypers", len(keyperSet.Members)).
+			Uint64("threshold", keyperSet.Threshold).
+			Msg("adding keyper set")
+		handler.storage.AddKeyperSet(keyperSet.Eon, &obsKeyperSet)
+	}
+	return nil
+}