github.com/ebakus/go-ebakus@v1.0.5-0.20200520105415-dbccef9ec421/accounts/abi/abi.go

// Copyright 2019 The ebakus/go-ebakus Authors
// This file is part of the ebakus/go-ebakus library.
//
// The ebakus/go-ebakus library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The ebakus/go-ebakus library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the ebakus/go-ebakus library. If not, see <http://www.gnu.org/licenses/>.

package abi

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"

	"github.com/ebakus/go-ebakus/common"
)

type ArgumentsType int

const (
	InputsArgumentsType ArgumentsType = iota
	OutputsArgumentsType
)

// 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.
type ABI struct {
	Constructor Method
	Methods     map[string]Method
	Events      map[string]Event
	Tables      map[string]Table
}

// JSON returns a parsed ABI interface and error if it failed.
func JSON(reader io.Reader) (ABI, error) {
	dec := json.NewDecoder(reader)

	var abi ABI
	if err := dec.Decode(&abi); err != nil {
		return ABI{}, err
	}

	return abi, nil
}

// 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 ABI) Pack(name string, args ...interface{}) ([]byte, error) {
	return abi.PackWithArguments(name, InputsArgumentsType, args...)
}

// Unpack output in v according to the abi specification
func (abi ABI) Unpack(v interface{}, name string, output []byte) (err error) {
	return abi.UnpackWithArguments(v, name, output, OutputsArgumentsType)
}

// PackWithArguments 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 ABI) PackWithArguments(name string, argumentsType ArgumentsType, args ...interface{}) ([]byte, error) {
	// Fetch the ABI of the requested method
	if name == "" {
		// constructor
		arguments, err := abi.Constructor.Inputs.Pack(args...)
		if err != nil {
			return nil, err
		}
		return arguments, nil
	}

	var id, arguments []byte
	var err error
	if method, ok := abi.Methods[name]; ok {
		id = method.ID()
		switch argumentsType {
		case InputsArgumentsType:
			arguments, err = method.Inputs.Pack(args...)
		case OutputsArgumentsType:
			arguments, err = method.Outputs.Pack(args...)
		}
		if err != nil {
			return nil, err
		}
	} else if table, ok := abi.Tables[name]; ok {
		arguments, err = table.Pack(args...)
		if err != nil {
			return nil, err
		}
	} else {
		return nil, fmt.Errorf("method or table '%s' not found", name)
	}

	// Pack up the method ID too if not a constructor and return
	return append(id, arguments...), nil
}

// UnpackWithArguments output in v according to the abi specification
func (abi ABI) UnpackWithArguments(v interface{}, name string, data []byte, argumentsType ArgumentsType) (err error) {
	if len(data) == 0 {
		return fmt.Errorf("abi: unmarshalling empty output")
	}

	// since there can't be naming collisions with contracts and events,
	// we need to decide whether we're calling a method or an event
	if method, ok := abi.Methods[name]; ok {
		if len(data)%32 != 0 {
			return fmt.Errorf("abi: improperly formatted output: %s - Bytes: [%+v]", string(data), data)
		}

		switch argumentsType {
		case InputsArgumentsType:
			return method.Inputs.Unpack(v, data)
		case OutputsArgumentsType:
			return method.Outputs.Unpack(v, data)
		}
	} else if event, ok := abi.Events[name]; ok {
		return event.Inputs.Unpack(v, data)
	} else if table, ok := abi.Tables[name]; ok {
		return table.Inputs.Unpack(v, data)
	}
	return fmt.Errorf("abi: could not locate named method, event or table")
}

// UnpackIntoMap unpacks a log into the provided map[string]interface{}
func (abi ABI) UnpackIntoMap(v map[string]interface{}, name string, data []byte) (err error) {
	// since there can't be naming collisions with contracts and events,
	// we need to decide whether we're calling a method or an event
	if method, ok := abi.Methods[name]; ok {
		if len(data)%32 != 0 {
			return fmt.Errorf("abi: improperly formatted output")
		}
		return method.Outputs.UnpackIntoMap(v, data)
	}
	if event, ok := abi.Events[name]; ok {
		return event.Inputs.UnpackIntoMap(v, data)
	}
	return fmt.Errorf("abi: could not locate named method, event or table")
}

// UnmarshalJSON implements json.Unmarshaler interface
func (abi *ABI) UnmarshalJSON(data []byte) error {
	var fields []struct {
		Type      string
		Name      string
		Constant  bool
		Anonymous bool
		Inputs    []Argument
		Outputs   []Argument
	}
	if err := json.Unmarshal(data, &fields); err != nil {
		return err
	}
	abi.Methods = make(map[string]Method)
	abi.Events = make(map[string]Event)
	abi.Tables = make(map[string]Table)
	for _, field := range fields {
		switch field.Type {
		case "constructor":
			abi.Constructor = Method{
				Inputs: field.Inputs,
			}
		// empty defaults to function according to the abi spec
		case "function", "":
			name := field.Name
			_, ok := abi.Methods[name]
			for idx := 0; ok; idx++ {
				name = fmt.Sprintf("%s%d", field.Name, idx)
				_, ok = abi.Methods[name]
			}
			abi.Methods[name] = Method{
				Name:    name,
				RawName: field.Name,
				Const:   field.Constant,
				Inputs:  field.Inputs,
				Outputs: field.Outputs,
			}
		case "event":
			name := field.Name
			_, ok := abi.Events[name]
			for idx := 0; ok; idx++ {
				name = fmt.Sprintf("%s%d", field.Name, idx)
				_, ok = abi.Events[name]
			}
			abi.Events[name] = Event{
				Name:      name,
				RawName:   field.Name,
				Anonymous: field.Anonymous,
				Inputs:    field.Inputs,
			}
		case "table":
			abi.Tables[field.Name] = Table{
				Name:   field.Name,
				Inputs: field.Inputs,
			}
		}
	}

	return nil
}

// MethodById looks up a method by the 4-byte id
// returns nil if none found
func (abi *ABI) MethodById(sigdata []byte) (*Method, error) {
	if len(sigdata) < 4 {
		return nil, fmt.Errorf("data too short (%d bytes) for abi method lookup", len(sigdata))
	}
	for _, method := range abi.Methods {
		if bytes.Equal(method.ID(), sigdata[:4]) {
			return &method, nil
		}
	}
	return nil, fmt.Errorf("no method with id: %#x", sigdata[:4])
}

// EventByID looks an event up by its topic hash in the
// ABI and returns nil if none found.
func (abi *ABI) EventByID(topic common.Hash) (*Event, error) {
	for _, event := range abi.Events {
		if bytes.Equal(event.ID().Bytes(), topic.Bytes()) {
			return &event, nil
		}
	}
	return nil, fmt.Errorf("no event with id: %#x", topic.Hex())
}

// GetTableInstance returns a table instance
func (abi *ABI) GetTableInstance(name string) (interface{}, error) {
	if table, ok := abi.Tables[name]; ok {
		return table.GetTableInstance()
	}
	return nil, fmt.Errorf("abi: could not locate named table")
}

// UnpackSingle fill single field in struct for this table from provided output of single value encoded abi
func (abi *ABI) UnpackSingle(v interface{}, name string, field string, output []byte) (interface{}, error) {
	if table, ok := abi.Tables[name]; ok {
		return table.UnpackSingle(v, field, output)
	}
	return nil, fmt.Errorf("abi: could not locate named table")
}