Add features to wrapper and property extractor modifiers (#1098)

* Change hardcoder to support TransformToOffChain for primitive variables

* Fix err handling in transformWithMapsHelper

* Improve extractElement to work on uninitialised slices

* Add a test for hardcoder TransformToOffChain for primitives variables

* Handle uninitialised slices in property extractor and add tests

* Improve transformWithMapsHelper err message

* minor improvements

* Improve err handling in initSliceForFieldPath

* Use derefPtr helper

Author: ilija42

pkg/codec/hard_coder.go

@@ -137,6 +137,15 @@ func (m *onChainHardCoder) TransformToOffChain(onChainValue any, itemType string
 	copy(allHooks, m.hooks)
 	allHooks[len(m.hooks)] = hardCodeManyHook
 
+	// if there is only one field with unset name, then a primitive variable is being hardcoded
+	if len(m.fields) == 1 {
+		for k, v := range m.fields {
+			if k == "" {
+				return v, nil
+			}
+		}
+	}
+
 	modified, err := transformWithMaps(onChainValue, m.onToOffChainType, m.fields, hardCode, allHooks...)
 	if err != nil {
 		return nil, err

pkg/codec/hard_coder_test.go

@@ -470,6 +470,20 @@ func TestHardCoder(t *testing.T) {
 		assert.Equal(t, int32(123), reflect.ValueOf(offChain).FieldByName("B").Interface())
 	})
 
+	t.Run("TransformToOffChain works on primitive variables", func(t *testing.T) {
+		hardCoder, err = codec.NewHardCoder(map[string]any{}, map[string]any{"": "test"})
+		require.NoError(t, err)
+
+		var a string
+		_, err = hardCoder.RetypeToOffChain(reflect.TypeOf(a), "")
+		require.NoError(t, err)
+
+		offChain, err := hardCoder.TransformToOffChain(a, "")
+		require.NoError(t, err)
+
+		assert.Equal(t, "test", offChain)
+	})
+
 	t.Run("TransformToOnChain and TransformToOffChain works for itemType path", func(t *testing.T) {
 		nestedHardCoder, err := codec.NewPathTraverseHardCoder(map[string]any{
 			"A":   "Top",

pkg/codec/modifier_base.go

@@ -270,6 +270,10 @@ func transformWithMapsHelper[T any](
 		}
 
 		tmp, err := transformWithMapsHelper(elm, toType.Elem(), fields, fn, hooks)
+		if err != nil {
+			return reflect.Value{}, fmt.Errorf("%w: failed to transform elem: %q of item: %q, to %q, with", err, elm.Type(), rItem.Type(), toType.Elem())
+		}
+
 		result := reflect.New(toType.Elem())
 		reflect.Indirect(result).Set(tmp)
 

pkg/codec/property_extractor.go

@@ -1,6 +1,7 @@
 package codec
 
 import (
+	"errors"
 	"fmt"
 	"reflect"
 	"strings"
@@ -376,7 +377,18 @@ func extractElement(src any, field string) (reflect.Value, error) {
 		return reflect.Value{}, err
 	}
 
-	if len(extractMaps) != 1 {
+	// if extract maps is empty, check if the underlying field is an uninitialised slice, if so initialise it and return extracted elem.
+	if len(extractMaps) == 0 {
+		typ, err := initSliceForFieldPath(reflect.TypeOf(src), field)
+		if errors.Is(err, &NoSliceUnderFieldPathError{}) {
+			return reflect.Value{}, fmt.Errorf("%w: cannot find %q in type: %q for extraction", types.ErrInvalidType, field, reflect.TypeOf(src).String())
+		} else if err != nil {
+			return reflect.Value{}, fmt.Errorf("%w: cannot find %q in type: %q for extraction, tried to check if path leads to an uninitialised slice, but failed with %w", types.ErrInvalidType, field, reflect.TypeOf(src).String(), err)
+		}
+		return typ, nil
+	}
+
+	if len(extractMaps) > 1 {
 		var sliceValue reflect.Value
 		var sliceInitialized bool
 		for _, fields := range extractMaps {
@@ -407,7 +419,7 @@ func extractElement(src any, field string) (reflect.Value, error) {
 
 	item, ok := em[name]
 	if !ok {
-		return reflect.Value{}, fmt.Errorf("%w: cannot find %s", types.ErrInvalidType, field)
+		return reflect.Value{}, fmt.Errorf("%w: cannot find %q", types.ErrInvalidType, field)
 	}
 
 	return reflect.ValueOf(item), nil
@@ -452,3 +464,68 @@ func pathAndName(field string) ([]string, string) {
 
 	return path, name
 }
+
+type NoSliceUnderFieldPathError struct {
+	Err error
+}
+
+func (e *NoSliceUnderFieldPathError) Error() string {
+	return fmt.Sprintf("field path did not resolve to a slice")
+}
+
+func initSliceForFieldPath(rootType reflect.Type, fieldPath string) (reflect.Value, error) {
+	parts := strings.Split(fieldPath, ".")
+	var prevIsSlice bool
+
+	if rootType == nil {
+		return reflect.Value{}, fmt.Errorf("root type is nil")
+	}
+
+	typ := derefTypePtr(rootType)
+
+	for i, p := range parts {
+		if typ.Kind() != reflect.Struct {
+			return reflect.Value{}, fmt.Errorf("expected a struct when processing field %q, got %s", p, typ.Kind())
+		}
+
+		fieldByName, ok := typ.FieldByName(p)
+		if !ok {
+			return reflect.Value{}, fmt.Errorf("field %q not found in type %s", p, typ.Name())
+		}
+
+		fieldType := derefTypePtr(fieldByName.Type)
+
+		// at end of path return a slice or a slice of slice if parent was a slice
+		if i == len(parts)-1 {
+			if prevIsSlice {
+				fieldType = reflect.SliceOf(fieldType)
+			}
+
+			if fieldType.Kind() != reflect.Slice {
+				return reflect.Value{}, &NoSliceUnderFieldPathError{}
+			}
+
+			return reflect.MakeSlice(fieldType, 0, 0), nil
+		}
+
+		if fieldType.Kind() == reflect.Slice {
+			if prevIsSlice {
+				return reflect.Value{}, fmt.Errorf("multiple nested slices are not allowed: found a slice at field %q, but parent in path is already a slice", p)
+			}
+			prevIsSlice = true
+
+			newTyp := fieldType.Elem()
+			newTyp = derefTypePtr(newTyp)
+
+			if newTyp.Kind() == reflect.Slice {
+				return reflect.Value{}, fmt.Errorf("multiple nested slices are not allowed: field %q in path contains a nested slice", p)
+			}
+
+			typ = newTyp
+		} else {
+			typ = derefTypePtr(fieldByName.Type)
+		}
+	}
+
+	return reflect.Value{}, &NoSliceUnderFieldPathError{}
+}

pkg/codec/property_extractor_test.go

@@ -20,6 +20,7 @@ func TestPropertyExtractor(t *testing.T) {
 
 	type testStruct2 struct {
 		D [16]uint8
+		F int
 	}
 
 	type testStruct3 struct {
@@ -166,6 +167,43 @@ func TestPropertyExtractor(t *testing.T) {
 		require.Equal(t, [][16]uint8{{1}, {2}}, offChainValue)
 	})
 
+	t.Run("TransformToOffChain works on filed that is an uninitialised slice", func(t *testing.T) {
+		_, err := nestedExtractorFieldUnderSlice.RetypeToOffChain(reflect.TypeOf(nestedTestStruct{}), "")
+		require.NoError(t, err)
+
+		onChainValue := nestedTestStruct{
+			A: "test",
+			B: testStruct{
+				A: true,
+				B: 42,
+			},
+			C: testStruct3{},
+		}
+
+		// can't be transformed back to on-chain, its completely lossy
+		offChainValue, err := nestedExtractorFieldUnderSlice.TransformToOffChain(onChainValue, "")
+		require.NoError(t, err)
+		require.Equal(t, [][16]uint8{}, offChainValue)
+
+		uninitialisedSliceExtractor := codec.NewPropertyExtractor("C.E")
+		_, err = uninitialisedSliceExtractor.RetypeToOffChain(reflect.TypeOf(nestedTestStruct{}), "")
+		require.NoError(t, err)
+
+		// can't be transformed back to on-chain, its completely lossy
+		offChainValue, err = uninitialisedSliceExtractor.TransformToOffChain(onChainValue, "")
+		require.NoError(t, err)
+		require.Equal(t, []testStruct2{}, offChainValue)
+
+		uninitialisedSliceExtractor = codec.NewPropertyExtractor("C.E.F")
+		_, err = uninitialisedSliceExtractor.RetypeToOffChain(reflect.TypeOf(nestedTestStruct{}), "")
+		require.NoError(t, err)
+
+		// can't be transformed back to on-chain, its completely lossy
+		offChainValue, err = uninitialisedSliceExtractor.TransformToOffChain(onChainValue, "")
+		require.NoError(t, err)
+		require.Equal(t, []int{}, offChainValue)
+	})
+
 	t.Run("TransformToOnChain and TransformToOffChain works on pointers", func(t *testing.T) {
 		_, err := nestedExtractor.RetypeToOffChain(reflect.PointerTo(onChainType), "")
 		require.NoError(t, err)

pkg/codec/utils.go

@@ -474,7 +474,7 @@ func SetValueAtPath(vInto, vField reflect.Value, itemType string) error {
 }
 
 func applyValue(vInto, vField reflect.Value) error {
-	if typeWithoutPtr(vInto.Type()) != typeWithoutPtr(vField.Type()) {
+	if derefTypePtr(vInto.Type()) != derefTypePtr(vField.Type()) {
 		return fmt.Errorf("value type mismatch for field")
 	}
 
@@ -522,11 +522,9 @@ func applyValue(vInto, vField reflect.Value) error {
 	return nil
 }
 
-func typeWithoutPtr(val reflect.Type) reflect.Type {
-	switch val.Kind() {
-	case reflect.Ptr:
-		return typeWithoutPtr(val.Elem())
-	default:
-		return val
+func derefTypePtr(typ reflect.Type) reflect.Type {
+	for typ.Kind() == reflect.Ptr {
+		typ = typ.Elem()
 	}
+	return typ
 }

pkg/codec/wrapper.go

@@ -72,10 +72,7 @@ func (m *wrapperModifier) TransformToOnChain(offChainValue any, itemType string)
 	}
 
 	// check if the offChainValue is a wrapper around the whole value
-	typ := reflect.TypeOf(offChainValue)
-	if typ.Kind() == reflect.Ptr {
-		typ = typ.Elem()
-	}
+	typ := derefTypePtr(reflect.TypeOf(offChainValue))
 
 	if typ.Kind() == reflect.Struct && typ.NumField() == 1 {
 		if m.isWholeValueWrapper() {