fix(enum): bounds-check ValueList index to avoid runtime panic

A ValueList enum decodes its variant index from a single untrusted input
byte (0-255). The final branch of Enum.Process did an unguarded slice
access e.ValueList[e.Index], so an index beyond the value list (e.g. byte
0x10 into a 3-variant enum) panicked with an opaque runtime 'index out of
range' inside the decoder. The TypeMapping.Types path above already guards
this; the ValueList path did not.

Add the matching bounds check with a descriptive message so a caller
recovering decode panics gets the offending type and index. In-range
decoding is unchanged. Adds a regression test.

Author: chiliec

types/Enum.go

@@ -69,6 +69,9 @@ func (e *Enum) Process() {
 			return
 		}
 	}
+	if e.Index >= len(e.ValueList) {
+		panic(fmt.Errorf("enum %s index out of range [%d] with value list length %d", e.TypeName, e.Index, len(e.ValueList)))
+	}
 	if e.ValueList[e.Index] != "" {
 		e.Value = e.ValueList[e.Index]
 	}

types/Enum_valuelist_oob_test.go

@@ -0,0 +1,48 @@
+package types
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/itering/scale.go/source"
+	scaleBytes "github.com/itering/scale.go/types/scaleBytes"
+	"github.com/itering/scale.go/utiles"
+)
+
+// A ValueList enum decodes its variant index from a single untrusted input byte
+// (0-255). If that index is beyond the value list, the decoder previously did an
+// unguarded slice access e.ValueList[e.Index] and panicked with an opaque
+// "runtime error: index out of range". This mirrors the descriptive bounds check
+// already present on the TypeMapping.Types path so the recovering caller gets the
+// offending type/index instead of a bare runtime panic.
+func TestEnumValueListIndexOutOfRange(t *testing.T) {
+	RegCustomTypes(map[string]source.TypeStruct{
+		"OOBValueEnum": {Type: "enum", ValueList: []string{"A", "B", "C"}},
+	})
+
+	// Out-of-range index byte (0x10 = 16, list length 3) -> descriptive panic.
+	func() {
+		defer func() {
+			r := recover()
+			if r == nil {
+				t.Fatal("expected a panic for an out-of-range enum index")
+			}
+			msg := fmt.Sprint(r)
+			if !strings.Contains(msg, "index out of range") ||
+				!strings.Contains(msg, "value list length") {
+				t.Fatalf("panic message not descriptive: %v", r)
+			}
+		}()
+		m := ScaleDecoder{}
+		m.Init(scaleBytes.ScaleBytes{Data: utiles.HexToBytes("0x10")}, nil)
+		m.ProcessAndUpdateData("OOBValueEnum")
+	}()
+
+	// In-range index still decodes correctly.
+	m := ScaleDecoder{}
+	m.Init(scaleBytes.ScaleBytes{Data: utiles.HexToBytes("0x01")}, nil)
+	if got := m.ProcessAndUpdateData("OOBValueEnum"); got != "B" {
+		t.Fatalf("in-range decode = %v, want B", got)
+	}
+}