refactor(pc): string -> [4]bytes

eth/core/precompile/factories.go

@@ -111,10 +111,10 @@ func (sf *StatefulFactory) Build(
 // This function matches each Go implementation of the precompile to the ABI's respective function.
 // It searches for the ABI function in the Go precompile contract and performs basic validation on
 // the implemented function.
-func buildIdsToMethods(si StatefulImpl, contractImpl reflect.Value) (map[string]*method, error) {
+func buildIdsToMethods(si StatefulImpl, contractImpl reflect.Value) (map[[4]byte]*method, error) {
 	precompileABI := si.ABIMethods()
 	contractImplType := contractImpl.Type()
-	idsToMethods := make(map[string]*method)
+	idsToMethods := make(map[[4]byte]*method)
 	for m := 0; m < contractImplType.NumMethod(); m++ {
 		implMethod := contractImplType.Method(m)
 
@@ -127,12 +127,12 @@ func buildIdsToMethods(si StatefulImpl, contractImpl reflect.Value) (map[string]
 		}
 
 		method := newMethod(si, precompileABI[methodName], implMethod)
-		idsToMethods[utils.UnsafeBytesToStr(precompileABI[methodName].ID)] = method
+		idsToMethods[[4]byte(precompileABI[methodName].ID)] = method
 	}
 
 	// verify that every abi method has a corresponding precompile implementation
 	for _, abiMethod := range precompileABI {
-		if _, found := idsToMethods[utils.UnsafeBytesToStr(abiMethod.ID)]; !found {
+		if _, found := idsToMethods[[4]byte(abiMethod.ID)]; !found {
 			return nil, errorslib.Wrap(ErrNoPrecompileMethodForABIMethod, abiMethod.Name)
 		}
 	}

eth/core/precompile/method_test.go

@@ -64,6 +64,17 @@ var _ = Describe("Method", func() {
 	})
 })
 
+var _ = Describe("Test MethoID", func() {
+	It("should work", func() {
+		x := make([]byte, 0)
+		x = append(x, 0x12)
+		x = append(x, 0x34)
+		x = append(x, 0x56)
+		x = append(x, 0x78)
+		Expect([4]byte(x)).To(Equal([4]byte{0x12, 0x34, 0x56, 0x78}))
+	})
+})
+
 // MOCKS BELOW.
 
 type mockStatefulWithMethod struct {

eth/core/precompile/method_validation.go

@@ -38,8 +38,7 @@ func validateArg(implMethodVar reflect.Value, abiMethodVar reflect.Value) error
 	implMethodVarType := implMethodVar.Type()
 	abiMethodVarType := abiMethodVar.Type()
 
-	//nolint:exhaustive // only the ones we need.
-	switch implMethodVarType.Kind() {
+	switch implMethodVarType.Kind() { //nolint:exhaustive // todo verify its okay.
 	case reflect.Array, reflect.Slice:
 		if implMethodVarType.Elem() != abiMethodVarType.Elem() {
 			// If the array is not a slice/array of structs, return an error.

eth/core/precompile/stateful_container.go

@@ -26,7 +26,6 @@ import (
 
 	"pkg.berachain.dev/polaris/eth/common"
 	"pkg.berachain.dev/polaris/eth/core/vm"
-	"pkg.berachain.dev/polaris/lib/utils"
 )
 
 // NumBytesMethodID is the number of bytes used to represent a ABI method's ID.
@@ -42,7 +41,7 @@ type statefulContainer struct {
 	// method signatures) to native precompile functions. The signature key is provided by the
 	// precompile creator and must exactly match the signature in the geth abi.Method.Sig field
 	// (geth abi format). Please check core/precompile/container/method.go for more information.
-	idsToMethods map[string]*method
+	idsToMethods map[[4]byte]*method
 	// receive      *Method // TODO: implement
 	// fallback     *Method // TODO: implement
 
@@ -51,7 +50,7 @@ type statefulContainer struct {
 // NewStatefulContainer creates and returns a new `statefulContainer` with the given method ids
 // precompile functions map.
 func NewStatefulContainer(
-	si StatefulImpl, idsToMethods map[string]*method,
+	si StatefulImpl, idsToMethods map[[4]byte]*method,
 ) (vm.PrecompileContainer, error) {
 	if idsToMethods == nil {
 		return nil, ErrContainerHasNoMethods
@@ -78,7 +77,9 @@ func (sc *statefulContainer) Run(
 	}
 
 	// Extract the method ID from the input and load the method.
-	method, found := sc.idsToMethods[utils.UnsafeBytesToStr(input[:NumBytesMethodID])]
+
+	methodID := input[:NumBytesMethodID]
+	method, found := sc.idsToMethods[[4]byte(methodID)]
 	if !found {
 		return nil, ErrMethodNotFound
 	}

eth/core/precompile/stateful_container_test.go

@@ -29,7 +29,6 @@ import (
 	"pkg.berachain.dev/polaris/eth/common"
 	"pkg.berachain.dev/polaris/eth/core/vm"
 	vmmock "pkg.berachain.dev/polaris/eth/core/vm/mock"
-	"pkg.berachain.dev/polaris/lib/utils"
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
@@ -159,33 +158,33 @@ var (
 	contractFuncStrInputFunc, _  = reflect.TypeOf(mockStatefulDummy).MethodByName("ContractFuncStrInput")
 	overloadedFunc, _            = reflect.TypeOf(mockStatefulDummy).MethodByName("OverloadedFunc")
 	overloadedFunc0, _           = reflect.TypeOf(mockStatefulDummy).MethodByName("OverloadedFunc0")
-	mockIdsToMethods             = map[string]*method{
-		utils.UnsafeBytesToStr(getOutputABI.ID): newMethod(
+	mockIdsToMethods             = map[[4]byte]*method{
+		[4]byte(getOutputABI.ID): newMethod(
 			mockStatefulDummy,
 			getOutputABI,
 			getOutputFunc,
 		),
-		utils.UnsafeBytesToStr(getOutputPartialABI.ID): newMethod(
+		[4]byte(getOutputPartialABI.ID): newMethod(
 			mockStatefulDummy,
 			getOutputPartialABI,
 			getOutputPartialFunc,
 		),
-		utils.UnsafeBytesToStr(contractFuncAddrABI.ID): newMethod(
+		[4]byte(contractFuncAddrABI.ID): newMethod(
 			mockStatefulDummy,
 			contractFuncAddrABI,
 			contractFuncAddrInputFunc,
 		),
-		utils.UnsafeBytesToStr(contractFuncStrABI.ID): newMethod(
+		[4]byte(contractFuncStrABI.ID): newMethod(
 			mockStatefulDummy,
 			contractFuncStrABI,
 			contractFuncStrInputFunc,
 		),
-		utils.UnsafeBytesToStr(overloadedFuncABI.ID): newMethod(
+		[4]byte(overloadedFuncABI.ID): newMethod(
 			mockStatefulDummy,
 			overloadedFuncABI,
 			overloadedFunc,
 		),
-		utils.UnsafeBytesToStr(contractFuncStrABI.ID): newMethod(
+		[4]byte(contractFuncStrABI.ID): newMethod(
 			mockStatefulDummy,
 			overloadedFunc0ABI,
 			overloadedFunc0,