core-chain/common/natspec/natspec.go

package natspec

import (
	"encoding/json"
	"fmt"
	"github.com/robertkrimen/otto"
	"strings"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/crypto"
)

type abi2method map[[8]byte]*method

type NatSpec struct {
	jsvm                    *otto.Otto
	methods                 abi2method
	userDocJson, abiDocJson []byte
	userDoc                 userDoc
	// abiDoc abiDoc
}

// TODO: should initialise with abi and userdoc jsons
func New() (self *NatSpec, err error) {
	// fetch abi, userdoc
	abi := []byte("")
	userdoc := []byte("")
	return NewWithDocs(abi, userdoc)
}

func NewWithDocs(abiDocJson, userDocJson []byte) (self *NatSpec, err error) {

	self = &NatSpec{
		jsvm:        otto.New(),
		abiDocJson:  abiDocJson,
		userDocJson: userDocJson,
	}

	_, err = self.jsvm.Run(natspecJS)
	if err != nil {
		return
	}
	_, err = self.jsvm.Run("var natspec = require('natspec');")
	if err != nil {
		return
	}

	err = json.Unmarshal(userDocJson, &self.userDoc)
	// err = parseAbiJson(abiDocJson, &self.abiDoc)

	return
}

// type abiDoc []method

// type method struct {
// 	Name   string  `json:name`
// 	Inputs []input `json:inputs`
// 	abiKey [8]byte
// }

// type input struct {
// 	Name string `json:name`
// 	Type string `json:type`
// }

type method struct {
	Notice string `json:notice`
	name   string
}

type userDoc struct {
	Methods map[string]*method `json:methods`
}

func (self *NatSpec) makeAbi2method(abiKey [8]byte) (meth *method) {
	if self.methods != nil {
		meth = self.methods[abiKey]
		return
	}
	self.methods = make(abi2method)
	for signature, m := range self.userDoc.Methods {
		name := strings.Split(signature, "(")[0]
		hash := []byte(common.Bytes2Hex(crypto.Sha3([]byte(signature))))
		var key [8]byte
		copy(key[:], hash[:8])
		self.methods[key] = meth
		meth.name = name
		if key == abiKey {
			meth = m
		}
	}
	return
}

func (self *NatSpec) Notice(tx string, abi string) (notice string, err error) {
	var abiKey [8]byte
	copy(abiKey[:], []byte(abi)[:8])
	meth := self.makeAbi2method(abiKey)
	if meth == nil {
		err = fmt.Errorf("abi key %x does not match any method %v")
		return
	}
	notice, err = self.noticeForMethod(tx, meth.name, meth.Notice)
	return
}

func (self *NatSpec) noticeForMethod(tx string, name, expression string) (notice string, err error) {
	if _, err = self.jsvm.Run("var transaction = " + tx + ";"); err != nil {
		return "", fmt.Errorf("natspec.js error setting transaction: %v", err)
	}

	if _, err = self.jsvm.Run("var abi = " + string(self.abiDocJson) + ";"); err != nil {
		return "", fmt.Errorf("natspec.js error setting abi: %v", err)
	}

	if _, err = self.jsvm.Run("var method = '" + name + "';"); err != nil {
		return "", fmt.Errorf("natspec.js error setting method: %v", err)
	}

	if _, err = self.jsvm.Run("var expression = \"" + expression + "\";"); err != nil {
		return "", fmt.Errorf("natspec.js error setting expression: %v", err)
	}

	self.jsvm.Run("var call = {method: method,abi: abi,transaction: transaction};")
	value, err := self.jsvm.Run("natspec.evaluateExpression(expression, call);")
	if err != nil {
		return "", fmt.Errorf("natspec.js error evaluating expression: %v", err)
	}
	evalError := "Natspec evaluation failed, wrong input params"
	if value.String() == evalError {
		return "", fmt.Errorf("natspec.js error evaluating expression: wrong input params in expression '%s'", expression)
	}
	if len(value.String()) == 0 {
		return "", fmt.Errorf("natspec.js error evaluating expression")
	}

	return value.String(), nil

}