feat(op): added AtBlockNumber to events

Author: ezdac

rolling-shutter/keyperimpl/optimism/keyper.go

@@ -99,7 +99,7 @@ func (kpr *Keyper) newBlock(_ context.Context, ev *shopevent.LatestBlock) error
 
 	// TODO: sanity checks
 
-	idPreimage := identitypreimage.BigToIdentityPreimage(ev.Number)
+	idPreimage := identitypreimage.BigToIdentityPreimage(ev.Number.Int)
 	trig := &epochkghandler.DecryptionTrigger{
 		BlockNumber:       ev.Number.Uint64(),
 		IdentityPreimages: []identitypreimage.IdentityPreimage{idPreimage},

rolling-shutter/keyperimpl/optimism/sync/event/events.go

@@ -1,9 +1,9 @@
 package event
 
 import (
-	"math/big"
-
 	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/encodeable/number"
 )
 
 type (
@@ -12,16 +12,22 @@ type (
 		Members         []common.Address
 		Threshold       uint64
 		Eon             uint64
+
+		AtBlockNumber *number.BlockNumber
 	}
 	EonPublicKey struct {
 		Eon uint64
 		Key []byte
-	}
-	LatestBlock struct {
-		Number    *big.Int
-		BlockHash common.Hash
+
+		AtBlockNumber *number.BlockNumber
 	}
 	ShutterState struct {
 		Active bool
+
+		AtBlockNumber *number.BlockNumber
+	}
+	LatestBlock struct {
+		Number    *number.BlockNumber
+		BlockHash common.Hash
 	}
 )

rolling-shutter/keyperimpl/optimism/sync/syncer/eonpubkey.go

@@ -74,7 +74,6 @@ func (s *EonPubKeySyncer) Start(ctx context.Context, runner service.Runner) erro
 func (s *EonPubKeySyncer) getInitialPubKeys(ctx context.Context) ([]*event.EonPublicKey, error) {
 	// This blocknumber specifies AT what state
 	// the contract is called
-	// XXX: does the call-opts blocknumber -1 also means latest?
 	opts := &bind.CallOpts{
 		Context:     ctx,
 		BlockNumber: s.StartBlock.Int,
@@ -113,9 +112,14 @@ func (s *EonPubKeySyncer) logCallError(attrName string, err error) {
 }
 
 func (s *EonPubKeySyncer) GetEonPubKeyForEon(ctx context.Context, opts *bind.CallOpts, eon uint64) (*event.EonPublicKey, error) {
-	if opts == nil {
-		opts = &bind.CallOpts{
-			Context: ctx,
+	var err error
+	if err := guardCallOpts(opts, true); err != nil {
+		return nil, err
+	}
+	if number.BigToBlockNumber(opts.BlockNumber).IsLatest() {
+		opts, err = fixCallOpts(ctx, s.Client, opts)
+		if err != nil {
+			return nil, err
 		}
 	}
 	key, err := s.KeyBroadcast.GetEonKey(opts, eon)
@@ -125,8 +129,9 @@ func (s *EonPubKeySyncer) GetEonPubKeyForEon(ctx context.Context, opts *bind.Cal
 		return nil, err
 	}
 	return &event.EonPublicKey{
-		Eon: eon,
-		Key: key,
+		Eon:           eon,
+		Key:           key,
+		AtBlockNumber: number.BigToBlockNumber(opts.BlockNumber),
 	}, nil
 }
 
@@ -137,9 +142,11 @@ func (s *EonPubKeySyncer) watchNewEonPubkey(ctx context.Context) error {
 			if !ok {
 				return nil
 			}
+			bn := newEonKey.Raw.BlockNumber
 			ev := &event.EonPublicKey{
-				Eon: newEonKey.Eon,
-				Key: newEonKey.Key,
+				Eon:           newEonKey.Eon,
+				Key:           newEonKey.Key,
+				AtBlockNumber: number.NewBlockNumber(&bn),
 			}
 			err := s.Handler(ctx, ev)
 			if err != nil {

rolling-shutter/keyperimpl/optimism/sync/syncer/keyperset.go

@@ -82,27 +82,33 @@ func (s *KeyperSetSyncer) Start(ctx context.Context, runner service.Runner) erro
 }
 
 func (s *KeyperSetSyncer) getInitialKeyperSets(ctx context.Context) ([]*event.KeyperSet, error) {
-	// This blocknumber specifies AT what state
-	// the contract is called
-	// XXX: does the call-opts blocknumber -1 also means latest?
 	opts := &bind.CallOpts{
 		Context:     ctx,
 		BlockNumber: s.StartBlock.Int,
 	}
-	numKS, err := s.Contract.GetNumKeyperSets(opts)
-	if err != nil {
+	if err := guardCallOpts(opts, false); err != nil {
 		return nil, err
 	}
+	bn := s.StartBlock.ToUInt64Ptr()
+	if bn == nil {
+		// this should not be the case
+		return nil, errors.New("start block is 'latest'")
+	}
 
 	initialKeyperSets := []*event.KeyperSet{}
 	// this blocknumber specifies the argument to the contract
 	// getter
-	ks, err := s.GetKeyperSetForBlock(ctx, nil, s.StartBlock)
+	ks, err := s.GetKeyperSetForBlock(ctx, opts, s.StartBlock)
 	if err != nil {
 		return nil, err
 	}
 	initialKeyperSets = append(initialKeyperSets, ks)
 
+	numKS, err := s.Contract.GetNumKeyperSets(opts)
+	if err != nil {
+		return nil, err
+	}
+
 	for i := ks.Eon + 1; i < numKS; i++ {
 		ks, err = s.GetKeyperSetByIndex(ctx, opts, i)
 		if err != nil {
@@ -115,10 +121,8 @@ func (s *KeyperSetSyncer) getInitialKeyperSets(ctx context.Context) ([]*event.Ke
 }
 
 func (s *KeyperSetSyncer) GetKeyperSetByIndex(ctx context.Context, opts *bind.CallOpts, index uint64) (*event.KeyperSet, error) {
-	if opts == nil {
-		opts = &bind.CallOpts{
-			Context: ctx,
-		}
+	if err := guardCallOpts(opts, true); err != nil {
+		return nil, err
 	}
 	actBl, err := s.Contract.GetKeyperSetActivationBlock(opts, index)
 	if err != nil {
@@ -134,18 +138,15 @@ func (s *KeyperSetSyncer) GetKeyperSetByIndex(ctx context.Context, opts *bind.Ca
 func (s *KeyperSetSyncer) GetKeyperSetForBlock(ctx context.Context, opts *bind.CallOpts, b *number.BlockNumber) (*event.KeyperSet, error) {
 	var latestBlock uint64
 	var err error
+	if err := guardCallOpts(opts, true); err != nil {
+		return nil, err
+	}
 
 	if b.Equal(number.LatestBlock) {
 		latestBlock, err = s.Client.BlockNumber(ctx)
 	} else {
 		latestBlock = b.Uint64()
 	}
-	if opts == nil {
-		// call at "latest block" state
-		opts = &bind.CallOpts{
-			Context: ctx,
-		}
-	}
 	idx, err := s.Contract.GetKeyperSetIndexByBlock(opts, latestBlock)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not retrieve keyper set index")
@@ -159,34 +160,31 @@ func (s *KeyperSetSyncer) newEvent(
 	keyperSetContract common.Address,
 	activationBlock uint64,
 ) (*event.KeyperSet, error) {
-	callOpts := opts
-	if callOpts == nil {
-		callOpts = &bind.CallOpts{
-			Context: ctx,
-		}
+	if err := guardCallOpts(opts, false); err != nil {
+		return nil, err
 	}
 	ks, err := bindings.NewKeyperSet(keyperSetContract, s.Client)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not bind to KeyperSet contract")
 	}
 	// the manager only accepts final keyper sets,
 	// so we expect this to be final now.
-	final, err := ks.IsFinalized(callOpts)
+	final, err := ks.IsFinalized(opts)
 	if err != nil {
 		return nil, makeCallError("IsFinalized", err)
 	}
 	if !final {
 		return nil, errors.New("contract did accept unfinalized keyper-sets")
 	}
-	members, err := ks.GetMembers(callOpts)
+	members, err := ks.GetMembers(opts)
 	if err != nil {
 		return nil, makeCallError("Members", err)
 	}
-	threshold, err := ks.GetThreshold(callOpts)
+	threshold, err := ks.GetThreshold(opts)
 	if err != nil {
 		return nil, makeCallError("Threshold", err)
 	}
-	eon, err := s.Contract.GetKeyperSetIndexByBlock(callOpts, activationBlock)
+	eon, err := s.Contract.GetKeyperSetIndexByBlock(opts, activationBlock)
 	if err != nil {
 		return nil, makeCallError("KeyperSetIndexByBlock", err)
 	}
@@ -195,6 +193,7 @@ func (s *KeyperSetSyncer) newEvent(
 		Members:         members,
 		Threshold:       threshold,
 		Eon:             eon,
+		AtBlockNumber:   number.BigToBlockNumber(opts.BlockNumber),
 	}, nil
 }
 
@@ -205,9 +204,10 @@ func (s *KeyperSetSyncer) watchNewKeypersService(ctx context.Context) error {
 			if !ok {
 				return nil
 			}
+			opts := logToCallOpts(ctx, &newKeypers.Raw)
 			newKeyperSet, err := s.newEvent(
 				ctx,
-				nil,
+				opts,
 				newKeypers.KeyperSetContract,
 				newKeypers.ActivationBlock,
 			)

rolling-shutter/keyperimpl/optimism/sync/syncer/unsafehead.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/shutter-network/rolling-shutter/rolling-shutter/keyperimpl/optimism/sync/client"
 	"github.com/shutter-network/rolling-shutter/rolling-shutter/keyperimpl/optimism/sync/event"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/encodeable/number"
 	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/service"
 )
 
@@ -49,7 +50,7 @@ func (s *UnsafeHeadSyncer) watchLatestUnsafeHead(ctx context.Context) error {
 				return nil
 			}
 			ev := &event.LatestBlock{
-				Number:    newHeader.Number,
+				Number:    number.BigToBlockNumber(newHeader.Number),
 				BlockHash: newHeader.Hash(),
 			}
 			err := s.Handler(ctx, ev)

rolling-shutter/keyperimpl/optimism/sync/syncer/util.go

@@ -0,0 +1,65 @@
+package syncer
+
+import (
+	"context"
+	"errors"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/core/types"
+
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/keyperimpl/optimism/sync/client"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/encodeable/number"
+)
+
+var (
+	errNilCallOpts = errors.New("nil call-opts")
+	errLatestBlock = errors.New("'nil' latest block")
+)
+
+func logToCallOpts(ctx context.Context, log *types.Log) *bind.CallOpts {
+	block := new(big.Int)
+	block.SetUint64(log.BlockNumber)
+	return &bind.CallOpts{
+		BlockNumber: block,
+		Context:     ctx,
+	}
+}
+
+func guardCallOpts(opts *bind.CallOpts, allowLatest bool) error {
+	if opts == nil {
+		return errNilCallOpts
+	}
+	if !allowLatest {
+		n := number.BlockNumber{Int: opts.BlockNumber}
+		if n.IsLatest() {
+			return errLatestBlock
+		}
+	}
+	return nil
+}
+
+func fixCallOpts(ctx context.Context, c client.Client, opts *bind.CallOpts) (*bind.CallOpts, error) {
+	err := guardCallOpts(opts, false)
+	if err != nil {
+		return opts, nil
+	}
+	// query the current latest block and fix it
+	latest, err := c.BlockNumber(ctx)
+	if err != nil {
+		return nil, err
+	}
+	blockNumber := number.NewBlockNumber(&latest)
+	if errors.Is(err, errNilCallOpts) {
+		opts = &bind.CallOpts{
+			Context:     ctx,
+			BlockNumber: blockNumber.Int,
+		}
+		return opts, nil
+	}
+	if errors.Is(err, errLatestBlock) {
+		opts.BlockNumber = blockNumber.Int
+		return opts, nil
+	}
+	return nil, err
+}

rolling-shutter/medley/encodeable/number/block.go

@@ -11,6 +11,12 @@ var (
 	LatestStr            = []byte("latest")
 )
 
+func BigToBlockNumber(i *big.Int) *BlockNumber {
+	return &BlockNumber{
+		Int: i,
+	}
+}
+
 func NewBlockNumber(u *uint64) *BlockNumber {
 	b := &BlockNumber{
 		Int: &big.Int{},

rolling-shutter/medley/identitypreimage/identitypreimage.go

@@ -9,7 +9,6 @@ import (
 
 type IdentityPreimage []byte
 
-// BigToIdentityPreimage converts n to an epoch id. It fails if n is too big.
 func BigToIdentityPreimage(n *big.Int) IdentityPreimage {
 	return IdentityPreimage(n.Bytes())
 }