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 ¶
const ( IntTy byte = iota UintTy BoolTy SliceTy AddressTy RealTy )
Variables ¶
This section is empty.
Functions ¶
Types ¶
type ABI ¶
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 ¶
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) Pack ¶
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 ¶
type Argument ¶
Argument holds the name of the argument and the corresponding type. Types are used when packing and testing arguments.
func (*Argument) UnmarshalJSON ¶
type Method ¶
Callable method 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.
type Type ¶
type Type struct {
Kind reflect.Kind
Type reflect.Type
Size int
T byte // Our own type checking
// contains filtered or unexported fields
}
Type is the reflection of the supported argument type
func NewType ¶
NewType returns a fully parsed Type given by the input string or an error if it can't be parsed.
Strings can be in the format of:
Input = Type [ "[" [ Number ] "]" ] Name . Type = [ "u" ] "int" [ Number ] .
Examples:
string int uint real string32 int8 uint8 uint[] address int256 uint256 real[2]
Source Files