deploy_factory_and_set_owner_to_mcms.go

package changesets

import (
	"fmt"
	"time"

	"github.com/smartcontractkit/mcms"
	cantonsdk "github.com/smartcontractkit/mcms/sdk/canton"
	mcms_types "github.com/smartcontractkit/mcms/types"

	"github.com/smartcontractkit/chainlink-deployments-framework/datastore"
	cldf "github.com/smartcontractkit/chainlink-deployments-framework/deployment"
	"github.com/smartcontractkit/chainlink-deployments-framework/operations"

	factorybindings "github.com/smartcontractkit/chainlink-canton/bindings/generated/latest/ccip/factory"
	factoryops "github.com/smartcontractkit/chainlink-canton/deployment/operations/ccip/factory"
	dsutils "github.com/smartcontractkit/chainlink-canton/deployment/utils/datastore"
	cantonmcms "github.com/smartcontractkit/chainlink-canton/deployment/utils/mcms"
	opcontract "github.com/smartcontractkit/chainlink-canton/deployment/utils/operations/contract"
)

// DeployFactoryAndSetOwnerToMCMS deploys a CCIPFactory and returns an MCMS proposal to transfer
// ownership via SetOwnerToMCMS (controller = mcmsParty).
type DeployFactoryAndSetOwnerToMCMSConfig struct {
	OwnerParty string        `json:"ownerParty" yaml:"ownerParty"`
	MCMSParty  string        `json:"mcmsParty" yaml:"mcmsParty"`
	InstanceID string        `json:"instanceID,omitempty" yaml:"instanceID,omitempty"`
	Qualifier  string        `json:"qualifier,omitempty" yaml:"qualifier,omitempty"`
	MinDelay   time.Duration `json:"minDelay,omitempty" yaml:"minDelay,omitempty"`
}

type DeployFactoryAndSetOwnerToMCMS struct{}

var _ cldf.ChangeSetV2[CantonCSDeps[DeployFactoryAndSetOwnerToMCMSConfig]] = DeployFactoryAndSetOwnerToMCMS{}

func (d DeployFactoryAndSetOwnerToMCMS) VerifyPreconditions(e cldf.Environment, config CantonCSDeps[DeployFactoryAndSetOwnerToMCMSConfig]) error {
	chain, ok := e.BlockChains.CantonChains()[config.ChainSelector]
	if !ok {
		return fmt.Errorf("canton chain %v not found", config.ChainSelector)
	}
	if config.Participant < 0 || config.Participant >= len(chain.Participants) {
		return fmt.Errorf("participant index %d out of range for canton chain %d with %d participants",
			config.Participant, config.ChainSelector, len(chain.Participants))
	}
	if config.Config.OwnerParty == "" {
		return fmt.Errorf("owner party is required")
	}
	if config.Config.MCMSParty == "" {
		return fmt.Errorf("mcms party is required")
	}
	if config.Config.Qualifier == "" {
		return fmt.Errorf("factory qualifier is required")
	}
	mcmsOwnerQualifier, err := mcmsOwnerQualifierForFactory(config.Config.Qualifier)
	if err != nil {
		return err
	}
	if _, err := dsutils.MCMSRawInstanceAddress(e.DataStore, config.ChainSelector, mcmsOwnerQualifier); err != nil {
		return fmt.Errorf("MCMS contract not found in datastore (deploy MCMS first): %w", err)
	}
	if config.Config.MinDelay <= 0 {
		return fmt.Errorf("minDelay must be greater than zero")
	}

	return nil
}

func (d DeployFactoryAndSetOwnerToMCMS) Apply(e cldf.Environment, config CantonCSDeps[DeployFactoryAndSetOwnerToMCMSConfig]) (cldf.ChangesetOutput, error) {
	ds := datastore.NewMemoryDataStore()
	chain := e.BlockChains.CantonChains()[config.ChainSelector]
	cfg := config.Config

	factoryRef, err := dsutils.FactoryAddressRef(e.DataStore, config.ChainSelector, cfg.Qualifier)
	if err != nil {
		factoryRef, err = deployCCIPFactory(e.OperationsBundle, chain, DeployCCIPFactoryParams{
			OwnerParty: cfg.OwnerParty,
			MCMSParty:  cfg.MCMSParty,
			InstanceID: cfg.InstanceID,
			Qualifier:  cfg.Qualifier,
		})
		if err != nil {
			return cldf.ChangesetOutput{}, err
		}
		if err := ds.AddressRefStore.Add(factoryRef); err != nil {
			return cldf.ChangesetOutput{}, fmt.Errorf("store address ref: %w", err)
		}
	}

	factoryRawAddr, err := dsutils.GetRawInstanceAddressFromAddressRef(factoryRef)
	if err != nil {
		return cldf.ChangesetOutput{}, fmt.Errorf("factory raw instance address: %w", err)
	}

	// Encode SetOwnerToMCMS for MCMS proposal submission.
	exerciseOut, err := operations.ExecuteOperation(e.OperationsBundle, factoryops.SetOwnerToMCMS, chain, opcontract.ChoiceInput[factorybindings.SetOwnerToMCMS]{
		InstanceAddress:    factoryRawAddr.InstanceAddress(),
		RawInstanceAddress: factoryRawAddr.String(),
		Args:               factorybindings.SetOwnerToMCMS{},
		MCMSEnabled:        true,
	})
	if err != nil {
		return cldf.ChangesetOutput{}, fmt.Errorf("encode SetOwnerToMCMS: %w", err)
	}

	batchOp, err := cantonmcms.BuildBatchFromOutputs([]opcontract.ExerciseOutput{exerciseOut.Output})
	if err != nil {
		return cldf.ChangesetOutput{}, fmt.Errorf("build batch operation: %w", err)
	}

	mcmsOwnerQualifier, err := mcmsOwnerQualifierForFactory(cfg.Qualifier)
	if err != nil {
		return cldf.ChangesetOutput{}, err
	}
	mcmsRawAddr, err := dsutils.MCMSRawInstanceAddress(e.DataStore, config.ChainSelector, mcmsOwnerQualifier)
	if err != nil {
		return cldf.ChangesetOutput{}, fmt.Errorf("MCMS contract not found: %w", err)
	}

	participant := chain.Participants[config.Participant]
	proposal, err := cantonmcms.GenerateTimelockProposal(
		e.GetContext(),
		participant.LedgerServices.State,
		opcontract.LedgerQueryParties(participant),
		cantonmcms.ProposalConfig{
			MCMSContract: cantonmcms.MCMSContractInfo{
				RawInstanceAddress: mcmsRawAddr,
				InstanceAddress:    mcmsRawAddr.InstanceAddress(),
			},
			ChainSelector: mcms_types.ChainSelector(config.ChainSelector),
			Description:   fmt.Sprintf("Transfer CCIPFactory (%s) ownership to MCMS", cfg.Qualifier),
			MinDelay:      cfg.MinDelay,
			Action:        mcms_types.TimelockActionSchedule,
			Role:          cantonsdk.TimelockRoleProposer,
		},
		[]mcms_types.BatchOperation{batchOp},
	)
	if err != nil {
		return cldf.ChangesetOutput{}, fmt.Errorf("generate SetOwnerToMCMS proposal: %w", err)
	}

	return cldf.ChangesetOutput{
		DataStore:             ds,
		MCMSTimelockProposals: []mcms.TimelockProposal{*proposal},
	}, nil
}