go-ethereum: github.com/axiomzen/go-ethereum/accounts/abi Index | Examples | Files | Directories

package abi

import "github.com/axiomzen/go-ethereum/accounts/abi"

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

Package Files

abi.go argument.go doc.go error.go event.go method.go numbers.go pack.go reflect.go type.go unpack.go

Constants

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

Type enumerator

func ToCamelCase Uses

func ToCamelCase(input string) string

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

func U256 Uses

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

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

type ABI Uses

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 Uses

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

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

Code:

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) EventByID Uses

func (abi *ABI) EventByID(topic common.Hash) (*Event, error)

EventByID looks an event up by its topic hash in the ABI and returns nil if none found.

func (*ABI) MethodById Uses

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 Uses

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 Uses

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

UnmarshalJSON implements json.Unmarshaler interface

func (ABI) Unpack Uses

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

Unpack output in v according to the abi specification

func (ABI) UnpackIntoMap Uses

func (abi ABI) UnpackIntoMap(v map[string]interface{}, name string, data []byte) (err error)

UnpackIntoMap unpacks a log into the provided map[string]interface{}

type Argument Uses

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 Uses

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

UnmarshalJSON implements json.Unmarshaler interface

type ArgumentMarshaling Uses

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

type Arguments Uses

type Arguments []Argument

func (Arguments) LengthNonIndexed Uses

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 Uses

func (arguments Arguments) NonIndexed() Arguments

NonIndexed returns the arguments with indexed arguments filtered out

func (Arguments) Pack Uses

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

Pack performs the operation Go format -> Hexdata

func (Arguments) PackValues Uses

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

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

func (Arguments) Unpack Uses

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

Unpack performs the operation hexdata -> Go format

func (Arguments) UnpackIntoMap Uses

func (arguments Arguments) UnpackIntoMap(v map[string]interface{}, data []byte) error

UnpackIntoMap performs the operation hexdata -> mapping of argument name to argument value

func (Arguments) UnpackValues Uses

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.

type Event Uses

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 Uses

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 Uses

func (e Event) String() string

type Method Uses

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 therefore requires no Tx to be send to the network. A method such as `Transact` does require a Tx and thus will be flagged `false`. Input specifies the required input parameters for this gives method.

func (Method) Id Uses

func (method Method) Id() []byte

func (Method) Sig Uses

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 Uses

func (method Method) String() string

type Type Uses

type Type struct {
    Elem *Type
    Kind reflect.Kind
    Type reflect.Type
    Size int
    T    byte // Our own type checking

    // Tuple relative fields
    TupleElems    []*Type  // Type information of all tuple fields
    TupleRawNames []string // Raw field name of all tuple fields
    // contains filtered or unexported fields
}

Type is the reflection of the supported argument type

func NewType Uses

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

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

func (Type) String Uses

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

String implements Stringer

Directories

PathSynopsis
bindPackage bind generates Ethereum contract Go bindings.
bind/backends

Package abi imports 14 packages (graph). Updated 2019-07-06. Refresh now. Tools for package owners.