feat: add config transformer functionality [DPA-1409] (#255)

Adds configuration transformer functionality to the solana sdk

## AI Summary: 

This pull request introduces a new configuration transformer
functionality for Solana and updates the existing configuration
transformer for EVM. The changes include modifications to the
`ConfigTransformer` interface, implementation of the Solana transformer,
and updates to tests.

### New Features:
* Added a new configuration transformer for Solana, including the
`AdditionalConfig` struct and the `ToChainConfig` method implementation
in `sdk/solana/config_transformer.go`.
[[1]](diffhunk://#diff-e668d47f11b486cfa0ba79551c77dbb35570e15152d2ae5f7d1708ae2aa48680L4-R26)
[[2]](diffhunk://#diff-e668d47f11b486cfa0ba79551c77dbb35570e15152d2ae5f7d1708ae2aa48680L55-R100)

### Interface Updates:
* Modified the `ConfigTransformer` interface to accept an additional
chain-specific configuration parameter.

### Implementation Updates:
* Updated the EVM `ConfigTransformer` to support the new interface by
adding a chain-specific configuration parameter to the `ToChainConfig`
method.
[[1]](diffhunk://#diff-eb9910cff7faabe1b397889073e7b58998a9c95918839b87779808412fab84f4L140-R140)
[[2]](diffhunk://#diff-fe1f07d4fe69ce3f43ced9b53edfbbabe82ed2fb364d017f8c914414e9b5c402R66)
[[3]](diffhunk://#diff-6e8114ad8cf44c0e74542ad75d01b9f810b06aa111c956b5fade449578976a7fL253-R253)

### Testing Enhancements:
* Added tests for the new Solana `ToChainConfig` method in
`sdk/solana/config_transformer_test.go`.

### Documentation:
* Added a changeset entry for the new Solana configuration transformer
functionality.

Author: ecPablo

.changeset/lazy-lemons-fold.md

@@ -0,0 +1,5 @@
+---
+"@smartcontractkit/mcms": minor
+---
+
+Add config transformer functionality for solana.

go.mod

@@ -18,6 +18,7 @@ require (
 	github.com/spf13/cast v1.7.1
 	github.com/stretchr/testify v1.10.0
 	golang.org/x/tools v0.29.0
+	gotest.tools/v3 v3.5.1
 )
 
 require (

internal/testutils/evmsim/evmsim.go

@@ -137,7 +137,7 @@ func (s *SimulatedChain) SetMCMSConfig(
 	}
 
 	transformer := evm.ConfigTransformer{}
-	bindConfig, err := transformer.ToChainConfig(*cfg)
+	bindConfig, err := transformer.ToChainConfig(*cfg, nil)
 	require.NoError(t, err)
 
 	signerAddrs := make([]common.Address, len(bindConfig.Signers))

sdk/config_transformer.go

@@ -6,10 +6,11 @@ import (
 
 // ConfigTransformer is the interface used to create the configuration of an MCMS contract.
 // R in this case is the chain-specific struct that is used to configure the contract.
+// C is the chain-specific additional configuration that is required to configure the contract.
 // the interface allows conversion between the chain-specific struct and the chain-agnostic.
-type ConfigTransformer[R any] interface {
+type ConfigTransformer[R any, C any] interface {
 	// ToChainConfig converts the chain agnostic config to the chain-specific config
-	ToChainConfig(contract string, cfg types.Config) (R, error)
+	ToChainConfig(cfg types.Config, chainSpecificConfig C) (R, error)
 
 	// ToConfig Maps the chain-specific config to the chain-agnostic config
 	ToConfig(onchainConfig R) (*types.Config, error)

sdk/evm/config_transformer.go

@@ -8,11 +8,14 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 
 	"github.com/smartcontractkit/mcms/internal/utils/safecast"
+	"github.com/smartcontractkit/mcms/sdk"
 	sdkerrors "github.com/smartcontractkit/mcms/sdk/errors"
 	"github.com/smartcontractkit/mcms/sdk/evm/bindings"
 	"github.com/smartcontractkit/mcms/types"
 )
 
+var _ sdk.ConfigTransformer[bindings.ManyChainMultiSigConfig, any] = (*ConfigTransformer)(nil)
+
 const maxUint8Value = 255
 
 type ConfigTransformer struct{}
@@ -62,6 +65,7 @@ func (e *ConfigTransformer) ToConfig(
 // ToChainConfig converts a chain-agnostic types.Config to an EVM ManyChainMultiSigConfig
 func (e *ConfigTransformer) ToChainConfig(
 	cfg types.Config,
+	_ any,
 ) (bindings.ManyChainMultiSigConfig, error) {
 	var bindConfig bindings.ManyChainMultiSigConfig
 
@@ -94,6 +98,13 @@ func (e *ConfigTransformer) ToChainConfig(
 	}, nil
 }
 
+// ExtractSetConfigInputs flattens a nested `*types.Config` into:
+//  1. groupQuorums: [32]uint8 where each index i holds the quorum for group i (zero-padded).
+//  2. groupParents: [32]uint8 where each index i holds the parent group’s index (or a sentinel).
+//  3. orderedSignerAddresses: a sorted slice of all signer addresses.
+//  4. orderedSignerGroups: a parallel slice of group indices for each signer.
+//
+// Returns an error if the structure cannot be flattened (e.g., too many groups).
 func ExtractSetConfigInputs(
 	group *types.Config,
 ) ([32]uint8, [32]uint8, []common.Address, []uint8, error) {

sdk/evm/config_transformer_test.go

@@ -331,7 +331,7 @@ func Test_SetConfigInputs(t *testing.T) {
 			t.Parallel()
 
 			transformer := ConfigTransformer{}
-			got, err := transformer.ToChainConfig(tt.giveConfig)
+			got, err := transformer.ToChainConfig(tt.giveConfig, nil)
 
 			if tt.wantErr != "" {
 				require.EqualError(t, err, tt.wantErr)

sdk/solana/config_transformer.go

@@ -1,14 +1,26 @@
 package solana
 
 import (
-	"fmt"
-
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/gagliardetto/solana-go"
 	bindings "github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings/mcm"
 
+	sdkerrors "github.com/smartcontractkit/mcms/sdk/errors"
+	"github.com/smartcontractkit/mcms/sdk/evm"
 	"github.com/smartcontractkit/mcms/types"
 )
 
+type AdditionalConfig struct {
+	ChainID    uint64
+	MultisigID [32]uint8
+	// Current Owner of the multisig ID
+	Owner solana.PublicKey
+	// Proposed Owner of the program when calling transfer_ownership
+	ProposedOwner solana.PublicKey
+}
+
+const maxUint8Value = 255
+
 type ConfigTransformer struct{}
 
 func NewConfigTransformer() *ConfigTransformer {
@@ -54,8 +66,38 @@ func (e *ConfigTransformer) ToConfig(
 }
 
 // ToChainConfig converts a chain-agnostic types.Config to an Solana ManyChainMultiSigConfig
-func (e *ConfigTransformer) ToChainConfig(
-	cfg types.Config,
-) (bindings.MultisigConfig, error) {
-	return bindings.MultisigConfig{}, fmt.Errorf("sdk.solana.ConfigTransformer.ToChainConfig not implemented")
+func (e *ConfigTransformer) ToChainConfig(cfg types.Config, solanaConfig AdditionalConfig) (bindings.MultisigConfig, error) {
+	// Populate additional Configs
+	result := bindings.MultisigConfig{
+		ChainId:       solanaConfig.ChainID,
+		MultisigId:    solanaConfig.MultisigID,
+		Owner:         solanaConfig.Owner,
+		ProposedOwner: solanaConfig.ProposedOwner,
+	}
+	// Populate the signers: we can reuse the evm implementation here as the signers structure is the same
+	groupQuorums, groupParents, signerAddrs, signerGroups, err := evm.ExtractSetConfigInputs(&cfg)
+	if err != nil {
+		return bindings.MultisigConfig{}, err
+	}
+	// Check the length of signerAddresses up-front
+	if len(signerAddrs) > maxUint8Value {
+		return bindings.MultisigConfig{}, sdkerrors.NewTooManySignersError(uint64(len(signerAddrs)))
+	}
+	// Set the signers
+	bindSigners := make([]bindings.McmSigner, len(signerAddrs))
+	idx := uint8(0)
+	for i, signerAddr := range signerAddrs {
+		bindSigners[i] = bindings.McmSigner{
+			EvmAddress: signerAddr,
+			Group:      signerGroups[i],
+			Index:      idx,
+		}
+		idx += 1
+	}
+	result.Signers = bindSigners
+	// Set group quorums and group parents.
+	result.GroupQuorums = groupQuorums
+	result.GroupParents = groupParents
+
+	return result, nil
 }

sdk/solana/config_transformer_test.go

@@ -4,9 +4,11 @@ import (
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/gagliardetto/solana-go"
 	"github.com/google/go-cmp/cmp"
 	bindings "github.com/smartcontractkit/chainlink-ccip/chains/solana/gobindings/mcm"
 	"github.com/stretchr/testify/require"
+	"gotest.tools/v3/assert"
 
 	"github.com/smartcontractkit/mcms/types"
 )
@@ -158,3 +160,157 @@ func Test_ConfigTransformer_ToConfig(t *testing.T) {
 		})
 	}
 }
+
+func Test_ConfigTransformer_ToChainConfig(t *testing.T) {
+	t.Parallel()
+
+	var (
+		signer1 = common.HexToAddress("0x1")
+		signer2 = common.HexToAddress("0x2")
+		signer3 = common.HexToAddress("0x3")
+		signer4 = common.HexToAddress("0x4")
+	)
+	testOwner, err := solana.NewRandomPrivateKey()
+	require.NoError(t, err)
+	proposedOwner, err := solana.NewRandomPrivateKey()
+	require.NoError(t, err)
+
+	tests := []struct {
+		name             string
+		give             types.Config
+		want             bindings.MultisigConfig
+		additionalConfig AdditionalConfig
+		wantErr          string
+		assert           func(t *testing.T, got bindings.MultisigConfig)
+	}{
+		{
+			name: "success: converts binding config to config",
+			want: bindings.MultisigConfig{
+				GroupQuorums:  [32]uint8{1, 1},
+				GroupParents:  [32]uint8{0, 0},
+				Owner:         testOwner.PublicKey(),
+				ProposedOwner: proposedOwner.PublicKey(),
+				Signers: []bindings.McmSigner{
+					{EvmAddress: signer1, Group: 0, Index: 0},
+					{EvmAddress: signer2, Group: 1, Index: 1},
+				},
+			},
+			additionalConfig: AdditionalConfig{
+				ChainID:       0,
+				MultisigID:    [32]uint8{},
+				Owner:         testOwner.PublicKey(),
+				ProposedOwner: proposedOwner.PublicKey(),
+			},
+			give: types.Config{
+				Quorum:  1,
+				Signers: []common.Address{signer1},
+				GroupSigners: []types.Config{
+					{
+						Quorum:       1,
+						Signers:      []common.Address{signer2},
+						GroupSigners: []types.Config{},
+					},
+				},
+			},
+			assert: func(t *testing.T, got bindings.MultisigConfig) {
+				t.Helper()
+
+				assert.Equal(t, [32]uint8{1, 1}, got.GroupQuorums)
+				assert.Equal(t, [32]uint8{0, 0}, got.GroupParents)
+				assert.Equal(t, uint64(0), got.ChainId)
+				assert.Equal(t, [32]uint8{}, got.MultisigId)
+				assert.Equal(t, got.Owner, testOwner.PublicKey())
+				assert.Equal(t, got.ProposedOwner, proposedOwner.PublicKey())
+			},
+		},
+		{
+			name: "success: nested config",
+			give: types.Config{
+				Quorum:  2,
+				Signers: []common.Address{signer1}, // group 0 signers
+				GroupSigners: []types.Config{
+					{
+						Quorum:  1,
+						Signers: []common.Address{signer2}, // group 1 signers
+						GroupSigners: []types.Config{
+							{
+								Quorum:  2,
+								Signers: []common.Address{signer3, signer4}, // group 2 signers
+							},
+						},
+					},
+				},
+			},
+			want: bindings.MultisigConfig{
+				Owner:         testOwner.PublicKey(),
+				ProposedOwner: proposedOwner.PublicKey(),
+				ChainId:       1,
+				MultisigId:    [32]uint8{},
+				GroupQuorums: [32]uint8{
+					2, // group 0
+					1, // group 1
+					2, // group 2
+				},
+				GroupParents: [32]uint8{
+					0, // group 0's parent => 0 by convention (no parent)
+					0, // group 1's parent => group 0
+					1, // group 2's parent => group 1
+				},
+				Signers: []bindings.McmSigner{
+					{EvmAddress: signer1, Group: 0, Index: 0},
+					{EvmAddress: signer2, Group: 1, Index: 1},
+					{EvmAddress: signer3, Group: 2, Index: 2},
+					{EvmAddress: signer4, Group: 2, Index: 3},
+				},
+			},
+			additionalConfig: AdditionalConfig{
+				ChainID:       1,
+				MultisigID:    [32]uint8{},
+				Owner:         testOwner.PublicKey(),
+				ProposedOwner: proposedOwner.PublicKey(),
+			},
+			assert: func(t *testing.T, got bindings.MultisigConfig) {
+				t.Helper()
+
+				require.Empty(t, cmp.Diff(got, bindings.MultisigConfig{
+					Owner:         testOwner.PublicKey(),
+					ProposedOwner: proposedOwner.PublicKey(),
+					ChainId:       1,
+					MultisigId:    [32]uint8{},
+					GroupQuorums: [32]uint8{
+						2, // group 0
+						1, // group 1
+						2, // group 2
+					},
+					GroupParents: [32]uint8{
+						0, // group 0
+						0, // group 1 has parent group 0
+						1, // group 2 has parent group 1
+					},
+					Signers: []bindings.McmSigner{
+						{EvmAddress: signer1, Group: 0, Index: 0},
+						{EvmAddress: signer2, Group: 1, Index: 1},
+						{EvmAddress: signer3, Group: 2, Index: 2},
+						{EvmAddress: signer4, Group: 2, Index: 3},
+					},
+				}))
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			transformer := ConfigTransformer{}
+			got, err := transformer.ToChainConfig(tt.give, tt.additionalConfig)
+
+			if tt.wantErr != "" {
+				require.EqualError(t, err, tt.wantErr)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tt.want, got)
+			}
+		})
+	}
+}