Documentation

Index

Constants

View Source
const ElementSize = 32

    EVM Solidity calls and return values are packed into pieces of 32 bytes, including a bool (wasting 255 out of 256 bits)

    View Source
    const EventIDSize = 32

      EventIDSize is the length of the event selector

      View Source
      const FallbackFunctionName = "()"

        Token to use in deploy yaml in order to indicate call to the fallback function.

        View Source
        const FunctionIDSize = 4

          FunctionIDSize is the length of the function selector

          Variables

          This section is empty.

          Functions

          func GetPackingTypes

          func GetPackingTypes(args []Argument) []interface{}

          func Pack

          func Pack(argSpec []Argument, args ...interface{}) ([]byte, error)

          func PackEvent

          func PackEvent(eventSpec *EventSpec, args ...interface{}) ([]binary.Word256, []byte, error)

          func Signature

          func Signature(name string, args []Argument) string

          func Unpack

          func Unpack(argSpec []Argument, data []byte, args ...interface{}) error

          func UnpackEvent

          func UnpackEvent(eventSpec *EventSpec, topics []binary.Word256, data []byte, args ...interface{}) error

          func UnpackRevert

          func UnpackRevert(data []byte) (message *string, err error)

            UnpackRevert decodes the revert reason if a contract called revert. If no reason was given, message will be nil else it will point to the string

            Types

            type Argument

            type Argument struct {
            	Name        string
            	EVM         EVMType
            	IsArray     bool
            	Indexed     bool
            	Hashed      bool
            	ArrayLength uint64
            }

              Argument is a decoded function parameter, return or event field

              type EVMAddress

              type EVMAddress struct {
              }

              func (EVMAddress) Dynamic

              func (e EVMAddress) Dynamic() bool

              func (EVMAddress) GetSignature

              func (e EVMAddress) GetSignature() string

              func (EVMAddress) ImplicitCast

              func (e EVMAddress) ImplicitCast(o EVMType) bool

              func (EVMAddress) String

              func (e EVMAddress) String() string

              type EVMBool

              type EVMBool struct {
              }

              func (EVMBool) Dynamic

              func (e EVMBool) Dynamic() bool

              func (EVMBool) GetSignature

              func (e EVMBool) GetSignature() string

              func (EVMBool) ImplicitCast

              func (e EVMBool) ImplicitCast(o EVMType) bool

              func (EVMBool) String

              func (e EVMBool) String() string

              type EVMBytes

              type EVMBytes struct {
              	M uint64
              }

              func (EVMBytes) Dynamic

              func (e EVMBytes) Dynamic() bool

              func (EVMBytes) GetSignature

              func (e EVMBytes) GetSignature() string

              func (EVMBytes) ImplicitCast

              func (e EVMBytes) ImplicitCast(o EVMType) bool

              func (EVMBytes) String

              func (e EVMBytes) String() string

              type EVMFixed

              type EVMFixed struct {
              	N, M uint64
              	// contains filtered or unexported fields
              }

              func (EVMFixed) Dynamic

              func (e EVMFixed) Dynamic() bool

              func (EVMFixed) GetSignature

              func (e EVMFixed) GetSignature() string

              func (EVMFixed) ImplicitCast

              func (e EVMFixed) ImplicitCast(o EVMType) bool

              type EVMInt

              type EVMInt struct {
              	M uint64
              }

              func (EVMInt) Dynamic

              func (e EVMInt) Dynamic() bool

              func (EVMInt) GetSignature

              func (e EVMInt) GetSignature() string

              func (EVMInt) ImplicitCast

              func (e EVMInt) ImplicitCast(o EVMType) bool

              func (EVMInt) String

              func (e EVMInt) String() string

              type EVMString

              type EVMString struct {
              }

              func (EVMString) Dynamic

              func (e EVMString) Dynamic() bool

              func (EVMString) GetSignature

              func (e EVMString) GetSignature() string

              func (EVMString) ImplicitCast

              func (e EVMString) ImplicitCast(o EVMType) bool

              func (EVMString) String

              func (e EVMString) String() string

              type EVMType

              type EVMType interface {
              	GetSignature() string
              
              	Dynamic() bool
              	ImplicitCast(o EVMType) bool
              	// contains filtered or unexported methods
              }

              type EVMUint

              type EVMUint struct {
              	M uint64
              }

              func (EVMUint) Dynamic

              func (e EVMUint) Dynamic() bool

              func (EVMUint) GetSignature

              func (e EVMUint) GetSignature() string

              func (EVMUint) ImplicitCast

              func (e EVMUint) ImplicitCast(o EVMType) bool

              func (EVMUint) String

              func (e EVMUint) String() string

              type EventID

              type EventID [EventIDSize]byte

              func GetEventID

              func GetEventID(signature string) (id EventID)

              func (EventID) Bytes

              func (id EventID) Bytes() []byte

              func (EventID) String

              func (id EventID) String() string

              type EventSpec

              type EventSpec struct {
              	ID        EventID
              	Inputs    []Argument
              	Name      string
              	Anonymous bool
              }

              func (*EventSpec) Get

              func (e *EventSpec) Get(key string) (interface{}, bool)

              func (*EventSpec) String

              func (e *EventSpec) String() string

              func (*EventSpec) UnmarshalJSON

              func (e *EventSpec) UnmarshalJSON(data []byte) error

              type FunctionID

              type FunctionID [FunctionIDSize]byte

              func GetFunctionID

              func GetFunctionID(signature string) (id FunctionID)

              func (FunctionID) Bytes

              func (fs FunctionID) Bytes() []byte

              type FunctionSpec

              type FunctionSpec struct {
              	Name       string
              	FunctionID FunctionID
              	Constant   bool
              	Inputs     []Argument
              	Outputs    []Argument
              }

              func EncodeFunctionCall

              func EncodeFunctionCall(abiData, funcName string, logger *logging.Logger, args ...interface{}) ([]byte, *FunctionSpec, error)

                EncodeFunctionCall ABI encodes a function call based on ABI in string abiData and the arguments specified as strings. The fname specifies which function should called, if it doesn't exist exist the fallback function will be called. If fname is the empty string, the constructor is called. The arguments must be specified in args. The count must match the function being called. Returns the ABI encoded function call, whether the function is constant according to the ABI (which means it does not modified contract state)

                func EncodeFunctionCallFromFile

                func EncodeFunctionCallFromFile(abiFileName, abiPath, funcName string, logger *logging.Logger, args ...interface{}) ([]byte, *FunctionSpec, error)

                  EncodeFunctionCallFromFile ABI encodes a function call based on ABI in file, and the arguments specified as strings. The abiFileName specifies the name of the ABI file, and abiPath the path where it can be found. The fname specifies which function should called, if it doesn't exist exist the fallback function will be called. If fname is the empty string, the constructor is called. The arguments must be specified in args. The count must match the function being called. Returns the ABI encoded function call, whether the function is constant according to the ABI (which means it does not modified contract state)

                  func NewFunctionSpec

                  func NewFunctionSpec(name string, inputs, outputs []Argument) *FunctionSpec

                  func SpecFromFunctionReflect

                  func SpecFromFunctionReflect(fname string, v reflect.Value, skipIn, skipOut int) *FunctionSpec

                  func SpecFromStructReflect

                  func SpecFromStructReflect(fname string, args reflect.Type, rets reflect.Type) *FunctionSpec

                    SpecFromStructReflect generates a FunctionSpec where the arguments and return values are described a struct. Both args and rets should be set to the return value of reflect.TypeOf() with the respective struct as an argument.

                    func (*FunctionSpec) SetConstant

                    func (f *FunctionSpec) SetConstant() *FunctionSpec

                      Sets this function as constant

                      func (*FunctionSpec) String

                      func (f *FunctionSpec) String() string

                      type Spec

                      type Spec struct {
                      	Constructor  *FunctionSpec
                      	Fallback     *FunctionSpec
                      	Functions    map[string]*FunctionSpec
                      	EventsByName map[string]*EventSpec
                      	EventsByID   map[EventID]*EventSpec
                      }

                        Spec is the ABI for contract decoded.

                        func LoadPath

                        func LoadPath(abiFileOrDirs ...string) (*Spec, error)

                          LoadPath loads one abi file or finds all files in a directory

                          func MergeSpec

                          func MergeSpec(abiSpec []*Spec) *Spec

                            MergeSpec takes multiple Specs and merges them into once structure. Note that the same function name or event name can occur in different abis, so there might be some information loss.

                            func NewSpec

                            func NewSpec() *Spec

                            func ReadSpec

                            func ReadSpec(specBytes []byte) (*Spec, error)

                              ReadSpec takes an ABI and decodes it for futher use

                              func ReadSpecFile

                              func ReadSpecFile(filename string) (*Spec, error)

                                ReadSpecFile reads an ABI file from a file

                                func (*Spec) GetEventAbi

                                func (spec *Spec) GetEventAbi(id EventID, addresses crypto.Address) (*EventSpec, error)

                                func (*Spec) Pack

                                func (spec *Spec) Pack(fname string, args ...interface{}) ([]byte, *FunctionSpec, error)

                                  Pack ABI encodes a function call. The fname specifies which function should called, if it doesn't exist exist the fallback function will be called. If fname is the empty string, the constructor is called. The arguments must be specified in args. The count must match the function being called. Returns the ABI encoded function call, whether the function is constant according to the ABI (which means it does not modified contract state)

                                  func (*Spec) Unpack

                                  func (spec *Spec) Unpack(data []byte, fname string, args ...interface{}) error

                                    Unpack decodes the return values from a function call

                                    func (*Spec) UnpackWithID

                                    func (spec *Spec) UnpackWithID(data []byte, args ...interface{}) error

                                    type Variable

                                    type Variable struct {
                                    	Name  string
                                    	Value string
                                    }

                                      Variable exist to unpack return values into, so have both the return value and its name

                                      func DecodeFunctionReturn

                                      func DecodeFunctionReturn(abiData, name string, data []byte) ([]*Variable, error)

                                      func DecodeFunctionReturnFromFile

                                      func DecodeFunctionReturnFromFile(abiLocation, binPath, funcName string, resultRaw []byte, logger *logging.Logger) ([]*Variable, error)

                                        DecodeFunctionReturnFromFile ABI decodes the return value from a contract function call.