ABI: Bugfix - now it's compliant (#165)

* Abi updates

* Fixing unit tests

* Overall data tests

Author: 0x19

abi/builder.go

@@ -36,7 +36,8 @@ func NewBuilderFromSources(ctx context.Context, sources *solgo.Sources) (*Builde
 		parser:     parser,
 		astBuilder: parser.GetAstBuilder(),
 		resolver: &TypeResolver{
-			parser: parser,
+			parser:         parser,
+			processedTypes: make(map[string]bool),
 		},
 	}, nil
 }
@@ -124,9 +125,11 @@ func (b *Builder) Parse() (errs []error) {
 }
 
 // Build constructs the ABIs from the sources.
-func (b *Builder) Build() error {
+func (b *Builder) Build() (err error) {
 	if root := b.GetParser().GetRoot(); root != nil {
-		b.root = b.processRoot(root)
+		if b.root, err = b.processRoot(root); err != nil {
+			return err
+		}
 	}
 	return nil
 }

abi/constructor.go

@@ -1,10 +1,14 @@
 package abi
 
-import "github.com/unpackdev/solgo/ir"
+import (
+	"fmt"
+
+	"github.com/unpackdev/solgo/ir"
+)
 
 // processConstructor processes an IR constructor and returns a Method representation of it.
 // It extracts the input and output parameters of the constructor and normalizes its state mutability.
-func (b *Builder) processConstructor(unit *ir.Constructor) *Method {
+func (b *Builder) processConstructor(unit *ir.Constructor) (*Method, error) {
 	// Initialize a new Method structure for the constructor.
 	toReturn := &Method{
 		Name:            "", // Constructors in Ethereum don't have a name.
@@ -15,6 +19,10 @@ func (b *Builder) processConstructor(unit *ir.Constructor) *Method {
 	}
 
 	for _, parameter := range unit.GetParameters() {
+		if parameter.GetTypeDescription() == nil {
+			return nil, fmt.Errorf("nil type description for constructor parameter %s", parameter.GetName())
+		}
+
 		methodIo := MethodIO{
 			Name: parameter.GetName(),
 		}
@@ -24,17 +32,5 @@ func (b *Builder) processConstructor(unit *ir.Constructor) *Method {
 		)
 	}
 
-	// Process return statements of the constructor.
-	// Note: In Ethereum, constructors don't return values. This might be specific to the IR representation.
-	/* for _, parameter := range unit.GetReturnStatements() {
-		methodIo := MethodIO{
-			Name: parameter.GetName(),
-		}
-		toReturn.Outputs = append(
-			toReturn.Outputs,
-			b.buildMethodIO(methodIo, parameter.GetTypeDescription()),
-		)
-	} */
-
-	return toReturn
+	return toReturn, nil
 }

abi/constructor_test.go

@@ -47,7 +47,8 @@ func TestProcessConstructor(t *testing.T) {
 	}
 
 	builder := &Builder{}
-	result := builder.processConstructor(mockConstructor)
+	result, err := builder.processConstructor(mockConstructor)
+	assert.NoError(t, err)
 
 	// Assert that the returned Method object has the expected properties
 	assert.Equal(t, "constructor", result.Type)

abi/contract.go

@@ -2,6 +2,7 @@ package abi
 
 import (
 	abi_pb "github.com/unpackdev/protos/dist/go/abi"
+	ast_pb "github.com/unpackdev/protos/dist/go/ast"
 	"github.com/unpackdev/solgo/ast"
 	"github.com/unpackdev/solgo/ir"
 )
@@ -44,7 +45,7 @@ func (c *Contract) ToProto() *abi_pb.Contract {
 
 // processContract processes an IR contract and returns a Contract representation of it.
 // It extracts state variables, events, errors, constructor, functions, fallback, and receive methods.
-func (b *Builder) processContract(contract *ir.Contract) *Contract {
+func (b *Builder) processContract(contract *ir.Contract) (*Contract, error) {
 	toReturn := Contract{}
 
 	// Process state variables.
@@ -55,28 +56,44 @@ func (b *Builder) processContract(contract *ir.Contract) *Contract {
 
 	// Process events.
 	for _, event := range contract.GetEvents() {
-		method := b.processEvent(event)
+		method, err := b.processEvent(event)
+		if err != nil {
+			return nil, err
+		}
+
 		toReturn = append(toReturn, method)
 	}
 
 	// Process errors.
 	for _, errorNode := range contract.GetErrors() {
-		method := b.processError(errorNode)
+		method, err := b.processError(errorNode)
+		if err != nil {
+			return nil, err
+		}
+
 		toReturn = append(toReturn, method)
 	}
 
 	// Process constructor.
 	if contract.GetConstructor() != nil {
-		toReturn = append(
-			toReturn,
-			b.processConstructor(contract.GetConstructor()),
-		)
+		method, err := b.processConstructor(contract.GetConstructor())
+		if err != nil {
+			return nil, err
+		}
+
+		toReturn = append(toReturn, method)
 	}
 
 	// Process functions.
 	for _, function := range contract.GetFunctions() {
-		method := b.processFunction(function)
-		toReturn = append(toReturn, method)
+		if function.GetVisibility() == ast_pb.Visibility_PUBLIC && function.GetVisibility() == ast_pb.Visibility_EXTERNAL {
+			method, err := b.processFunction(function)
+			if err != nil {
+				return nil, err
+			}
+
+			toReturn = append(toReturn, method)
+		}
 	}
 
 	// Process fallback.
@@ -89,13 +106,15 @@ func (b *Builder) processContract(contract *ir.Contract) *Contract {
 
 	// Process receive.
 	if contract.GetReceive() != nil {
-		toReturn = append(
-			toReturn,
-			b.processReceive(contract.GetReceive()),
-		)
+		method, err := b.processReceive(contract.GetReceive())
+		if err != nil {
+			return nil, err
+		}
+
+		toReturn = append(toReturn, method)
 	}
 
-	return &toReturn
+	return &toReturn, nil
 }
 
 // buildMethodIO constructs a MethodIO object based on the provided method and type description.

abi/error.go

@@ -1,12 +1,14 @@
 package abi
 
 import (
+	"fmt"
+
 	"github.com/unpackdev/solgo/ir"
 )
 
 // processError processes an IR error and returns a Method representation of it.
 // It extracts the name and parameters of the error and sets its type to "error" and state mutability to "view".
-func (b *Builder) processError(unit *ir.Error) *Method {
+func (b *Builder) processError(unit *ir.Error) (*Method, error) {
 	toReturn := &Method{
 		Name:            unit.GetName(),
 		Inputs:          make([]MethodIO, 0),
@@ -16,13 +18,19 @@ func (b *Builder) processError(unit *ir.Error) *Method {
 	}
 
 	for _, parameter := range unit.GetParameters() {
-		toReturn.Inputs = append(toReturn.Inputs, MethodIO{
-			Name:         parameter.GetName(),
-			Type:         normalizeTypeName(parameter.GetTypeDescription().GetString()),
-			InternalType: parameter.GetTypeDescription().GetString(),
-			Indexed:      true, // Parameters for errors are indexed by default.
-		})
+		if parameter.GetTypeDescription() == nil {
+			return nil, fmt.Errorf("nil type description for error parameter %s", parameter.GetName())
+		}
+
+		methodIo := MethodIO{
+			Name:    parameter.GetName(),
+			Indexed: parameter.IsIndexed(),
+		}
+		toReturn.Inputs = append(
+			toReturn.Inputs,
+			b.buildMethodIO(methodIo, parameter.GetTypeDescription()),
+		)
 	}
 
-	return toReturn
+	return toReturn, nil
 }

abi/error_test.go

@@ -36,7 +36,7 @@ func TestProcessError(t *testing.T) {
 						Name:         "param1",
 						Type:         "uint256",
 						InternalType: "uint256",
-						Indexed:      true,
+						Indexed:      false,
 					},
 				},
 				Outputs: []MethodIO{},
@@ -52,12 +52,14 @@ func TestProcessError(t *testing.T) {
 						TypeDescription: &ast.TypeDescription{
 							TypeString: "uint256",
 						},
+						Indexed: true,
 					},
 					{
 						Name: "param2",
 						TypeDescription: &ast.TypeDescription{
 							TypeString: "address",
 						},
+						Indexed: true,
 					},
 				},
 			},
@@ -88,7 +90,8 @@ func TestProcessError(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := builder.processError(tt.input)
+			result, err := builder.processError(tt.input)
+			assert.NoError(t, err)
 			assert.Equal(t, tt.expected, result)
 		})
 	}

abi/event.go

@@ -1,12 +1,14 @@
 package abi
 
 import (
+	"fmt"
+
 	"github.com/unpackdev/solgo/ir"
 )
 
 // processEvent processes an IR event and returns a Method representation of it.
 // It extracts the name and parameters of the event and sets its type to "event" and state mutability to "view".
-func (b *Builder) processEvent(unit *ir.Event) *Method {
+func (b *Builder) processEvent(unit *ir.Event) (*Method, error) {
 	toReturn := &Method{
 		Name:            unit.GetName(),
 		Inputs:          make([]MethodIO, 0),
@@ -16,15 +18,30 @@ func (b *Builder) processEvent(unit *ir.Event) *Method {
 	}
 
 	// Process parameters of the event.
-	// Note: In Ethereum, event parameters are considered as outputs.
+	// Note: In Ethereum, event parameters are considered as inputs.
 	for _, parameter := range unit.GetParameters() {
-		toReturn.Outputs = append(toReturn.Outputs, MethodIO{
-			Name:         parameter.GetName(),
-			Type:         parameter.GetTypeDescription().TypeString,
-			InternalType: parameter.GetTypeDescription().TypeString,
-			Indexed:      true, // Parameters for events can be indexed.
-		})
+		if parameter.GetTypeDescription() == nil {
+			return nil, fmt.Errorf("nil type description for event parameter %s", parameter.GetName())
+		}
+
+		methodIo := MethodIO{
+			Name:    parameter.GetName(),
+			Indexed: parameter.IsIndexed(),
+		}
+		toReturn.Inputs = append(
+			toReturn.Inputs,
+			b.buildMethodIO(methodIo, parameter.GetTypeDescription()),
+		)
+	}
+
+	return toReturn, nil
+}
+
+func (b *Builder) GetEventAsAbi(unit *ir.Event) ([]*Method, error) {
+	method, err := b.processEvent(unit)
+	if err != nil {
+		return nil, err
 	}
 
-	return toReturn
+	return []*Method{method}, nil
 }

abi/event_test.go

@@ -9,7 +9,12 @@ import (
 )
 
 func TestProcessEvent(t *testing.T) {
-	builder := &Builder{}
+	builder := &Builder{
+		resolver: &TypeResolver{
+			parser:         nil,
+			processedTypes: make(map[string]bool),
+		},
+	}
 
 	testCases := []struct {
 		name            string
@@ -29,6 +34,7 @@ func TestProcessEvent(t *testing.T) {
 							TypeString:     "uint256",
 							TypeIdentifier: "t_uint256",
 						},
+						Indexed: true,
 					},
 				},
 			},
@@ -40,10 +46,11 @@ func TestProcessEvent(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			result := builder.processEvent(tc.input)
+			result, err := builder.processEvent(tc.input)
+			assert.NoError(t, err)
 			assert.Equal(t, tc.expectedType, result.Type)
 			assert.Equal(t, tc.expectedName, result.Name)
-			assert.Equal(t, tc.expectedOutputs, len(result.Outputs))
+			assert.Equal(t, tc.expectedOutputs, len(result.Inputs))
 			for _, output := range result.Outputs {
 				assert.True(t, output.Indexed)
 			}

abi/fallback.go

@@ -1,7 +1,9 @@
 // Package abi provides tools for building and parsing Ethereum ABI (Application Binary Interface) data.
 package abi
 
-import "github.com/unpackdev/solgo/ir"
+import (
+	"github.com/unpackdev/solgo/ir"
+)
 
 // processFallback processes an IR fallback function and returns a Method representation of it.
 // It extracts the input and output parameters of the fallback function and normalizes its state mutability.
@@ -14,27 +16,5 @@ func (b *Builder) processFallback(unit *ir.Fallback) *Method {
 		StateMutability: b.normalizeStateMutability(unit.GetStateMutability()),
 	}
 
-	for _, parameter := range unit.GetParameters() {
-		methodIo := MethodIO{
-			Name: parameter.GetName(),
-		}
-		toReturn.Inputs = append(
-			toReturn.Inputs,
-			b.buildMethodIO(methodIo, parameter.GetTypeDescription()),
-		)
-	}
-
-	// Process return statements of the fallback function.
-	// Note: In Ethereum, fallback functions can have return values.
-	/* 	for _, parameter := range unit.GetReturnStatements() {
-		methodIo := MethodIO{
-			Name: parameter.GetName(),
-		}
-		toReturn.Outputs = append(
-			toReturn.Outputs,
-			b.buildMethodIO(methodIo, parameter.GetTypeDescription()),
-		)
-	} */
-
 	return toReturn
 }

abi/fallback_test.go

@@ -53,12 +53,6 @@ func TestProcessFallback(t *testing.T) {
 	assert.Equal(t, "fallback", result.Type)
 	assert.Equal(t, builder.normalizeStateMutability(mockFallback.GetStateMutability()), result.StateMutability)
 	assert.Equal(t, "", result.Name)
-	assert.Equal(t, 2, len(result.Inputs))
-	assert.Equal(t, "inputParam1", result.Inputs[0].Name)
-	assert.Equal(t, "inputParam2", result.Inputs[1].Name)
-	assert.Equal(t, "uint256", result.Inputs[0].Type)
-	assert.Equal(t, "uint256", result.Inputs[1].Type)
-	assert.Equal(t, "uint256", result.Inputs[0].InternalType)
-	assert.Equal(t, "uint256", result.Inputs[1].InternalType)
+	assert.Equal(t, 0, len(result.Inputs))
 	assert.Equal(t, 0, len(result.Outputs))
 }