Merge branch 'develop' into ozep/unsigned-integer-underflow-check

Author: Unheilbar

.github/workflows/ccip-solana-messaging.yml

@@ -53,18 +53,10 @@ jobs:
       fail-fast: false
       matrix:
         test:
-          - name: EVM2Solana
-            slug: evm2solana
-            run: Test_CCIPMessaging_EVM2Solana
-            loopp: false
           - name: EVM2Solana LOOPP
             slug: evm2solana-loopp
             run: Test_CCIPMessaging_EVM2Solana
             loopp: true
-          - name: Solana2EVM
-            slug: solana2evm
-            run: Test_CCIPMessaging_Solana2EVM
-            loopp: false
           - name: Solana2EVM LOOPP
             slug: solana2evm-loopp
             run: Test_CCIPMessaging_Solana2EVM
@@ -73,10 +65,6 @@ jobs:
             slug: revert-evm2solana-loopp
             run: Test_CCIPMessaging_Revert_EVM2Solana
             loopp: true
-          - name: MultiExecReports EVM2Solana
-            slug: multiexec-evm2solana
-            run: Test_CCIPMessaging_MultiExecReports_EVM2Solana
-            loopp: false
     steps:
       - name: Checkout chainlink-solana
         uses: actions/checkout@v5
@@ -137,7 +125,6 @@ jobs:
         working-directory: chainlink/integration-tests
         env:
           CL_DATABASE_URL: ${{ steps.setup-postgres.outputs.database-url }}
-          CL_SOLANA_CMD: ${{ matrix.test.loopp && 'chainlink-solana' || '' }}
         run: |
           mkdir -p "${GITHUB_WORKSPACE}/ccip-test-artifacts"
           cd smoke/ccip

pkg/solana/CONFIG.md

@@ -371,18 +371,21 @@ AcceptanceTimeout is the default timeout for a tranmission to be accepted on cha
 ForwarderAddress = '14grJpemFaf88c8tiVb77W7TYg2W3ir6pfkKz3YjhhZ5' # Example
 ```
 ForwarderAddress is the keystone forwarder program address on chain.
+Deprecated: ignored at runtime; use capability config. Kept for TOML compatibility.
 
 ### ForwarderState
 ```toml
 ForwarderState = '14grJpemFaf88c8tiVb77W7TYg2W3ir6pfkKz3YjhhZ5' # Example
 ```
 ForwarderState is the keystone forwarder program state account on chain.
+Deprecated: ignored at runtime; use capability config. Kept for TOML compatibility.
 
 ### FromAddress
 ```toml
 FromAddress = '4BJXYkfvg37zEmBbsacZjeQDpTNx91KppxFJxRqrz48e' # Example
 ```
 FromAddress is Address of the transmitter key to use for workflow writes.
+Deprecated: ignored at runtime; use capability / transmitter config. Kept for TOML compatibility.
 
 ### GasLimitDefault
 ```toml

pkg/solana/cmd/chainlink-solana/main.go

@@ -3,10 +3,8 @@ package main
 import (
 	"context"
 	"fmt"
-	"strings"
 
 	"github.com/hashicorp/go-plugin"
-	"github.com/pelletier/go-toml/v2"
 
 	"github.com/smartcontractkit/chainlink-common/pkg/beholder"
 	"github.com/smartcontractkit/chainlink-common/pkg/loop"
@@ -54,27 +52,21 @@ type pluginRelayer struct {
 	ds sqlutil.DataSource
 }
 
-func (c *pluginRelayer) NewRelayer(ctx context.Context, config string, keystore core.Keystore, csaKeystore core.Keystore, capRegistry core.CapabilitiesRegistry) (loop.Relayer, error) {
-	d := toml.NewDecoder(strings.NewReader(config))
-	d.DisallowUnknownFields()
-	var cfg struct {
-		Solana solcfg.TOMLConfig
-	}
-
-	if err := d.Decode(&cfg); err != nil {
-		return nil, fmt.Errorf("failed to decode config toml: %w:\n\t%s", err, config)
+func (c *pluginRelayer) NewRelayer(ctx context.Context, rawConfig string, keystore core.Keystore, csaKeystore core.Keystore, capRegistry core.CapabilitiesRegistry) (loop.Relayer, error) {
+	cfg, err := solcfg.NewDecodedTOMLConfig(rawConfig)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read configs: %w", err)
 	}
-
-	rawNodes := make([]map[string]string, 0, len(cfg.Solana.Nodes))
-	for _, n := range cfg.Solana.Nodes {
+	rawNodes := make([]map[string]string, 0, len(cfg.Nodes))
+	for _, n := range cfg.Nodes {
 		if n == nil || n.URL == nil {
 			continue
 		}
 		rawNodes = append(rawNodes, map[string]string{"URL": n.URL.String()})
 	}
 	chainID := ""
-	if cfg.Solana.ChainID != nil {
-		chainID = *cfg.Solana.ChainID
+	if cfg.ChainID != nil {
+		chainID = *cfg.ChainID
 	}
 	emitter := loop.NewPluginRelayerConfigEmitter(
 		c.Logger,
@@ -93,12 +85,12 @@ func (c *pluginRelayer) NewRelayer(ctx context.Context, config string, keystore
 		DS:       c.ds,
 	}
 
-	chain, err := solana.NewChain(&cfg.Solana, opts)
+	chain, err := solana.NewChain(cfg, opts)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create chain: %w", err)
 	}
 
-	ra := solana.NewRelayer(c.Logger, chain, capRegistry)
+	ra := solana.NewRelayer(c.Logger, chain, capRegistry, keystore)
 
 	c.SubService(ra)
 

pkg/solana/codec/codec.go

@@ -18,14 +18,14 @@ import (
 func NewEventCodecEntry(filter types.Filter, includeDiscriminator bool, mod commoncodec.Modifier, builder encodings.Builder) (solcommoncodec.Entry, error) {
 	if filter.ContractIdl != "" {
 		// Try codecv2 first (Anchor 0.30+ IDL format)
-		entry, err := codecv2.NewEventArgsEntryWrapper(filter.EventName, filter.ContractIdl, includeDiscriminator, mod, builder)
-		if err == nil {
+		entry, v2Err := codecv2.NewEventArgsEntryWrapper(filter.EventName, filter.ContractIdl, includeDiscriminator, mod, builder)
+		if v2Err == nil {
 			return entry, nil
 		}
 		// Fall back to codec (legacy Anchor IDL format)
-		entry, err = codecv1.NewEventArgsEntryWrapper(filter.EventName, filter.ContractIdl, includeDiscriminator, mod, builder)
-		if err != nil {
-			return nil, fmt.Errorf("failed to create event codec entry: %w", err)
+		entry, v1Err := codecv1.NewEventArgsEntryWrapper(filter.EventName, filter.ContractIdl, includeDiscriminator, mod, builder)
+		if v1Err != nil {
+			return nil, fmt.Errorf("failed to create event codec entry: v2 err: %w, v1 err: %w", v2Err, v1Err)
 		}
 		return entry, nil
 	}

pkg/solana/codec/v1/codec_entry.go

@@ -6,7 +6,7 @@ import (
 
 	"github.com/smartcontractkit/chainlink-common/pkg/codec"
 	"github.com/smartcontractkit/chainlink-common/pkg/codec/encodings"
-	"github.com/smartcontractkit/chainlink-common/pkg/codec/encodings/binary"
+
 	solcommoncodec "github.com/smartcontractkit/chainlink-solana/pkg/solana/codec/common"
 )
 
@@ -77,23 +77,35 @@ type EventIDLTypes struct {
 	Types IdlTypeDefSlice
 }
 
-// accepts contract idl string
+// NewEventArgsEntryWrapper accepts a contract IDL JSON string and builds a v1 event codec entry.
+// It rejects Anchor v2 (0.30+) IDLs, which lack a top-level "version" field, to prevent
+// silently producing an empty codec (v2 stores event fields externally in "types").
 func NewEventArgsEntryWrapper(offChainName string, contractIdl string, includeDiscriminator bool, mod codec.Modifier, builder encodings.Builder) (solcommoncodec.Entry, error) {
 	var codecIDL IDL
 	if err := json.Unmarshal([]byte(contractIdl), &codecIDL); err != nil {
 		return nil, fmt.Errorf("failed to unmarshal contract IDL for %s, error: %w", offChainName, err)
 	}
 
+	if codecIDL.Version == "" {
+		return nil, fmt.Errorf("IDL for %s is not a legacy Anchor IDL (missing top-level \"version\" field); use the v2 codec for Anchor 0.30+ IDLs", offChainName)
+	}
+
 	eventIdl, err := ExtractEventIDL(offChainName, codecIDL)
 	if err != nil {
 		return nil, fmt.Errorf("failed to extract event IDL from codec: %w", err)
 	}
 
-	return NewEventArgsEntry(offChainName, EventIDLTypes{Event: eventIdl, Types: codecIDL.Types}, true, nil, binary.LittleEndian())
+	return NewEventArgsEntry(offChainName, EventIDLTypes{Event: eventIdl, Types: codecIDL.Types}, includeDiscriminator, mod, builder)
 }
 
-// accepts struct containing event definition and types parsed from the contract idl
+// NewEventArgsEntry accepts a struct containing event definition and types parsed from the contract IDL.
+// It requires the event to have at least one field to prevent building an empty codec
+// that would silently discard decoded data.
 func NewEventArgsEntry(offChainName string, idlTypes EventIDLTypes, includeDiscriminator bool, mod codec.Modifier, builder encodings.Builder) (solcommoncodec.Entry, error) {
+	if len(idlTypes.Event.Fields) == 0 {
+		return nil, fmt.Errorf("event %q has no fields; this may indicate an Anchor v2 IDL was parsed with the v1 codec", idlTypes.Event.Name)
+	}
+
 	_, eventCodec, err := asStruct(eventFieldsToFields(idlTypes.Event.Fields), createRefs(idlTypes.Types, builder), idlTypes.Event.Name, false, false)
 	if err != nil {
 		return nil, err

pkg/solana/codec/v1/solana_test.go

@@ -152,6 +152,35 @@ func TestNewIDLCodec_WithModifiers(t *testing.T) {
 	require.Equal(t, expected.EnumVal, unmodifiedDecoded.EnumVal)
 }
 
+func TestNewEventArgsEntryWrapper_RejectsV2IDL(t *testing.T) {
+	t.Parallel()
+
+	// Minimal v2-style IDL: has events without inline fields and no top-level "version".
+	// This would unmarshal successfully into the v1 IDL struct, producing an event
+	// with empty Fields that generates an empty codec — the exact vulnerability.
+	v2StyleIDL := `{
+		"name": "test_program",
+		"instructions": [],
+		"events": [{"name": "TestItem", "discriminator": [119, 183, 160, 247, 84, 104, 222, 251]}],
+		"types": [{"name": "TestItem", "type": {"kind": "struct", "fields": [{"name": "field", "type": "i32"}]}}]
+	}`
+
+	_, err := codecv1.NewEventArgsEntryWrapper("TestItem", v2StyleIDL, true, nil, binary.LittleEndian())
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "not a legacy Anchor IDL")
+}
+
+func TestNewEventArgsEntry_RejectsEmptyFields(t *testing.T) {
+	t.Parallel()
+
+	_, err := codecv1.NewEventArgsEntry("TestEmpty", codecv1.EventIDLTypes{
+		Event: codecv1.IdlEvent{Name: "TestEmpty", Fields: nil},
+		Types: nil,
+	}, true, nil, binary.LittleEndian())
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "has no fields")
+}
+
 func TestNewIDLCodec_CircularDependency(t *testing.T) {
 	t.Parallel()
 

pkg/solana/codec/v2/codec_entry.go

@@ -8,7 +8,6 @@ import (
 
 	"github.com/smartcontractkit/chainlink-common/pkg/codec"
 	"github.com/smartcontractkit/chainlink-common/pkg/codec/encodings"
-	"github.com/smartcontractkit/chainlink-common/pkg/codec/encodings/binary"
 
 	solcommoncodec "github.com/smartcontractkit/chainlink-solana/pkg/solana/codec/common"
 )
@@ -53,7 +52,7 @@ func NewEventArgsEntryWrapper(offChainName string, contractIdl string, includeDi
 		return nil, fmt.Errorf("failed to extract event IDL from codec: %w", err)
 	}
 
-	return NewEventArgsEntry(offChainName, EventIDLTypes{Event: eventIdl, Types: codecIDL.Types}, true, nil, binary.LittleEndian())
+	return NewEventArgsEntry(offChainName, EventIDLTypes{Event: eventIdl, Types: codecIDL.Types}, includeDiscriminator, mod, builder)
 }
 
 func NewEventArgsEntry(offChainName string, idlTypes EventIDLTypes, includeDiscriminator bool, mod codec.Modifier, builder encodings.Builder) (solcommoncodec.Entry, error) {

pkg/solana/codec/v2/codec_entry_test.go

@@ -1,4 +1,4 @@
-package codecv2_test
+package codecv2
 
 import (
 	_ "embed"
@@ -10,7 +10,6 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/smartcontractkit/chainlink-common/pkg/codec/encodings/binary"
-	codecv2 "github.com/smartcontractkit/chainlink-solana/pkg/solana/codec/v2"
 )
 
 //go:embed testutils/data_storage.json
@@ -41,7 +40,7 @@ func TestNewEventArgsEntry(t *testing.T) {
 			t.Fatalf("unexpected error: invalid IDL, error: %v", err)
 		}
 		for i, event := range idl.Events {
-			entry, err := codecv2.NewEventArgsEntry(fmt.Sprintf("test%d", i), codecv2.EventIDLTypes{
+			entry, err := NewEventArgsEntry(fmt.Sprintf("test%d", i), EventIDLTypes{
 				Event: event,
 				Types: idl.Types,
 			}, false, nil, binary.LittleEndian())
@@ -59,7 +58,7 @@ func TestNewInstructionArgsEntry(t *testing.T) {
 		}
 		for i, instruction := range idl.Instructions {
 			if len(instruction.Args) > 0 {
-				entry, err := codecv2.NewInstructionArgsEntry(fmt.Sprintf("test%d", i), codecv2.InstructionArgsIDLTypes{
+				entry, err := NewInstructionArgsEntry(fmt.Sprintf("test%d", i), InstructionArgsIDLTypes{
 					Instruction: instruction,
 					Types:       idl.Types,
 				}, nil, binary.LittleEndian())

pkg/solana/codec/v2/solana.go

@@ -24,15 +24,31 @@ const (
 
 // snakeToPascal converts a snake_case string to PascalCase.
 // e.g. "transmission_id" -> "TransmissionId", "don_id" -> "DonId"
-func snakeToPascal(s string) string {
-	caser := cases.Title(language.English, cases.NoLower)
+// Returns an error if the conversion produces an empty string (e.g. underscore-only inputs).
+func snakeToPascal(s string) (string, error) {
+	caser := cases.Title(language.English)
 	parts := strings.Split(s, "_")
-	for i, part := range parts {
+	var result strings.Builder
+	for _, part := range parts {
 		if len(part) > 0 {
-			parts[i] = caser.String(part)
+			result.WriteString(caser.String(part))
 		}
 	}
-	return strings.Join(parts, "")
+	if result.Len() == 0 {
+		return "", fmt.Errorf("%w: field name %q converts to an empty PascalCase string", commontypes.ErrInvalidConfig, s)
+	}
+	return result.String(), nil
+}
+
+func validateUniqueFieldNames(named []commonencodings.NamedTypeCodec) error {
+	seen := make(map[string]struct{}, len(named))
+	for _, n := range named {
+		if _, exists := seen[n.Name]; exists {
+			return fmt.Errorf("%w: duplicate PascalCase field name %q", commontypes.ErrInvalidConfig, n.Name)
+		}
+		seen[n.Name] = struct{}{}
+	}
+	return nil
 }
 
 func CreateCodecEntry(idlDefinition interface{}, offChainName string, idl anchoridl.Idl, mod commoncodec.Modifier) (entry solcommoncodec.Entry, err error) {
@@ -163,7 +179,14 @@ func asStruct(
 				return name, nil, err
 			}
 
-			named[idx] = commonencodings.NamedTypeCodec{Name: snakeToPascal(fieldName), Codec: typedCodec}
+			pascalName, err := snakeToPascal(fieldName)
+			if err != nil {
+				return name, nil, err
+			}
+			named[idx] = commonencodings.NamedTypeCodec{Name: pascalName, Codec: typedCodec}
+		}
+		if err := validateUniqueFieldNames(named); err != nil {
+			return name, nil, err
 		}
 		structCodec, err := commonencodings.NewStructCodec(named)
 		if err != nil {
@@ -189,7 +212,11 @@ func asStructForInstructionArgs(
 		if err != nil {
 			return nil, err
 		}
-		named[idx] = commonencodings.NamedTypeCodec{Name: snakeToPascal(fieldName), Codec: typedCodec}
+		pascalName, err := snakeToPascal(fieldName)
+		if err != nil {
+			return nil, err
+		}
+		named[idx] = commonencodings.NamedTypeCodec{Name: pascalName, Codec: typedCodec}
 	}
 
 	var isVecOrArray bool
@@ -209,6 +236,10 @@ func asStructForInstructionArgs(
 		return named[0].Codec, nil
 	}
 
+	if err := validateUniqueFieldNames(named); err != nil {
+		return nil, err
+	}
+
 	structCodec, err := commonencodings.NewStructCodec(named)
 	if err != nil {
 		return nil, err