feat: add utils to generate cancel / bypass proposals from timelock schedule proposal (#342)

add utils to generate cancel / bypass proposals from timelock schedule
proposal

## AI Summary
This pull request introduces new methods to the `TimelockProposal`
struct in `timelock_proposal.go` to enhance its functionality. The most
significant changes include the addition of methods to derive
cancellation and bypass proposals from an existing proposal.

Enhancements to `TimelockProposal`:

* Added `DeriveCancellationProposal` method to derive a new proposal
that cancels the current proposal. This method ensures the original
proposal remains unaffected and returns an error if the action is not of
type 'schedule'.
* Added `DeriveBypassProposal` method to derive a new proposal that
bypasses the current proposal. Similar to the cancellation method, it
ensures the original proposal remains unaffected and returns an error if
the action is not of type 'schedule'.

Author: ecPablo

.changeset/shy-suits-join.md

@@ -0,0 +1,5 @@
+---
+"@smartcontractkit/mcms": minor
+---
+
+Add proposal cancel and bypass helpers

timelock_proposal.go

@@ -17,6 +17,7 @@ import (
 )
 
 var ZERO_HASH = common.Hash{}
+var DefaultValidUntil = 72 * time.Hour
 
 type TimelockProposal struct {
 	BaseProposal
@@ -105,6 +106,59 @@ func (m *TimelockProposal) Validate() error {
 
 	return nil
 }
+func replaceChainMetadataWithAddresses(p *TimelockProposal, addresses map[types.ChainSelector]types.ChainMetadata) error {
+	for chain := range p.ChainMetadata {
+		newMeta, ok := addresses[chain]
+		if !ok {
+			return fmt.Errorf("cannot replace addresses in chain metadata, missing address for chain %d", chain)
+		}
+		p.ChainMetadata[chain] = newMeta
+	}
+
+	return nil
+}
+
+// deriveNewProposal creates a copy of the current proposal with overridden action, signatures, salt, and metadata.
+func (m *TimelockProposal) deriveNewProposal(action types.TimelockAction, metadata map[types.ChainSelector]types.ChainMetadata) (TimelockProposal, error) {
+	// Create a copy of the current proposal, we don't want to affect the original proposal
+	newProposal := *m
+	newProposal.Signatures = []types.Signature{}
+	ts := time.Now().Add(DefaultValidUntil).Unix()
+	ts32, err := safecast.Int64ToUint32(ts)
+	if err != nil {
+		return TimelockProposal{}, err
+	}
+	// #nosec G115
+	newProposal.ValidUntil = ts32
+	bytesSalt := m.Salt()
+	salt := common.BytesToHash(bytesSalt[:])
+	newProposal.SaltOverride = &salt
+	newProposal.Action = action
+	err = replaceChainMetadataWithAddresses(&newProposal, metadata)
+	if err != nil {
+		return TimelockProposal{}, err
+	}
+
+	return newProposal, nil
+}
+
+// DeriveCancellationProposal derives a new proposal that cancels the current proposal.
+func (m *TimelockProposal) DeriveCancellationProposal(cancellerMetadata map[types.ChainSelector]types.ChainMetadata) (TimelockProposal, error) {
+	if m.Action != types.TimelockActionSchedule {
+		return TimelockProposal{}, fmt.Errorf("cannot derive a cancellation proposal from a non-schedule proposal. Action needs to be of type 'schedule'")
+	}
+
+	return m.deriveNewProposal(types.TimelockActionCancel, cancellerMetadata)
+}
+
+// DeriveBypassProposal derives a new proposal that bypasses the current proposal.
+func (m *TimelockProposal) DeriveBypassProposal(bypasserAddresses map[types.ChainSelector]types.ChainMetadata) (TimelockProposal, error) {
+	if m.Action != types.TimelockActionSchedule {
+		return TimelockProposal{}, fmt.Errorf("cannot derive a bypass proposal from a non-schedule proposal. Action needs to be of type 'schedule'")
+	}
+
+	return m.deriveNewProposal(types.TimelockActionBypass, bypasserAddresses)
+}
 
 // Convert the proposal to an MCMS only proposal and also return all predecessors for easy access later.
 // Every transaction to be sent from the Timelock is encoded with the corresponding timelock method.

timelock_proposal_test.go

@@ -930,3 +930,132 @@ func TestProposal_WithoutSaltOverride(t *testing.T) {
 	assert.NotNil(t, saltBytes)
 	assert.NotEqual(t, common.Hash{}, saltBytes)
 }
+
+func buildDummyProposal(action types.TimelockAction) TimelockProposal {
+	builder := NewTimelockProposalBuilder()
+	builder.SetVersion("v1").
+		SetValidUntil(2004259681).
+		SetDescription("Test proposal").
+		SetChainMetadata(map[types.ChainSelector]types.ChainMetadata{
+			chaintest.Chain2Selector: {
+				StartingOpCount: 0,
+				MCMAddress:      "0x0000000000000000000000000000000000000000",
+			},
+		}).
+		SetOverridePreviousRoot(false).
+		SetAction(action).
+		SetDelay(types.MustParseDuration("1h")).
+		AddTimelockAddress(chaintest.Chain2Selector, "0x01").
+		SetOperations([]types.BatchOperation{{
+			ChainSelector: chaintest.Chain2Selector,
+			Transactions: []types.Transaction{
+				{
+					To:               "0x0000000000000000000000000000000000000000",
+					AdditionalFields: []byte(`{"value": 0}`),
+					Data:             []byte("data"),
+				},
+			},
+		}})
+	proposal, err := builder.Build()
+	if err != nil {
+		panic(err)
+	}
+
+	return *proposal
+}
+
+func TestDeriveBypassProposal(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name       string
+		proposal   TimelockProposal
+		wantErr    bool
+		wantAction types.TimelockAction
+	}{
+		{
+			name:       "valid schedule action",
+			proposal:   buildDummyProposal(types.TimelockActionSchedule),
+			wantErr:    false,
+			wantAction: types.TimelockActionBypass,
+		},
+		{
+			name:       "invalid non-schedule action",
+			proposal:   buildDummyProposal(types.TimelockActionCancel),
+			wantErr:    true,
+			wantAction: types.TimelockActionBypass,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			dummyAddressess := map[types.ChainSelector]types.ChainMetadata{
+				chaintest.Chain2Selector: {
+					StartingOpCount: 1,
+					MCMAddress:      "0x0000000000000000000000000000000000000001",
+				},
+			}
+			newProposal, err := tt.proposal.DeriveBypassProposal(dummyAddressess)
+			if tt.wantErr {
+				require.Error(t, err)
+				assert.EqualError(t, err, "cannot derive a bypass proposal from a non-schedule proposal. Action needs to be of type 'schedule'")
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.wantAction, newProposal.Action)
+				assert.Empty(t, newProposal.Signatures)
+				assert.NotEqual(t, tt.proposal, newProposal)
+				assert.Equal(t, newProposal.Salt(), tt.proposal.Salt())
+				assert.Equal(t, dummyAddressess, newProposal.ChainMetadata)
+			}
+		})
+	}
+}
+
+func TestDeriveCancellationProposal(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name       string
+		proposal   TimelockProposal
+		wantErr    bool
+		wantAction types.TimelockAction
+	}{
+		{
+			name:       "valid schedule action",
+			proposal:   buildDummyProposal(types.TimelockActionSchedule),
+			wantErr:    false,
+			wantAction: types.TimelockActionCancel,
+		},
+		{
+			name:       "invalid non-schedule action",
+			proposal:   buildDummyProposal(types.TimelockActionCancel),
+			wantErr:    true,
+			wantAction: types.TimelockActionCancel,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			dummyAddressess := map[types.ChainSelector]types.ChainMetadata{
+				chaintest.Chain2Selector: {
+					StartingOpCount: 1,
+					MCMAddress:      "0x0000000000000000000000000000000000000001",
+				},
+			}
+			newProposal, err := tt.proposal.DeriveCancellationProposal(dummyAddressess)
+			if tt.wantErr {
+				require.Error(t, err)
+				assert.EqualError(t, err, "cannot derive a cancellation proposal from a non-schedule proposal. Action needs to be of type 'schedule'")
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.wantAction, newProposal.Action)
+				assert.Empty(t, newProposal.Signatures)
+				assert.NotEqual(t, tt.proposal, newProposal)
+				assert.Equal(t, newProposal.Salt(), tt.proposal.Salt())
+				assert.Equal(t, dummyAddressess, newProposal.ChainMetadata)
+			}
+		})
+	}
+}