Optimize solidity mapping perf (#1221)

* Optimize solidity mapping perf

* Update builtin/solidity/mapping.go

* fix nil handling of mapping

* dont use named returns

Author: otherview

builtin/solidity/mapping.go

@@ -6,8 +6,6 @@
 package solidity
 
 import (
-	"reflect"
-
 	"github.com/ethereum/go-ethereum/rlp"
 
 	"github.com/vechain/thor/v2/thor"
@@ -19,44 +17,99 @@ type Key interface {
 
 // Mapping is a key/value storage abstraction for built-in contracts, similar to the mapping in Solidity.
 // It DOES NOT (TBD) allow for direct access to values if declared in the same `pos` in the built-in contract.
-type Mapping[K Key, V any] struct {
+//
+// Mapping behavior:
+//
+//   - Setting the default type value means removing the value from storage
+//
+//   - If Mapping[thor.Bytes32, *thor.Address]:
+//     ex: SET (k:0x123, v:nil) -> stores nil
+//     ex: SET (k:0x123, v:&thor.Address{})  -> stores nil
+//
+//   - If Mapping[thor.Bytes32, thor.Address]:
+//     ex: SET (k:0x123, v:thor.Address{}) -> stores nil (default empty value)
+//
+//   - Getting a nil storage value will always return default value of V not an empty pointer of the instance
+//
+//   - If Mapping[thor.Bytes32, *thor.Address]:
+//     ex: SET (k:0x123, v:nil) GET (k:0x123)-> returns nil
+//     ex: SET (k:0x123, v:&thor.Address{}) GET (k:0x123)-> returns nil
+//
+//   - If Mapping[thor.Bytes32, thor.Address]:
+//     ex: SET (k:0x123, v:nil) GET (k:0x123)-> returns thor.Address{} (default empty value)
+//     ex: SET (k:0x123, v:thor.Address{}) GET (k:0x123)-> returns thor.Address{} (default empty value)
+//
+// - Getting a non-existing storage will always return the default value of the type defined in the V comparable mapping
+type Mapping[K Key, V comparable] struct {
 	context *Context
 	basePos thor.Bytes32
 }
 
-func NewMapping[K Key, V any](context *Context, pos thor.Bytes32) *Mapping[K, V] {
+// NewMapping creates a new persistent mapping at the given storage position.
+func NewMapping[K Key, V comparable](context *Context, pos thor.Bytes32) *Mapping[K, V] {
 	return &Mapping[K, V]{context: context, basePos: pos}
 }
 
-func (m *Mapping[K, V]) Get(key K) (value V, err error) {
+// Get retrieves the value for the given key, charging SloadGas per 32-byte word.
+// If no value is present, returns the zero-value of V.
+func (m *Mapping[K, V]) Get(key K) (V, error) {
+	// compute the storage slot from key + base position
 	position := thor.Blake2b(key.Bytes(), m.basePos.Bytes())
-	err = m.context.state.DecodeStorage(m.context.address, position, func(raw []byte) error {
-		if reflect.ValueOf(value).Kind() == reflect.Ptr {
-			value = reflect.New(reflect.TypeOf(value).Elem()).Interface().(V)
-		}
-		if len(raw) == 0 {
-			return nil
-		}
-		slots := (uint64(len(raw)) + 31) / 32
-		m.context.UseGas(slots * thor.SloadGas)
-		return rlp.DecodeBytes(raw, &value)
-	})
-	return
+
+	// prepare a zero-value container for decoding
+	var value V
+
+	// attempt to decode storage into value
+	err := m.context.state.DecodeStorage(
+		m.context.address, position, func(raw []byte) error {
+			if len(raw) == 0 {
+				// no data, leave value as zero
+				return nil
+			}
+
+			// charge gas per 32-byte word
+			slots := (uint64(len(raw)) + 31) / 32
+			m.context.UseGas(slots * thor.SloadGas)
+
+			// decode RLP in-place
+			return rlp.DecodeBytes(raw, &value)
+		})
+	if err != nil {
+		// return zero type value
+		var zero V
+		return zero, err
+	}
+
+	return value, nil
 }
 
+// Set stores the given value at key, charging Sstore gas per 32-byte word.
+// Passing the zero-value of V clears the storage slot.
 func (m *Mapping[K, V]) Set(key K, value V, newValue bool) error {
 	position := thor.Blake2b(key.Bytes(), m.basePos.Bytes())
+
+	// do not RLP-encode nil values, instead set raw storage to nil
+	var zero V
+	if value == zero {
+		m.context.state.SetRawStorage(m.context.address, position, nil)
+		return nil
+	}
+
+	// encode and store
 	return m.context.state.EncodeStorage(m.context.address, position, func() ([]byte, error) {
-		val, err := rlp.EncodeToBytes(value)
+		// encode via rlp library's internal pooling
+		buf, err := rlp.EncodeToBytes(value)
 		if err != nil {
 			return nil, err
 		}
-		slots := (uint64(len(val)) + 31) / 32
+
+		// charge gas per 32-byte word
+		slots := (uint64(len(buf)) + 31) / 32
 		if newValue {
 			m.context.UseGas(slots * thor.SstoreSetGas)
 		} else {
 			m.context.UseGas(slots * thor.SstoreResetGas)
 		}
-		return rlp.EncodeToBytes(value)
+		return buf, nil
 	})
 }