neo-go/pkg/core/transaction/oracle.go

package transaction

import (
	"encoding/json"
	"errors"
	"math"
	"strings"

	"github.com/nspcc-dev/neo-go/pkg/io"
)

//go:generate stringer -type=OracleResponseCode

// OracleResponseCode represents result code of oracle response.
type OracleResponseCode byte

// OracleResponse represents oracle response.
type OracleResponse struct {
	ID     uint64             `json:"id"`
	Code   OracleResponseCode `json:"code"`
	Result []byte             `json:"result"`
}

// MaxOracleResultSize is the maximum allowed oracle answer size.
const MaxOracleResultSize = math.MaxUint16

// Enumeration of possible oracle response types.
const (
	Success                 OracleResponseCode = 0x00
	ProtocolNotSupported    OracleResponseCode = 0x10
	ConsensusUnreachable    OracleResponseCode = 0x12
	NotFound                OracleResponseCode = 0x14
	Timeout                 OracleResponseCode = 0x16
	Forbidden               OracleResponseCode = 0x18
	ResponseTooLarge        OracleResponseCode = 0x1a
	InsufficientFunds       OracleResponseCode = 0x1c
	ContentTypeNotSupported OracleResponseCode = 0x1f
	Error                   OracleResponseCode = 0xff
)

// Various validation errors.
var (
	ErrInvalidResponseCode = errors.New("invalid oracle response code")
	ErrInvalidResult       = errors.New("oracle response != success, but result is not empty")
)

// IsValid checks if c is valid response code.
func (c OracleResponseCode) IsValid() bool {
	return c == Success || c == ProtocolNotSupported || c == ConsensusUnreachable || c == NotFound ||
		c == Timeout || c == Forbidden || c == ResponseTooLarge ||
		c == InsufficientFunds || c == ContentTypeNotSupported || c == Error
}

// MarshalJSON implements the json.Marshaler interface.
func (c OracleResponseCode) MarshalJSON() ([]byte, error) {
	return []byte(`"` + c.String() + `"`), nil
}

// UnmarshalJSON implements the json.Unmarshaler interface.
func (c *OracleResponseCode) UnmarshalJSON(data []byte) error {
	var js string
	if err := json.Unmarshal(data, &js); err != nil {
		return err
	}
	js = strings.ToLower(js)
	switch js {
	case "success":
		*c = Success
	case "protocolnotsupported":
		*c = ProtocolNotSupported
	case "consensusunreachable":
		*c = ConsensusUnreachable
	case "notfound":
		*c = NotFound
	case "timeout":
		*c = Timeout
	case "forbidden":
		*c = Forbidden
	case "responsetoolarge":
		*c = ResponseTooLarge
	case "insufficientfunds":
		*c = InsufficientFunds
	case "contenttypenotsupported":
		*c = ContentTypeNotSupported
	case "error":
		*c = Error
	default:
		return errors.New("invalid oracle response code")
	}
	return nil
}

// DecodeBinary implements the io.Serializable interface.
func (r *OracleResponse) DecodeBinary(br *io.BinReader) {
	r.ID = br.ReadU64LE()
	r.Code = OracleResponseCode(br.ReadB())
	if !r.Code.IsValid() {
		br.Err = ErrInvalidResponseCode
		return
	}
	r.Result = br.ReadVarBytes(MaxOracleResultSize)
	if r.Code != Success && len(r.Result) > 0 {
		br.Err = ErrInvalidResult
	}
}

// EncodeBinary implements the io.Serializable interface.
func (r *OracleResponse) EncodeBinary(w *io.BinWriter) {
	w.WriteU64LE(r.ID)
	w.WriteB(byte(r.Code))
	w.WriteVarBytes(r.Result)
}

func (r *OracleResponse) toJSONMap(m map[string]interface{}) {
	m["id"] = r.ID
	m["code"] = r.Code
	m["result"] = r.Result
}