Merge conflicts

Author: ferranbt

CHANGELOG.md

@@ -1,5 +1,7 @@
 # 0.1.4 (Unreleased)
 
+- feat: Add override to `eth_call` request [[GH-240](https://github.com/umbracle/ethgo/issues/240)]
+- fix: Recovery of typed transactions [[GH-238](https://github.com/umbracle/ethgo/issues/238)]
 - fix: Parse `nonce` and `mixHash` on `Block` [[GH-228](https://github.com/umbracle/ethgo/issues/228)]
 - feat: `abi` decodes function string in multilines [[GH-212](https://github.com/umbracle/ethgo/issues/212)]
 - feat: `abi` DecodeStruct uses the `abi` tag instead of the default `mapstructure` [[GH-211](https://github.com/umbracle/ethgo/issues/211)]

README.md

@@ -1,9 +1,14 @@
 
 # Eth-Go
 
+[![Chat Badge]][chat link]
+
+[chat badge]: https://img.shields.io/badge/chat-discord-%237289da
+[chat link]: https://discord.gg/5A6Qm2u4yK
+
 Ethgo is a lightweight SDK in Go to interact with Ethereum compatible blockchains.
 
-- Website: https://ethgo.dev
+- Website: https://www.ethgoproject.io
 
 Ethgo provides the next key features:
 

abi/abi.go

@@ -404,10 +404,11 @@ func buildSignature(name string, typ *Type) string {
 
 // ArgumentStr encodes a type object
 type ArgumentStr struct {
-	Name       string
-	Type       string
-	Indexed    bool
-	Components []*ArgumentStr
+	Name         string
+	Type         string
+	Indexed      bool
+	Components   []*ArgumentStr
+	InternalType string
 }
 
 var keccakPool = sync.Pool{

abi/abi_test.go

@@ -1,11 +1,11 @@
 package abi
 
 import (
-	"fmt"
 	"reflect"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestAbi(t *testing.T) {
@@ -106,14 +106,53 @@ func TestAbi(t *testing.T) {
 			}
 
 			if !reflect.DeepEqual(abi, c.Output) {
-				fmt.Println(reflect.DeepEqual(abi.Methods["balanceOf"].Outputs, c.Output.Methods["balanceOf"].Outputs))
 				t.Fatal("bad")
 			}
-
 		})
 	}
 }
 
+func TestAbi_InternalType(t *testing.T) {
+	const abiStr = `[
+        {
+            "inputs": [
+				{
+					"components": [
+						{
+							"internalType": "address",
+							"type": "address"
+						},
+						{
+							"internalType": "uint256[4]",
+							"type": "uint256[4]"
+						}
+					],
+					"internalType": "struct X",
+					"name": "newSet",
+					"type": "tuple[]"
+				},
+                {
+                    "internalType": "custom_address",
+                    "name": "_to",
+                    "type": "address"
+                }
+			],
+			"outputs": [],
+			"name": "transfer",
+			"type": "function"
+		}
+	]`
+
+	abi, err := NewABI(abiStr)
+	require.NoError(t, err)
+
+	typ := abi.GetMethod("transfer").Inputs
+	require.Equal(t, typ.tuple[0].Elem.InternalType(), "struct X")
+	require.Equal(t, typ.tuple[0].Elem.elem.tuple[0].Elem.InternalType(), "address")
+	require.Equal(t, typ.tuple[0].Elem.elem.tuple[1].Elem.InternalType(), "uint256[4]")
+	require.Equal(t, typ.tuple[1].Elem.InternalType(), "custom_address")
+}
+
 func TestAbi_Polymorphism(t *testing.T) {
 	// This ABI contains 2 "transfer" functions (polymorphism)
 	const polymorphicABI = `[
@@ -208,49 +247,49 @@ func TestAbi_HumanReadable(t *testing.T) {
 			Inputs: MustNewType("tuple(string symbol, string name)"),
 		},
 		Methods: map[string]*Method{
-			"transferFrom": &Method{
+			"transferFrom": {
 				Name:    "transferFrom",
 				Inputs:  MustNewType("tuple(address from, address to, uint256 value)"),
 				Outputs: MustNewType("tuple()"),
 			},
-			"balanceOf": &Method{
+			"balanceOf": {
 				Name:    "balanceOf",
 				Inputs:  MustNewType("tuple(address owner)"),
 				Outputs: MustNewType("tuple(uint256 balance)"),
 			},
-			"balanceOf0": &Method{
+			"balanceOf0": {
 				Name:    "balanceOf",
 				Inputs:  MustNewType("tuple()"),
 				Outputs: MustNewType("tuple()"),
 			},
-			"addPerson": &Method{
+			"addPerson": {
 				Name:    "addPerson",
 				Inputs:  MustNewType("tuple(tuple(string name, uint16 age) person)"),
 				Outputs: MustNewType("tuple()"),
 			},
-			"addPeople": &Method{
+			"addPeople": {
 				Name:    "addPeople",
 				Inputs:  MustNewType("tuple(tuple(string name, uint16 age)[] person)"),
 				Outputs: MustNewType("tuple()"),
 			},
-			"getPerson": &Method{
+			"getPerson": {
 				Name:    "getPerson",
 				Inputs:  MustNewType("tuple(uint256 id)"),
 				Outputs: MustNewType("tuple(tuple(string name, uint16 age))"),
 			},
 		},
 		Events: map[string]*Event{
-			"Transfer": &Event{
+			"Transfer": {
 				Name:   "Transfer",
 				Inputs: MustNewType("tuple(address indexed from, address indexed to, address value)"),
 			},
-			"PersonAdded": &Event{
+			"PersonAdded": {
 				Name:   "PersonAdded",
 				Inputs: MustNewType("tuple(uint256 indexed id, tuple(string name, uint16 age) person)"),
 			},
 		},
 		Errors: map[string]*Error{
-			"InsufficientBalance": &Error{
+			"InsufficientBalance": {
 				Name:   "InsufficientBalance",
 				Inputs: MustNewType("tuple(address owner, uint256 balance)"),
 			},

abi/decode.go

@@ -296,7 +296,10 @@ func readLength(data []byte) (int, error) {
 		return 0, fmt.Errorf("length larger than int64: %v", lengthBig.Int64())
 	}
 	length := int(lengthBig.Uint64())
-	if length > len(data) {
+
+	// if we trim the length in the data there should be enough
+	// bytes to cover the length
+	if length > len(data)-32 {
 		return 0, fmt.Errorf("length insufficient %v require %v", len(data), length)
 	}
 	return length, nil

abi/decode_test.go

@@ -1,8 +1,20 @@
 package abi
 
-import "testing"
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
 
 func TestDecode_BytesBound(t *testing.T) {
 	typ := MustNewType("tuple(string)")
 	decodeTuple(typ, nil) // it should not panic
 }
+
+func TestDecode_DynamicLengthOutOfBounds(t *testing.T) {
+	input := []byte("00000000000000000000000000000000\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00 00000000000000000000000000")
+	typ := MustNewType("tuple(bytes32, bytes, bytes)")
+
+	_, err := Decode(typ, input)
+	require.Error(t, err)
+}

abi/encoding_test.go

@@ -621,10 +621,35 @@ func TestRandomEncoding(t *testing.T) {
 			if err := testEncodeDecode(t, server, tt, input); err != nil {
 				t.Fatal(err)
 			}
+
+			if err := testDecodePanic(tt, input); err != nil {
+				t.Fatal(err)
+			}
 		})
 	}
 }
 
+func testDecodePanic(tt *Type, input interface{}) error {
+	// test that the encoded input and random permutattions of the response do not cause
+	// panics on Decode function
+	res1, err := Encode(input, tt)
+	if err != nil {
+		return err
+	}
+
+	buf := make([]byte, len(res1))
+
+	// change each bit of the input with 1
+	for i := 0; i < len(res1); i++ {
+		copy(buf, res1)
+		buf[i] = 0xff
+
+		Decode(tt, buf)
+	}
+
+	return nil
+}
+
 func testTypeWithContract(t *testing.T, server *testutil.TestServer, typ *Type) error {
 	g := &generateContractImpl{}
 	source := g.run(typ)

abi/type.go

@@ -104,6 +104,7 @@ type Type struct {
 	elem  *Type
 	tuple []*TupleElem
 	t     reflect.Type
+	itype string
 }
 
 func NewTupleType(inputs []*TupleElem) *Type {
@@ -145,6 +146,11 @@ func (t *Type) DecodeStruct(input []byte, out interface{}) error {
 	return DecodeStruct(t, input, out)
 }
 
+// InternalType returns the internal type
+func (t *Type) InternalType() string {
+	return t.itype
+}
+
 // Encode encodes an object using this type
 func (t *Type) Encode(v interface{}) ([]byte, error) {
 	return Encode(v, t)
@@ -280,7 +286,50 @@ func NewTypeFromArgument(arg *ArgumentStr) (*Type, error) {
 	if err != nil {
 		return nil, err
 	}
-	return NewType(str)
+	typ, err := NewType(str)
+	if err != nil {
+		return nil, err
+	}
+
+	// fill-in the `internalType` field into the type elems
+	fillIn(typ, arg)
+
+	return typ, nil
+}
+
+func fillIn(typ *Type, arg *ArgumentStr) error {
+	typ.itype = arg.InternalType
+
+	if len(arg.Components) == 0 {
+		// no more items, nothing else to do
+		return nil
+	}
+
+	// tuple types in the ABI with slices are represented as
+	// tuple()[] or tuple()[2]. Thus, there might be element in the components
+	// section of the abi but the next item not be a tuple.
+	for {
+		kind := typ.kind
+		if kind == KindTuple {
+			break
+		}
+		if kind != KindArray && kind != KindSlice {
+			// error
+			return fmt.Errorf("array or slice not found")
+		}
+		typ = typ.Elem()
+	}
+
+	if len(arg.Components) != len(typ.tuple) {
+		// incorrect length
+		return fmt.Errorf("incorrect size")
+	}
+
+	for indx, i := range arg.Components {
+		fillIn(typ.tuple[indx].Elem, i)
+	}
+
+	return nil
 }
 
 // NewType parses a type in string format

abi/type_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestType(t *testing.T) {
@@ -363,6 +364,30 @@ func TestType(t *testing.T) {
 	}
 }
 
+func TestTypeArgument_InternalFields(t *testing.T) {
+	arg := &ArgumentStr{
+		Type: "tuple",
+		Components: []*ArgumentStr{
+			{
+				Type: "tuple[]",
+				Components: []*ArgumentStr{
+					{
+						Type:         "int32",
+						InternalType: "c",
+					},
+				},
+				InternalType: "b",
+			},
+		},
+	}
+
+	res, err := NewTypeFromArgument(arg)
+	require.NoError(t, err)
+
+	require.Equal(t, res.tuple[0].Elem.itype, "b")
+	require.Equal(t, res.tuple[0].Elem.elem.tuple[0].Elem.itype, "c")
+}
+
 func TestSize(t *testing.T) {
 	cases := []struct {
 		Input string