abi

package
v1.1.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 4, 2022 License: GPL-3.0 Imports: 17 Imported by: 0

Documentation

Overview

Package abi implements the Ethereum ABI (Application Binary Interface).

The Ethereum ABI is strongly typed, known at compile time and static. This ABI will handle basic type casting; unsigned to signed and visa versa. It does not handle slice casting such as unsigned slice to signed slice. Bit size type casting is also handled. ints with a bit size of 32 will be properly cast to int256, etc.

Index

Examples

Constants

View Source 
const (
	IntTy byte = iota
	UintTy
	BoolTy
	StringTy
	SliceTy
	ArrayTy
	// TupleTy
	AddressTy
	FixedBytesTy
	BytesTy
	HashTy
	FixedPointTy
	FunctionTy

	// newly Added [2020-08-06]
	TupleTy
)

Type enumerator

View Source 
const (
	ContractTypeWasm     = "wasm"
	ContractTypeSolidity = "sol"
)

Variables

View Source 
var (
	// MaxUint256 is the maximum value that can be represented by a uint256
	MaxUint256 = new(big.Int).Sub(new(big.Int).Lsh(common.Big1, 256), common.Big1)
	// MaxInt256 is the maximum value that can be represented by a int256
	MaxInt256 = new(big.Int).Sub(new(big.Int).Lsh(common.Big1, 255), common.Big1)
)

Functions

func BytesConverter 

func BytesConverter(source []byte, t string) interface{}

BytesConverter converts the bytes to the specific data type it is the same as the BytesConverter in ctool/core/bytes_util.go

func GenerateInputData 

func GenerateInputData(ct ContractType, input []byte) ([]byte, error)

func GetFuncParamWrap 

func GetFuncParamWrap(str string) []string

func GetFuncParams 

func GetFuncParams(paramString string) []string

func ParseWasmCallSolInput 

func ParseWasmCallSolInput(input []byte) ([]byte, error)

func ReadFixedBytes 

func ReadFixedBytes(t Type, word []byte) (interface{}, error)

ReadFixedBytes uses reflection to create a fixed array to be read from

func ReadInteger 

func ReadInteger(typ Type, b []byte) interface{}

ReadInteger reads the integer based on its kind and returns the appropriate value

func SetInputLength 

func SetInputLength(input []byte) (res []byte)

func Sig 

func Sig(funcName string, types []string) string

func SolInputStringTOInt 

func SolInputStringTOInt(v string, bitSize int, hasNotPrefixU bool) (interface{}, error)

func SolInputTypeConversion 

func SolInputTypeConversion(t string, v string) (interface{}, error)

func SpliceParam 

func SpliceParam(param string) (paramType string, paramValue string, err error)

func StringConverter 

func StringConverter(source string, t string) ([]byte, error)

func StringConverterV2 

func StringConverterV2(source string, t string) ([]byte, error)

func StringToArg 

func StringToArg(source string, t string) (interface{}, error)

related to the cpp.abi.json file

func ToCamelCase 

func ToCamelCase(input string) string

ToCamelCase converts an under-score string to a camel-case string

func TrimSpace 

func TrimSpace(str string) string

TrimSpace trims all the space in the string

func U256 

func U256(n *big.Int) []byte

U256 converts a big Int into a 256bit EVM number.

func WasmArgToBytes 

func WasmArgToBytes(arg interface{}) []byte

only used for cpp contract

Types

type ABI 

type ABI struct {
	Constructor Method
	Methods     map[string]Method
	Events      map[string]Event
}

The ABI holds information about a contract's context and available invokable methods. It will allow you to type check function calls and packs data accordingly.

func JSON 

func JSON(reader io.Reader) (ABI, error)

JSON returns a parsed ABI interface and error if it failed.

Example 
const definition = `[{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"isBar","outputs":[{"name":"","type":"bool"}],"type":"function"}]`

abi, err := JSON(strings.NewReader(definition))
if err != nil {
	log.Fatalln(err)
}
out, err := abi.Pack("isBar", common.HexToAddress("01"))
if err != nil {
	log.Fatalln(err)
}

fmt.Printf("%x\n", out)

Output:

1f2c40920000000000000000000000000000000000000000000000000000000000000001

func (*ABI) MethodById 

func (abi *ABI) MethodById(sigdata []byte) (*Method, error)

MethodById looks up a method by the 4-byte id returns nil if none found

func (ABI) Pack 

func (abi ABI) Pack(name string, args ...interface{}) ([]byte, error)

Pack the given method name to conform the ABI. Method call's data will consist of method_id, args0, arg1, ... argN. Method id consists of 4 bytes and arguments are all 32 bytes. Method ids are created from the first 4 bytes of the hash of the methods string signature. (signature = baz(uint32,string32))

func (*ABI) UnmarshalJSON 

func (abi *ABI) UnmarshalJSON(data []byte) error

UnmarshalJSON implements json.Unmarshaler interface

func (ABI) Unpack 

func (abi ABI) Unpack(v interface{}, name string, output []byte) (err error)

Unpack output in v according to the abi specification

type Argument 

type Argument struct {
	Name    string
	Type    Type
	Indexed bool // indexed is only used by events
}

Argument holds the name of the argument and the corresponding type. Types are used when packing and testing arguments.

func (*Argument) UnmarshalJSON 

func (argument *Argument) UnmarshalJSON(data []byte) error

UnmarshalJSON implements json.Unmarshaler interface

type ArgumentMarshaling 

type ArgumentMarshaling struct {
	Name         string
	Type         string
	InternalType string
	Components   []ArgumentMarshaling
	Indexed      bool
}

type Arguments 

type Arguments []Argument

func (Arguments) LengthNonIndexed 

func (arguments Arguments) LengthNonIndexed() int

LengthNonIndexed returns the number of arguments when not counting 'indexed' ones. Only events can ever have 'indexed' arguments, it should always be false on arguments for method input/output

func (Arguments) NonIndexed 

func (arguments Arguments) NonIndexed() Arguments

NonIndexed returns the arguments with indexed arguments filtered out

func (Arguments) Pack 

func (arguments Arguments) Pack(args ...interface{}) ([]byte, error)

Pack performs the operation Go format -> Hexdata

func (Arguments) PackV2 

func (arguments Arguments) PackV2(args ...interface{}) ([]byte, error)

Pack performs the operation Go format -> Hexdata

func (Arguments) PackValues 

func (arguments Arguments) PackValues(args []interface{}) ([]byte, error)

PackValues performs the operation Go format -> Hexdata It is the semantic opposite of UnpackValues

func (Arguments) ReturnBytesUnpack 

func (arguments Arguments) ReturnBytesUnpack(data string) []interface{}

func (Arguments) Unpack 

func (arguments Arguments) Unpack(v interface{}, data []byte) error

Unpack performs the operation hexdata -> Go format

func (Arguments) UnpackV2 

func (arguments Arguments) UnpackV2(v interface{}, data []byte) error

Unpack performs the operation hexdata -> Go format

func (Arguments) UnpackValues 

func (arguments Arguments) UnpackValues(data []byte) ([]interface{}, error)

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. An atomic argument will be a list with one element.

func (Arguments) UnpackValuesV2 

func (arguments Arguments) UnpackValuesV2(data []byte) ([]interface{}, error)

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. An atomic argument will be a list with one element.

type ContractType 

type ContractType interface {
	GenerateInputData() ([]byte, error)
	NewContractTypeFromJson([]byte) error
}

type Event 

type Event struct {
	Name      string
	Anonymous bool
	Inputs    Arguments
}

Event is an event potentially triggered by the EVM's LOG mechanism. The Event holds type information (inputs) about the yielded output. Anonymous events don't get the signature canonical representation as the first LOG topic.

func (Event) Id 

func (e Event) Id() common.Hash

Id returns the canonical representation of the event's signature used by the abi definition to identify event names and types.

func (Event) String 

func (e Event) String() string

type Method 

type Method struct {
	Name    string
	Const   bool
	Inputs  Arguments
	Outputs Arguments
}

Method represents a callable given a `Name` and whether the method is a constant. If the method is `Const` no transaction needs to be created for this particular Method call. It can easily be simulated using a local VM. For example a `Balance()` method only needs to retrieve something from the storage and therefor requires no Tx to be send to the network. A method such as `Transact` does require a Tx and thus will be flagged `true`. Input specifies the required input parameters for this gives method.

func (Method) Id 

func (method Method) Id() []byte

func (Method) Sig 

func (method Method) Sig() string

Sig returns the methods string signature according to the ABI spec.

Example 

function foo(uint32 a, int b)    =    "foo(uint32,int256)"

Please note that "int" is substitute for its canonical representation "int256"

func (Method) String 

func (method Method) String() string

type SolInput 

type SolInput struct {
	FuncName   string   `json:"func_name"`
	FuncParams []string `json:"func_params"`
}

func (*SolInput) GenerateInputData 

func (s *SolInput) GenerateInputData() ([]byte, error)

Generate input data for solidity contract

func (*SolInput) NewContractTypeFromJson 

func (s *SolInput) NewContractTypeFromJson(input []byte) error

type Type 

type Type struct {
	Elem *Type

	Kind reflect.Kind
	Type reflect.Type
	Size int
	T    byte // Our own type checking

	// newly Added [2020-08-06]
	// Tuple relative fields
	TupleRawName  string       // Raw struct name defined in source code, may be empty.
	TupleElems    []*Type      // Type information of all tuple fields
	TupleRawNames []string     // Raw field name of all tuple fields
	TupleType     reflect.Type // Underlying struct of the tuple
	// contains filtered or unexported fields
}

Type is the reflection of the supported argument type

func NewType 

func NewType(t string) (typ Type, err error)

NewType creates a new reflection type of abi type given in t.

func NewTypeV2 

func NewTypeV2(t string, internalType string, components []ArgumentMarshaling) (typ Type, err error)

NewType creates a new reflection type of abi type given in t.

func (Type) GetType 

func (t Type) GetType() reflect.Type

GetType returns the reflection type of the ABI type.

func (Type) String 

func (t Type) String() (out string)

String implements Stringer

func (Type) StringConvert 

func (t Type) StringConvert(value string) (interface{}, error)

newly added StringConvert converts the input string to the actual type defined in golang

type WasmInput 

type WasmInput struct {
	TxType     int      `json:"-"`
	FuncName   string   `json:"func_name"`
	FuncParams []string `json:"func_params"`
}

func (*WasmInput) GenerateInputData 

func (c *WasmInput) GenerateInputData() ([]byte, error)

Generate the input data of the wasm contract

func (*WasmInput) NewContractTypeFromJson 

func (c *WasmInput) NewContractTypeFromJson(input []byte) error

Source Files

View all Source files

Directories

Path Synopsis
Package bind generates Ethereum contract Go bindings.
 Package bind generates Ethereum contract Go bindings.
backends

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.