Add 3x MCMS structure to deployer/reader/state (#601)

* Add 3x MCMS structure to deployer/reader/state

* Refactor common DeployMCMS seq

* Add ton/ops/mcms/set-config op

* Remove unused MCMS cs/test

* Polish & fix lint

* go mod tidy

* Fix tlbe.Cell[T] marshalling

* Use tvm.Getter in test, check output addr

* Add MCMS to transfer ownership test

* Fix full message plan vs body

* Check MCMS config post deployemnt

* Fix MCMS deploy seq addrs state

* Fix tests/env, add setConfig op test

* Fix/imporve CLDF idempotency - use unique series ID

* Fix lint

* Add wait option to ton/ops/send-messages

* PR feedback

Author: krebernisak

.github/workflows/ccip-integration-test.yml

@@ -16,7 +16,7 @@ env:
   DOCKER_CACHE_TAR_NAME: ccip-e2e-docker-images.tar
   # mylocalton docker image / CCIP E2E test database image
   DOCKER_IMAGES: >-
-    ghcr.io/neodix42/mylocalton-docker:v3.99
+    ghcr.io/neodix42/mylocalton-docker:v4.0.0
     postgres:16-alpine
 jobs:
   prepare-images:

deployment/ccip/1_6_0/sequences/mcms.go

@@ -2,89 +2,89 @@ package sequences
 
 import (
 	"fmt"
-	"math"
 
 	"github.com/Masterminds/semver/v3"
-
 	"github.com/xssnick/tonutils-go/address"
 
-	cldf_chain "github.com/smartcontractkit/chainlink-deployments-framework/chain"
-	"github.com/smartcontractkit/chainlink-deployments-framework/chain/ton"
-	"github.com/smartcontractkit/chainlink-deployments-framework/datastore"
-	"github.com/smartcontractkit/chainlink-deployments-framework/operations"
-
-	"github.com/smartcontractkit/chainlink-ccip/deployment/deploy"
-	cciputils "github.com/smartcontractkit/chainlink-ccip/deployment/utils"
-	"github.com/smartcontractkit/chainlink-ccip/deployment/utils/sequences"
+	cldfchain "github.com/smartcontractkit/chainlink-deployments-framework/chain"
+	cldfton "github.com/smartcontractkit/chainlink-deployments-framework/chain/ton"
+	cldfds "github.com/smartcontractkit/chainlink-deployments-framework/datastore"
+	cldfops "github.com/smartcontractkit/chainlink-deployments-framework/operations"
 
-	"github.com/smartcontractkit/chainlink-ton/pkg/bindings/mcms/timelock"
+	ccipddeploy "github.com/smartcontractkit/chainlink-ccip/deployment/deploy"
+	ccipdutils "github.com/smartcontractkit/chainlink-ccip/deployment/utils"
+	ccipdseq "github.com/smartcontractkit/chainlink-ccip/deployment/utils/sequences"
 
-	tonops "github.com/smartcontractkit/chainlink-ton/deployment/ccip"
-	mcmsConfig "github.com/smartcontractkit/chainlink-ton/deployment/mcms/config"
-	mcmsSeq "github.com/smartcontractkit/chainlink-ton/deployment/mcms/sequence"
 	"github.com/smartcontractkit/chainlink-ton/deployment/pkg/dep"
+	opsmcms "github.com/smartcontractkit/chainlink-ton/deployment/pkg/ops/mcms"
 	"github.com/smartcontractkit/chainlink-ton/deployment/state"
-)
 
-// defaultMCMSContractCoin is the default amount of TON coins to allocate for MCMS contract deployment.
-// MCMS contracts require more storage and operational capacity, hence the higher allocation compared to CCIP contracts.
-const defaultMCMSContractCoin = "1.5"
+	"github.com/smartcontractkit/chainlink-ton/pkg/ton/tvm"
+)
 
-func (a *TonDeployAdapter) DeployMCMS() *operations.Sequence[deploy.MCMSDeploymentConfigPerChainWithAddress, sequences.OnChainOutput, cldf_chain.BlockChains] {
+func (a *TonDeployAdapter) DeployMCMS() *cldfops.Sequence[ccipddeploy.MCMSDeploymentConfigPerChainWithAddress, ccipdseq.OnChainOutput, cldfchain.BlockChains] {
 	return DeployMCMSContracts
 }
 
-var DeployMCMSContracts = operations.NewSequence(
+var DeployMCMSContracts = cldfops.NewSequence(
 	"ton/sequences/ccip/tooling-api/deploy-mcms",
 	semver.MustParse("0.0.4"), // TODO mcms and timelock has different versions, can we pick mcms version here?
 	"Deploys all MCM contracts with config",
-	func(b operations.Bundle, chains cldf_chain.BlockChains, input deploy.MCMSDeploymentConfigPerChainWithAddress) (output sequences.OnChainOutput, err error) {
+	func(b cldfops.Bundle, chains cldfchain.BlockChains, input ccipddeploy.MCMSDeploymentConfigPerChainWithAddress) (output ccipdseq.OnChainOutput, err error) {
 		chain := chains.TonChains()[input.ChainSelector]
 
-		qualifier := cciputils.CLLQualifier // default
-		if input.Qualifier != nil {
-			qualifier = *input.Qualifier
+		defaultQualifier := ccipdutils.CLLQualifier
+		if input.Qualifier == nil {
+			input.Qualifier = &defaultQualifier
 		}
 
-		stateMCMS, err := extractMCMSChainStateFromMCMSDeploymentInput(chain, input.ExistingAddresses, qualifier)
+		stateMCMS, err := extractMCMSChainStateFromMCMSDeploymentInput(chain, input.ExistingAddresses, *input.Qualifier)
 		if err != nil {
-			return sequences.OnChainOutput{}, err
+			return ccipdseq.OnChainOutput{}, err
 		}
+
 		dp, err := dep.NewDependencyProvider(
 			dep.Provide(chain),
 			dep.Provide(stateMCMS[input.ChainSelector]),
 		)
 		if err != nil {
-			return sequences.OnChainOutput{}, fmt.Errorf("failed to create dependency provider: %w", err)
+			return ccipdseq.OnChainOutput{}, fmt.Errorf("failed to create dependency provider: %w", err)
 		}
 
-		_input, err := intoDeployMCMSSeqInput(input, chain.WalletAddress)
+		// Generate a random contract ID used for contracts in this deployment
+		contractID, err := tvm.RandomQueryID()
 		if err != nil {
-			return sequences.OnChainOutput{}, err
-		}
-		r, err := operations.ExecuteSequence(b, mcmsSeq.DeployMCMSSequence, dp, _input)
-		if err != nil {
-			return sequences.OnChainOutput{}, fmt.Errorf("failed to deploy MCMS for TON chain %d: %w", input.ChainSelector, err)
+			return ccipdseq.OnChainOutput{}, fmt.Errorf("failed to generate random contract ID: %w", err)
 		}
 
-		// Attach the qualifier to the output (to be stored in DS)
-		for i := range r.Output.Addresses {
-			r.Output.Addresses[i].Qualifier = qualifier
+		b.Logger.Info("in.TimelockAdmin - skipping param (EVM specific type - 20 bytes, not compatible with TON address format)")
+		b.Logger.Infof("in.TimelockAdmin - using deployer address %s as initial admin", chain.WalletAddress)
+
+		r, err := cldfops.ExecuteSequence(b, opsmcms.DeployMCMSSequence, dp, opsmcms.DeployMCMSSeqInput{
+			Config:                  input.MCMSDeploymentConfigPerChain,
+			ContractID:              uint32(contractID),
+			ContractsSemverMCMS:     &state.MCMSVersion,
+			ContractsSemverTimelock: &state.TimelockVersion,
+		})
+		if err != nil {
+			return ccipdseq.OnChainOutput{}, fmt.Errorf("failed to deploy MCMS for TON chain %d: %w", input.ChainSelector, err)
 		}
 
-		return sequences.OnChainOutput{
-			Addresses: r.Output.Addresses,
-			BatchOps:  r.Output.BatchOps,
-		}, nil
+		return r.Output, nil
 	},
 )
 
 // TODO: unify and deduplicate with state.LoadMCMSOnChainState
-func extractMCMSChainStateFromMCMSDeploymentInput(chain ton.Chain, existing []datastore.AddressRef, qualifier string) (map[uint64]state.MCMSChainState, error) {
-	noneAddr := address.NewAddressNone()
+func extractMCMSChainStateFromMCMSDeploymentInput(chain cldfton.Chain, existing []cldfds.AddressRef, qualifier string) (map[uint64]state.MCMSChainState, error) {
+	none := address.NewAddressNone()
 	s := state.MCMSChainState{
 		ByQualifier: map[string]*state.MCMSSuiteState{
-			qualifier: {Timelock: noneAddr, MCMS: noneAddr},
+			qualifier: {
+				Proposer:  none,
+				Bypasser:  none,
+				Canceller: none,
+				Timelock:  none,
+			},
 		},
 	}
 
@@ -100,10 +100,14 @@ func extractMCMSChainStateFromMCMSDeploymentInput(chain ton.Chain, existing []da
 		}
 
 		switch e.Type {
-		case state.Timelock:
+		case cldfds.ContractType(ccipdutils.RBACTimelock):
 			s.ByQualifier[qualifier].Timelock = tonAddr
-		case state.MCMS:
-			s.ByQualifier[qualifier].MCMS = tonAddr
+		case cldfds.ContractType(ccipdutils.ProposerManyChainMultisig):
+			s.ByQualifier[qualifier].Proposer = tonAddr
+		case cldfds.ContractType(ccipdutils.BypasserManyChainMultisig):
+			s.ByQualifier[qualifier].Bypasser = tonAddr
+		case cldfds.ContractType(ccipdutils.CancellerManyChainMultisig):
+			s.ByQualifier[qualifier].Canceller = tonAddr
 		default:
 			// ignore unknown types
 		}
@@ -112,63 +116,26 @@ func extractMCMSChainStateFromMCMSDeploymentInput(chain ton.Chain, existing []da
 	return map[uint64]state.MCMSChainState{chain.Selector: s}, nil
 }
 
-func intoDeployMCMSSeqInput(cfg deploy.MCMSDeploymentConfigPerChainWithAddress, deployer *address.Address) (mcmsSeq.DeployMCMSSeqInput, error) {
-	// Generate a random contract ID for all contracts in this deployment
-	contractID, err := tonops.RandomUint32()
-	if err != nil {
-		return mcmsSeq.DeployMCMSSeqInput{}, fmt.Errorf("failed to generate random contract ID: %w", err)
-	}
-
-	// MinDelay from cfg.TimelockMinDelay (big.Int) to uint32 safely
-	var minDelay uint32
-	if cfg.TimelockMinDelay != nil && cfg.TimelockMinDelay.IsUint64() {
-		val := cfg.TimelockMinDelay.Uint64()
-		if val <= math.MaxUint32 {
-			minDelay = uint32(val)
-		} else {
-			// overflow, set to max
-			minDelay = math.MaxUint32
-		}
-	}
-
-	return mcmsSeq.DeployMCMSSeqInput{
-		ContractsVersionSha: cfg.ContractVersion,
-		ContractsParams: mcmsConfig.ChainContractParams{
-			Timelock: mcmsConfig.TimelockParams{
-				ID:              contractID,
-				Coin:            defaultMCMSContractCoin,
-				ContractsSemver: &state.TimelockVersion,
-				InitMessage: timelock.Init{
-					MinDelay: minDelay,
-					Admin:    deployer,
-				},
-			},
-			MCMS: mcmsConfig.MCMSParams{
-				ID:              contractID,
-				Coin:            defaultMCMSContractCoin,
-				ContractsSemver: &state.MCMSVersion,
-			},
-		},
-		ChainSelector: cfg.ChainSelector,
-	}, nil
-}
-
-func (a *TonDeployAdapter) FinalizeDeployMCMS() *operations.Sequence[deploy.MCMSDeploymentConfigPerChainWithAddress, sequences.OnChainOutput, cldf_chain.BlockChains] {
-	return operations.NewSequence(
+func (a *TonDeployAdapter) FinalizeDeployMCMS() *cldfops.Sequence[ccipddeploy.MCMSDeploymentConfigPerChainWithAddress, ccipdseq.OnChainOutput, cldfchain.BlockChains] {
+	return cldfops.NewSequence(
 		"ton/sequences/ccip/tooling-api/finalize-deploy-mcms",
 		semver.MustParse("1.0.0"),
 		"On TON, finalizing MCM deployment is a no-op",
-		func(b operations.Bundle, chains cldf_chain.BlockChains, in deploy.MCMSDeploymentConfigPerChainWithAddress) (output sequences.OnChainOutput, err error) {
+		func(b cldfops.Bundle, chains cldfchain.BlockChains, in ccipddeploy.MCMSDeploymentConfigPerChainWithAddress) (output ccipdseq.OnChainOutput, err error) {
 			return output, nil
 		})
 }
 
-func (a *TonDeployAdapter) GrantAdminRoleToTimelock() *operations.Sequence[deploy.GrantAdminRoleToTimelockConfigPerChainWithSelector, sequences.OnChainOutput, cldf_chain.BlockChains] {
-	return operations.NewSequence(
+func (a *TonDeployAdapter) GrantAdminRoleToTimelock() *cldfops.Sequence[ccipddeploy.GrantAdminRoleToTimelockConfigPerChainWithSelector, ccipdseq.OnChainOutput, cldfchain.BlockChains] {
+	return cldfops.NewSequence(
 		"ton/sequences/ccip/tooling-api/grant-admin-role-to-timelock",
 		semver.MustParse("1.0.0"),
 		"On TON, GrantAdminRoleToTimelock is a no-op",
-		func(b operations.Bundle, chains cldf_chain.BlockChains, in deploy.GrantAdminRoleToTimelockConfigPerChainWithSelector) (output sequences.OnChainOutput, err error) {
+		func(b cldfops.Bundle, chains cldfchain.BlockChains, in ccipddeploy.GrantAdminRoleToTimelockConfigPerChainWithSelector) (output ccipdseq.OnChainOutput, err error) {
+			// TODO:
+			//  - grant role to timelock
+			//  - renounce role from deployer key
+
 			return output, nil
 		})
 }

deployment/ccip/1_6_0/sequences/mcms_reader.go

@@ -3,37 +3,40 @@ package sequences
 import (
 	"fmt"
 
-	mcms_ton "github.com/smartcontractkit/mcms/sdk/ton"
+	mcmston "github.com/smartcontractkit/mcms/sdk/ton"
 	"github.com/smartcontractkit/mcms/types"
 
-	"github.com/smartcontractkit/chainlink-deployments-framework/datastore"
-	"github.com/smartcontractkit/chainlink-deployments-framework/deployment"
+	cldfds "github.com/smartcontractkit/chainlink-deployments-framework/datastore"
+	cldf "github.com/smartcontractkit/chainlink-deployments-framework/deployment"
 
-	"github.com/smartcontractkit/chainlink-ccip/deployment/utils/changesets"
-	datastore_utils "github.com/smartcontractkit/chainlink-ccip/deployment/utils/datastore"
-	mcms_utils "github.com/smartcontractkit/chainlink-ccip/deployment/utils/mcms"
+	ccipdutils "github.com/smartcontractkit/chainlink-ccip/deployment/utils"
+	ccipdcs "github.com/smartcontractkit/chainlink-ccip/deployment/utils/changesets"
+	ccipdds "github.com/smartcontractkit/chainlink-ccip/deployment/utils/datastore"
+	ccipdmcms "github.com/smartcontractkit/chainlink-ccip/deployment/utils/mcms"
 
 	"github.com/smartcontractkit/chainlink-ton/deployment/state"
 )
 
+var _ ccipdcs.MCMSReader = &MCMSReaderAdapter{}
+
 type MCMSReaderAdapter struct{}
 
 // GetChainMetadata returns the chain metadata for a given MCMS input.
-func (r *MCMSReaderAdapter) GetChainMetadata(e deployment.Environment, chainSelector uint64, input mcms_utils.Input) (types.ChainMetadata, error) {
-	chain, ok := e.BlockChains.TonChains()[chainSelector]
+func (r *MCMSReaderAdapter) GetChainMetadata(e cldf.Environment, cs uint64, input ccipdmcms.Input) (types.ChainMetadata, error) {
+	chain, ok := e.BlockChains.TonChains()[cs]
 	if !ok {
-		return types.ChainMetadata{}, fmt.Errorf("chain with selector %d not found in environment", chainSelector)
+		return types.ChainMetadata{}, fmt.Errorf("chain with selector %d not found in environment", cs)
 	}
 
-	mcmsAddr, err := r.GetMCMSRef(e, chainSelector, input)
+	mcmsAddr, err := r.GetMCMSRef(e, cs, input)
 	if err != nil {
-		return types.ChainMetadata{}, fmt.Errorf("failed to get MCMS address for chain %d: %w", chainSelector, err)
+		return types.ChainMetadata{}, fmt.Errorf("failed to get MCMS address for chain %d: %w", cs, err)
 	}
 
-	inspector := mcms_ton.NewInspector(chain.Client)
+	inspector := mcmston.NewInspector(chain.Client)
 	counts, err := inspector.GetOpCount(e.GetContext(), mcmsAddr.Address)
 	if err != nil {
-		return types.ChainMetadata{}, fmt.Errorf("failed to get opCount for MCMS at address %s on chain %d: %w", mcmsAddr.Address, chainSelector, err)
+		return types.ChainMetadata{}, fmt.Errorf("failed to get opCount for MCMS at address %s on chain %d: %w", mcmsAddr.Address, cs, err)
 	}
 
 	return types.ChainMetadata{
@@ -44,33 +47,38 @@ func (r *MCMSReaderAdapter) GetChainMetadata(e deployment.Environment, chainSele
 }
 
 // GetTimelockRef returns the timelock contract address reference for a given MCMS input.
-func (r *MCMSReaderAdapter) GetTimelockRef(e deployment.Environment, chainSelector uint64, input mcms_utils.Input) (datastore.AddressRef, error) {
-	ref := datastore_utils.GetAddressRef(
-		e.DataStore.Addresses().Filter(),
-		chainSelector,
-		deployment.ContractType(state.Timelock),
-		&state.TimelockVersion,
-		input.Qualifier,
-	)
+func (r *MCMSReaderAdapter) GetTimelockRef(e cldf.Environment, cs uint64, input ccipdmcms.Input) (cldfds.AddressRef, error) {
+	t := ccipdutils.RBACTimelock
+	version := state.TimelockVersion
+	ref := ccipdds.GetAddressRef(e.DataStore.Addresses().Filter(), cs, t, &version, input.Qualifier)
 	if ref.Address == "" {
-		return datastore.AddressRef{}, fmt.Errorf("timelock contract not found for chain selector %d", chainSelector)
+		return cldfds.AddressRef{}, fmt.Errorf("timelock contract not found for chain selector %d", cs)
 	}
+
 	return ref, nil
 }
 
 // GetMCMSRef returns the MCMS contract address reference for a given MCMS input.
-func (r *MCMSReaderAdapter) GetMCMSRef(e deployment.Environment, chainSelector uint64, input mcms_utils.Input) (datastore.AddressRef, error) {
-	ref := datastore_utils.GetAddressRef(
-		e.DataStore.Addresses().Filter(),
-		chainSelector,
-		deployment.ContractType(state.MCMS),
-		&state.MCMSVersion,
-		input.Qualifier,
-	)
+func (r *MCMSReaderAdapter) GetMCMSRef(e cldf.Environment, cs uint64, input ccipdmcms.Input) (cldfds.AddressRef, error) {
+	// find mcms address
+	// populate contract type from TimelockAction
+	var t cldf.ContractType
+	switch input.TimelockAction {
+	case types.TimelockActionSchedule:
+		t = ccipdutils.ProposerManyChainMultisig
+	case types.TimelockActionBypass:
+		t = ccipdutils.BypasserManyChainMultisig
+	case types.TimelockActionCancel:
+		t = ccipdutils.CancellerManyChainMultisig
+	default:
+		return cldfds.AddressRef{}, fmt.Errorf("unsupported timelock action type: %s", input.TimelockAction)
+	}
+
+	version := state.MCMSVersion
+	ref := ccipdds.GetAddressRef(e.DataStore.Addresses().Filter(), cs, t, &version, input.Qualifier)
 	if ref.Address == "" {
-		return datastore.AddressRef{}, fmt.Errorf("MCMS contract not found for chain selector %d", chainSelector)
+		return cldfds.AddressRef{}, fmt.Errorf("MCMS contract not found for chain selector %d", cs)
 	}
+
 	return ref, nil
 }
-
-var _ changesets.MCMSReader = &MCMSReaderAdapter{}