feat: add interfaces to make scheduler chain-family agnostic

Author: gustavogama-cll

pkg/timelock/operations_evm.go

@@ -19,36 +19,44 @@ import (
 // - The predecessor operation is finished
 // - The operation is ready to be executed
 // Otherwise the operation will throw an info log and wait for a future tick.
-func (tw *WorkerEVM) execute(ctx context.Context, op []*contracts.RBACTimelockCallScheduled) {
-	isReady, err := isReady(ctx, tw.contract, op[0].Id)
+func (tw *WorkerEVM) execute(ctx context.Context, op []TimelockCallScheduled) {
+	if len(op) == 0 {
+		tw.logger.Warn("no calls given")
+		return
+	}
+	opId := op[0].Id()
+
+	isReady, err := isReady(ctx, tw.contract, opId)
 	if err != nil {
-		tw.logger.Errorw("unable to read operation %x \"ready\" status: %s", op[0].Id, err.Error())
+		tw.logger.Errorw("unable to read operation %x \"ready\" status: %s", opId, err.Error())
 		return
 	}
 	if !isReady {
-		tw.logger.Infof("skipping operation %x: not ready", op[0].Id)
+		tw.logger.Infof("skipping operation %x: not ready", opId)
 		return
 	}
 
-	tw.logger.Debugf("execute operation %x", op[0].Id)
+	tw.logger.Debugf("execute operation %x", opId)
 
 	tx, err := tw.executeCallSchedule(ctx, &tw.executeContract.RBACTimelockTransactor, op, tw.privateKey)
 	if err != nil || tx == nil {
-		tw.logger.Errorf("execute operation %x error: %s", op[0].Id, err.Error())
+		tw.logger.Errorf("execute operation %x error: %s", opId, err.Error())
 	} else {
-		tw.logger.Infof("execute operation %x success: %s", op[0].Id, tx.Hash())
+		tw.logger.Infof("execute operation %x success: %s", opId, tx.Hash())
 
 		_, err := Retry(ctx, func(rctx context.Context) (*types.Receipt, error) {
 			return bind.WaitMined(rctx, tw.ethClient, tx)
 		})
 		if err != nil {
-			tw.logger.Errorf("execute operation %x error: %s", op[0].Id, err.Error())
+			tw.logger.Errorf("execute operation %x error: %s", opId, err.Error())
 		}
 	}
 }
 
 // executeCallScheduleOperation is the handler to execute a CallScheduled operation.
-func (tw *WorkerEVM) executeCallSchedule(ctx context.Context, c *contracts.RBACTimelockTransactor, cs []*contracts.RBACTimelockCallScheduled, privateKey *ecdsa.PrivateKey) (*types.Transaction, error) {
+func (tw *WorkerEVM) executeCallSchedule(
+	ctx context.Context, c *contracts.RBACTimelockTransactor, cs []TimelockCallScheduled, privateKey *ecdsa.PrivateKey,
+) (*types.Transaction, error) {
 	fromAddress, err := privateKeyToAddress(privateKey)
 	if err != nil {
 		return nil, err
@@ -57,10 +65,15 @@ func (tw *WorkerEVM) executeCallSchedule(ctx context.Context, c *contracts.RBACT
 	// Compute all the different calls from each specific CallSchedule.
 	calls := make([]contracts.RBACTimelockCall, 0, len(cs))
 	for _, op := range cs {
+		evmOp, ok := op.(*evmTimelockCallScheduled)
+		if !ok {
+			return nil, fmt.Errorf("invalid operation type: %T (expected *evm.RBACTimelockCallScheduled)", op)
+		}
+
 		calls = append(calls, contracts.RBACTimelockCall{
-			Target: op.Target,
-			Value:  op.Value,
-			Data:   op.Data,
+			Target: evmOp.callScheduled.Target,
+			Value:  evmOp.callScheduled.Value,
+			Data:   evmOp.callScheduled.Data,
 		})
 	}
 
@@ -85,9 +98,12 @@ func (tw *WorkerEVM) executeCallSchedule(ctx context.Context, c *contracts.RBACT
 	tw.logger.Infof("Calling execute Batch...")
 	// Execute the tx's with all the computed calls.
 	// Predecessor and salt are the same for all the tx's.
+	predecessor := cs[0].(*evmTimelockCallScheduled).callScheduled.Predecessor
+	salt := cs[0].(*evmTimelockCallScheduled).callScheduled.Salt
+
 	return Retry(ctx, func(rctx context.Context) (*types.Transaction, error) {
 		txOpts.Context = rctx
-		return c.ExecuteBatch(txOpts, calls, cs[0].Predecessor, cs[0].Salt)
+		return c.ExecuteBatch(txOpts, calls, predecessor, salt)
 	})
 }
 

pkg/timelock/scheduler.go

@@ -5,36 +5,42 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"math/big"
 	"os"
 	"slices"
-	"sort"
 	"sync"
 	"time"
 
-	contracts "github.com/smartcontractkit/ccip-owner-contracts/gethwrappers"
 	"go.uber.org/zap"
 )
 
 type operationKey [32]byte
 
+type TimelockCallScheduled interface {
+	Id() operationKey
+	Index() int
+	BlockNumber() *big.Int
+	TxHash() string
+}
+
 type Scheduler interface {
 	runScheduler(ctx context.Context) <-chan struct{}
-	addToScheduler(op *contracts.RBACTimelockCallScheduled)
+	addToScheduler(op TimelockCallScheduled)
 	delFromScheduler(op operationKey)
 	dumpOperationStore(now func() time.Time)
 }
 
-type executeFn func(context.Context, []*contracts.RBACTimelockCallScheduled)
+type executeFn func(context.Context, []TimelockCallScheduled)
 
 // Scheduler represents a scheduler with an in memory store.
 // Whenever accesing the map the mutex should be Locked, to prevent
 // any race condition.
 type scheduler struct {
 	mu        sync.Mutex
 	ticker    *time.Ticker
-	add       chan *contracts.RBACTimelockCallScheduled
+	add       chan TimelockCallScheduled
 	del       chan operationKey
-	store     map[operationKey][]*contracts.RBACTimelockCallScheduled
+	store     map[operationKey][]TimelockCallScheduled
 	busy      bool
 	logger    *zap.SugaredLogger
 	executeFn executeFn
@@ -44,9 +50,9 @@ type scheduler struct {
 func newScheduler(tick time.Duration, logger *zap.SugaredLogger, executeFn executeFn) *scheduler {
 	s := &scheduler{
 		ticker:    time.NewTicker(tick),
-		add:       make(chan *contracts.RBACTimelockCallScheduled),
+		add:       make(chan TimelockCallScheduled),
 		del:       make(chan operationKey),
-		store:     make(map[operationKey][]*contracts.RBACTimelockCallScheduled),
+		store:     make(map[operationKey][]TimelockCallScheduled),
 		busy:      false,
 		logger:    logger,
 		executeFn: executeFn,
@@ -88,12 +94,12 @@ func (tw *scheduler) runScheduler(ctx context.Context) <-chan struct{} {
 
 			case op := <-tw.add:
 				tw.mu.Lock()
-				for len(tw.store[op.Id]) <= int(op.Index.Int64()) {
-					tw.store[op.Id] = append(tw.store[op.Id], op)
+				for len(tw.store[op.Id()]) <= op.Index() {
+					tw.store[op.Id()] = append(tw.store[op.Id()], op)
 				}
-				tw.store[op.Id][op.Index.Int64()] = op
+				tw.store[op.Id()][op.Index()] = op
 				tw.mu.Unlock()
-				tw.logger.Debugf("scheduled operation: %x", op.Id)
+				tw.logger.Debugf("scheduled operation: %x", op.Id())
 
 			case op := <-tw.del:
 				if _, ok := tw.store[op]; ok {
@@ -125,8 +131,8 @@ func (tw *scheduler) updateSchedulerDelay(t time.Duration) {
 }
 
 // addToScheduler adds a new CallSchedule operation safely to the store.
-func (tw *scheduler) addToScheduler(op *contracts.RBACTimelockCallScheduled) {
-	tw.logger.Debugf("scheduling operation: %x", op.Id)
+func (tw *scheduler) addToScheduler(op TimelockCallScheduled) {
+	tw.logger.Debugf("scheduling operation: %x", op.Id())
 	tw.add <- op
 }
 
@@ -171,11 +177,11 @@ func (tw *scheduler) dumpOperationStore(now func() time.Time) {
 	tw.logger.Infof("generating logs with pending operations in %s", logPath+logFile)
 
 	// Get the earliest block from all the operations stored by sorting them.
-	blocks := make([]uint64, 0)
+	blocks := make([]*big.Int, 0)
 	for _, op := range tw.store {
-		blocks = append(blocks, op[0].Raw.BlockNumber)
+		blocks = append(blocks, op[0].BlockNumber())
 	}
-	slices.Sort(blocks)
+	slices.SortFunc(blocks, func(a, b *big.Int) int { return a.Cmp(b) })
 
 	w := bufio.NewWriter(f)
 
@@ -185,22 +191,22 @@ func (tw *scheduler) dumpOperationStore(now func() time.Time) {
 }
 
 type storeRecord struct {
-	Block uint64
+	Block *big.Int
 	OpKey operationKey
-	Ops   []*contracts.RBACTimelockCallScheduled
+	Ops   []TimelockCallScheduled
 }
 
 // writeOperationStore writes the operations to the writer.
 func writeOperationStore(
 	w io.Writer,
 	logger *zap.SugaredLogger,
-	store map[operationKey][]*contracts.RBACTimelockCallScheduled,
-	earliest uint64,
+	store map[operationKey][]TimelockCallScheduled,
+	earliest *big.Int,
 	now func() time.Time,
 ) {
 	var (
 		err error
-		op  *contracts.RBACTimelockCallScheduled
+		op  TimelockCallScheduled
 		msg string
 	)
 
@@ -216,28 +222,24 @@ func writeOperationStore(
 			continue
 		}
 		storeRecords = append(storeRecords, storeRecord{
-			Block: ops[0].Raw.BlockNumber,
+			Block: ops[0].BlockNumber(),
 			OpKey: opID,
 			Ops:   ops,
 		})
 	}
-	sort.Slice(storeRecords, func(i, j int) bool {
-		return storeRecords[i].Block < storeRecords[j].Block
-	})
+	slices.SortFunc(storeRecords, func(a, b storeRecord) int { return a.Block.Cmp(b.Block) })
 
 	for _, record := range storeRecords {
 		op = record.Ops[0]
 
-		if op.Raw.BlockNumber == earliest {
+		if op.BlockNumber().Cmp(earliest) == 0 {
 			logLine := fmt.Sprintf("earliest unexecuted CallSchedule. Use this block number when "+
 				"spinning up the service again, with the environment variable or in timelock.env as FROM_BLOCK=%v, "+
-				"or using the flag --from-block=%v", op.Raw.BlockNumber, op.Raw.BlockNumber)
-			logger.With(fieldTXHash, fmt.Sprintf("%x", op.Raw.TxHash[:])).
-				With(fieldBlockNumber, op.Raw.BlockNumber).Info(logLine)
+				"or using the flag --from-block=%v", op.BlockNumber(), op.BlockNumber())
+			logger.With(fieldTXHash, op.TxHash()).With(fieldBlockNumber, op.BlockNumber()).Info(logLine)
 			msg = toEarliestRecord(op)
 		} else {
-			logger.With(fieldTXHash, fmt.Sprintf("%x", op.Raw.TxHash[:])).
-				With(fieldBlockNumber, op.Raw.BlockNumber).Info("CallSchedule pending")
+			logger.With(fieldTXHash, op.TxHash()).With(fieldBlockNumber, op.BlockNumber()).Info("CallSchedule pending")
 			msg = toSubsequentRecord(op)
 		}
 
@@ -249,17 +251,17 @@ func writeOperationStore(
 }
 
 // toEarliestRecord returns a string with the earliest record.
-func toEarliestRecord(op *contracts.RBACTimelockCallScheduled) string {
+func toEarliestRecord(op TimelockCallScheduled) string {
 	tmpl := "Earliest CallSchedule pending ID: %x\tBlock Number: %v\n" +
 		"\tUse this block number to ensure all pending operations are properly executed.  " +
 		"\tSet it as environment variable or in timelock.env with FROM_BLOCK=%v, or as a flag with --from-block=%v\n"
 
-	return fmt.Sprintf(tmpl, op.Id, op.Raw.BlockNumber, op.Raw.BlockNumber, op.Raw.BlockNumber)
+	return fmt.Sprintf(tmpl, op.Id(), op.BlockNumber(), op.BlockNumber(), op.BlockNumber())
 }
 
 // toSubsequentRecord returns a string for use with each subsequent record sent to a writer.
-func toSubsequentRecord(op *contracts.RBACTimelockCallScheduled) string {
-	return fmt.Sprintf("CallSchedule pending ID: %x\tBlock Number: %v\n", op.Id, op.Raw.BlockNumber)
+func toSubsequentRecord(op TimelockCallScheduled) string {
+	return fmt.Sprintf("CallSchedule pending ID: %x\tBlock Number: %v\n", op.Id(), op.BlockNumber())
 }
 
 // ----- nop scheduler -----
@@ -284,7 +286,7 @@ func (s *nopScheduler) runScheduler(ctx context.Context) <-chan struct{} {
 	return ch
 }
 
-func (s *nopScheduler) addToScheduler(op *contracts.RBACTimelockCallScheduled) {
+func (s *nopScheduler) addToScheduler(op TimelockCallScheduled) {
 	s.logger.With("op", op).Info("nop.addToScheduler")
 }
 

pkg/timelock/scheduler_evm.go

@@ -0,0 +1,36 @@
+package timelock
+
+import (
+	"fmt"
+	"math/big"
+
+	bindings "github.com/smartcontractkit/ccip-owner-contracts/gethwrappers"
+)
+
+var _ TimelockCallScheduled = NewEVMTimelockCallScheduled(nil)
+
+type evmTimelockCallScheduled struct {
+	callScheduled *bindings.RBACTimelockCallScheduled
+}
+
+func NewEVMTimelockCallScheduled(callScheduled *bindings.RBACTimelockCallScheduled) TimelockCallScheduled {
+	return &evmTimelockCallScheduled{
+		callScheduled: callScheduled,
+	}
+}
+
+func (cs *evmTimelockCallScheduled) Id() operationKey {
+	return cs.callScheduled.Id
+}
+
+func (cs *evmTimelockCallScheduled) Index() int {
+	return int(cs.callScheduled.Index.Int64())
+}
+
+func (cs *evmTimelockCallScheduled) BlockNumber() *big.Int {
+	return new(big.Int).SetUint64(cs.callScheduled.Raw.BlockNumber)
+}
+
+func (cs *evmTimelockCallScheduled) TxHash() string {
+	return fmt.Sprintf("%x", cs.callScheduled.Raw.TxHash[:])
+}

pkg/timelock/scheduler_evm_test.go

@@ -0,0 +1,54 @@
+package timelock
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/core/types"
+	bindings "github.com/smartcontractkit/ccip-owner-contracts/gethwrappers"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewEVMTimelockCallScheduled(t *testing.T) {
+	callScheduled := makeTestCallScheduled()
+	evmCallScheduled := NewEVMTimelockCallScheduled(callScheduled)
+	assert.NotNil(t, evmCallScheduled)
+}
+
+func TestEVMTimelockCallScheduled_Id(t *testing.T) {
+	callScheduled := makeTestCallScheduled()
+	evmCallScheduled := NewEVMTimelockCallScheduled(callScheduled)
+	assert.Equal(t, operationKey(callScheduled.Id), evmCallScheduled.Id())
+}
+
+func TestEVMTimelockCallScheduled_Index(t *testing.T) {
+	callScheduled := makeTestCallScheduled()
+	evmCallScheduled := NewEVMTimelockCallScheduled(callScheduled)
+	assert.Equal(t, 42, evmCallScheduled.Index())
+}
+
+func TestEVMTimelockCallScheduled_BlockNumber(t *testing.T) {
+	callScheduled := makeTestCallScheduled()
+	evmCallScheduled := NewEVMTimelockCallScheduled(callScheduled)
+	assert.Equal(t, big.NewInt(123456), evmCallScheduled.BlockNumber())
+}
+
+func TestEVMTimelockCallScheduled_TxHash(t *testing.T) {
+	callScheduled := makeTestCallScheduled()
+	evmCallScheduled := NewEVMTimelockCallScheduled(callScheduled)
+	expected := "aabbcc0000000000000000000000000000000000000000000000000000000000"
+	assert.Equal(t, expected, evmCallScheduled.TxHash())
+}
+
+// ----- helpers ------
+
+func makeTestCallScheduled() *bindings.RBACTimelockCallScheduled {
+	return &bindings.RBACTimelockCallScheduled{
+		Id:    [32]byte{1, 2, 3},
+		Index: big.NewInt(42),
+		Raw: types.Log{
+			BlockNumber: 123456,
+			TxHash:      [32]byte{0xaa, 0xbb, 0xcc},
+		},
+	}
+}