Fixes after merge

Author: sobolev-igor

accounts/abi/argument.go

@@ -241,41 +241,7 @@ func (arguments Arguments) UnpackValues(data []byte) ([]any, error) {
 	return retval, nil
 }
 
-// UnpackValues can be used to unpack ABI-encoded hexdata according to the ABI-specification,
-// without supplying a struct to unpack into. Instead, this method returns a list containing the
-// values converted to strings. An atomic argument will be a list with one element.
-func (arguments Arguments) UnpackValuesAsStrings(data []byte) ([]interface{}, error) {
-	nonIndexedArgs := arguments.NonIndexed()
-	retval := make([]interface{}, 0, len(nonIndexedArgs))
-	virtualArgs := 0
-	for index, arg := range nonIndexedArgs {
-		marshalledValue, err := toString((index+virtualArgs)*32, arg.Type, data)
-		if err != nil {
-			return nil, err
-		}
-		if arg.Type.T == ArrayTy && !isDynamicType(arg.Type) {
-			// If we have a static array, like [3]uint256, these are coded as
-			// just like uint256,uint256,uint256.
-			// This means that we need to add two 'virtual' arguments when
-			// we count the index from now on.
-			//
-			// Array values nested multiple levels deep are also encoded inline:
-			// [2][3]uint256: uint256,uint256,uint256,uint256,uint256,uint256
-			//
-			// Calculate the full array size to get the correct offset for the next argument.
-			// Decrement it by 1, as the normal index increment is still applied.
-			virtualArgs += getTypeSize(arg.Type)/32 - 1
-		} else if arg.Type.T == TupleTy && !isDynamicType(arg.Type) {
-			// If we have a static tuple, like (uint256, bool, uint256), these are
-			// coded as just like uint256,bool,uint256
-			virtualArgs += getTypeSize(arg.Type)/32 - 1
-		}
-		retval = append(retval, marshalledValue)
-	}
-	return retval, nil
-}
-
-// UnpackValues can be used to unpack ABI-encoded hexdata according to the ABI-specification,
+// UnpackValuesAsStrings can be used to unpack ABI-encoded hexdata according to the ABI-specification,
 // without supplying a struct to unpack into. Instead, this method returns a list containing the
 // values converted to strings. An atomic argument will be a list with one element.
 func (arguments Arguments) UnpackValuesAsStrings(data []byte) ([]interface{}, error) {

accounts/abi/type.go

@@ -390,166 +390,6 @@ func NewTypeAsString(t string, internalType string, components []ArgumentMarshal
 	return
 }
 
-// NewTypeAsString creates a new reflection type of abi type given in t.
-func NewTypeAsString(t string, internalType string, components []ArgumentMarshaling) (typ Type, err error) {
-	// check that array brackets are equal if they exist
-	if strings.Count(t, "[") != strings.Count(t, "]") {
-		return Type{}, errors.New("invalid arg type in abi")
-	}
-	typ.stringKind = t
-
-	// if there are brackets, get ready to go into slice/array mode and
-	// recursively create the type
-	if strings.Count(t, "[") != 0 {
-		// Note internalType can be empty here.
-		subInternal := internalType
-		if i := strings.LastIndex(internalType, "["); i != -1 {
-			subInternal = subInternal[:i]
-		}
-		// recursively embed the type
-		i := strings.LastIndex(t, "[")
-		embeddedType, err := NewTypeAsString(t[:i], subInternal, components)
-		if err != nil {
-			return Type{}, err
-		}
-		// grab the last cell and create a type from there
-		sliced := t[i:]
-		// grab the slice size with regexp
-		re := regexp.MustCompile("[0-9]+")
-		intz := re.FindAllString(sliced, -1)
-
-		if len(intz) == 0 {
-			// is a slice
-			typ.T = SliceTy
-			typ.Elem = &embeddedType
-			typ.stringKind = embeddedType.stringKind + sliced
-		} else if len(intz) == 1 {
-			// is an array
-			typ.T = ArrayTy
-			typ.Elem = &embeddedType
-			typ.Size, err = strconv.Atoi(intz[0])
-			if err != nil {
-				return Type{}, fmt.Errorf("abi: error parsing variable size: %v", err)
-			}
-			typ.stringKind = embeddedType.stringKind + sliced
-		} else {
-			return Type{}, errors.New("invalid formatting of array type")
-		}
-		return typ, err
-	}
-	// parse the type and size of the abi-type.
-	matches := typeRegex.FindAllStringSubmatch(t, -1)
-	if len(matches) == 0 {
-		return Type{}, fmt.Errorf("invalid type '%v'", t)
-	}
-	parsedType := matches[0]
-
-	// varSize is the size of the variable
-	var varSize int
-	if len(parsedType[3]) > 0 {
-		var err error
-		varSize, err = strconv.Atoi(parsedType[2])
-		if err != nil {
-			return Type{}, fmt.Errorf("abi: error parsing variable size: %v", err)
-		}
-	} else {
-		if parsedType[0] == "uint" || parsedType[0] == "int" {
-			// this should fail because it means that there's something wrong with
-			// the abi type (the compiler should always format it to the size...always)
-			return Type{}, fmt.Errorf("unsupported arg type: %s", t)
-		}
-	}
-	// varType is the parsed abi type
-	switch varType := parsedType[1]; varType {
-	case "int":
-		typ.Size = varSize
-		typ.T = IntTy
-	case "uint":
-		typ.Size = varSize
-		typ.T = UintTy
-	case "bool":
-		typ.T = BoolTy
-	case "address":
-		typ.Size = 20
-		typ.T = AddressTy
-	case "string":
-		typ.T = StringTy
-	case "bytes":
-		if varSize == 0 {
-			typ.T = BytesTy
-		} else {
-			if varSize > 32 {
-				return Type{}, fmt.Errorf("unsupported arg type: %s", t)
-			}
-			typ.T = FixedBytesTy
-			typ.Size = varSize
-		}
-	case "tuple":
-		var (
-			fields     []reflect.StructField
-			elems      []*Type
-			names      []string
-			expression string // canonical parameter expression
-			used       = make(map[string]bool)
-		)
-		expression += "("
-		for idx, c := range components {
-			cType, err := NewTypeAsString(c.Type, c.InternalType, c.Components)
-			if err != nil {
-				return Type{}, err
-			}
-			name := ToCamelCase(c.Name)
-			if name == "" {
-				return Type{}, errors.New("abi: purely anonymous or underscored field is not supported")
-			}
-			fieldName := ResolveNameConflict(name, func(s string) bool { return used[s] })
-			if err != nil {
-				return Type{}, err
-			}
-			used[fieldName] = true
-			if !isValidFieldName(fieldName) {
-				return Type{}, fmt.Errorf("field %d has invalid name", idx)
-			}
-			fields = append(fields, reflect.StructField{
-				Name: fieldName, // reflect.StructOf will panic for any exported field.
-				Type: cType.GetTypeAsString(),
-				Tag:  reflect.StructTag("json:\"" + c.Name + "\""),
-			})
-			elems = append(elems, &cType)
-			names = append(names, c.Name)
-			expression += cType.stringKind
-			if idx != len(components)-1 {
-				expression += ","
-			}
-		}
-		expression += ")"
-
-		typ.TupleType = reflect.StructOf(fields)
-		typ.TupleElems = elems
-		typ.TupleRawNames = names
-		typ.T = TupleTy
-		typ.stringKind = expression
-
-		const structPrefix = "struct "
-		// After solidity 0.5.10, a new field of abi "internalType"
-		// is introduced. From that we can obtain the struct name
-		// user defined in the source code.
-		if internalType != "" && strings.HasPrefix(internalType, structPrefix) {
-			// Foo.Bar type definition is not allowed in golang,
-			// convert the format to FooBar
-			typ.TupleRawName = strings.ReplaceAll(internalType[len(structPrefix):], ".", "")
-		}
-
-	case "function":
-		typ.T = FunctionTy
-		typ.Size = 24
-	default:
-		return Type{}, fmt.Errorf("unsupported arg type: %s", t)
-	}
-
-	return
-}
-
 // GetType returns the reflection type of the ABI type.
 func (t Type) GetType() reflect.Type {
 	switch t.T {
@@ -618,42 +458,6 @@ func (t Type) GetTypeAsString() reflect.Type {
 	}
 }
 
-// GetTypeAsString returns the reflection type of the ABI type (always string).
-func (t Type) GetTypeAsString() reflect.Type {
-	switch t.T {
-	case IntTy:
-		return reflect.TypeOf("")
-	case UintTy:
-		return reflect.TypeOf("")
-	case BoolTy:
-		return reflect.TypeOf("")
-	case StringTy:
-		return reflect.TypeOf("")
-	case SliceTy:
-		return reflect.SliceOf(t.Elem.GetTypeAsString())
-	case ArrayTy:
-		return reflect.ArrayOf(t.Size, t.Elem.GetTypeAsString())
-	case TupleTy:
-		return t.TupleType
-	case AddressTy:
-		return reflect.TypeOf("")
-	case FixedBytesTy:
-		return reflect.TypeOf("")
-	case BytesTy:
-		return reflect.TypeOf("")
-	case HashTy:
-		// hashtype currently not used
-		return reflect.TypeOf("")
-	case FixedPointTy:
-		// fixedpoint type currently not used
-		return reflect.TypeOf("")
-	case FunctionTy:
-		return reflect.TypeOf("")
-	default:
-		panic("Invalid type")
-	}
-}
-
 // String implements Stringer.
 func (t Type) String() (out string) {
 	return t.stringKind

ethclient/ethclient.go

@@ -696,6 +696,14 @@ func (ec *Client) SendTransaction(ctx context.Context, tx *types.Transaction) er
 	return ec.c.CallContext(ctx, nil, "eth_sendRawTransaction", hexutil.Encode(data))
 }
 
+// SendRawTransaction injects a raw transaction into the pending pool for execution.
+//
+// If the transaction was a contract creation use the TransactionReceipt method to get the
+// contract address after the transaction has been mined.
+func (ec *Client) SendRawTransaction(ctx context.Context, rawTx string) error {
+	return ec.c.CallContext(ctx, nil, "eth_sendRawTransaction", rawTx)
+}
+
 // RevertErrorData returns the 'revert reason' data of a contract call.
 //
 // This can be used with CallContract and EstimateGas, and only when the server is Geth.
@@ -711,13 +719,6 @@ func RevertErrorData(err error) ([]byte, bool) {
 		}
 	}
 	return nil, false
-
-// SendRawTransaction injects a raw transaction into the pending pool for execution.
-//
-// If the transaction was a contract creation use the TransactionReceipt method to get the
-// contract address after the transaction has been mined.
-func (ec *Client) SendRawTransaction(ctx context.Context, rawTx string) error {
-	return ec.c.CallContext(ctx, nil, "eth_sendRawTransaction", rawTx)
 }
 
 func toBlockNumArg(number *big.Int) string {