neo-go/pkg/core/native/name_service.go

package native

import (
	"encoding/binary"
	"errors"
	"math"
	"math/big"
	"net"
	"regexp"
	"sort"
	"strings"
	"unicode/utf8"

	"github.com/nspcc-dev/neo-go/pkg/core/dao"
	"github.com/nspcc-dev/neo-go/pkg/core/interop"
	"github.com/nspcc-dev/neo-go/pkg/core/interop/runtime"
	"github.com/nspcc-dev/neo-go/pkg/core/native/nativenames"
	"github.com/nspcc-dev/neo-go/pkg/core/state"
	"github.com/nspcc-dev/neo-go/pkg/crypto/hash"
	"github.com/nspcc-dev/neo-go/pkg/encoding/bigint"
	"github.com/nspcc-dev/neo-go/pkg/io"
	"github.com/nspcc-dev/neo-go/pkg/smartcontract"
	"github.com/nspcc-dev/neo-go/pkg/smartcontract/callflag"
	"github.com/nspcc-dev/neo-go/pkg/smartcontract/manifest"
	"github.com/nspcc-dev/neo-go/pkg/util"
	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
)

// NameService represents native NameService contract.
type NameService struct {
	nonfungible
	NEO *NEO
}

type nameState struct {
	state.NFTTokenState
	// Expiration is token expiration height.
	Expiration uint32
	// HasAdmin is true if token has admin.
	HasAdmin bool
	// Admin is token admin.
	Admin util.Uint160
}

// RecordType represents name record type.
type RecordType byte

// Pre-defined record types.
const (
	RecordTypeA     RecordType = 1
	RecordTypeCNAME RecordType = 5
	RecordTypeTXT   RecordType = 16
	RecordTypeAAAA  RecordType = 28
)

const (
	nameServiceID = -8

	prefixRoots       = 10
	prefixDomainPrice = 22
	prefixExpiration  = 20
	prefixRecord      = 12

	secondsInYear = 365 * 24 * 3600

	// DefaultDomainPrice is the default price of register method.
	DefaultDomainPrice = 10_00000000
	// MinDomainNameLength is minimum domain length.
	MinDomainNameLength = 3
	// MaxDomainNameLength is maximum domain length.
	MaxDomainNameLength = 255
)

var (
	// Lookahead is not supported by Go, but it is simple `(?=.{3,255}$)`,
	// so we check name length explicitly.
	nameRegex = regexp.MustCompile("^([a-z0-9]{1,62}\\.)+[a-z][a-z0-9]{0,15}$")
	ipv4Regex = regexp.MustCompile("^(2(5[0-5]|[0-4]\\d))|1?\\d{1,2}(\\.((2(5[0-5]|[0-4]\\d))|1?\\d{1,2})){3}$")
	ipv6Regex = regexp.MustCompile("^([a-f0-9A-F]{1,4}:){7}[a-f0-9A-F]{1,4}$")
	rootRegex = regexp.MustCompile("^[a-z][a-z0-9]{0,15}$")
)

// matchName checks if provided name is valid.
func matchName(name string) bool {
	ln := len(name)
	return MinDomainNameLength <= ln && ln <= MaxDomainNameLength &&
		nameRegex.Match([]byte(name))
}

func newNameService() *NameService {
	nf := newNonFungible(nativenames.NameService, nameServiceID, "NNS", 0)
	nf.getTokenKey = func(tokenID []byte) []byte {
		return append([]byte{prefixNFTToken}, hash.Hash160(tokenID).BytesBE()...)
	}
	nf.newTokenState = func() nftTokenState {
		return new(nameState)
	}
	nf.onTransferred = func(tok nftTokenState) {
		tok.(*nameState).HasAdmin = false
	}

	n := &NameService{nonfungible: *nf}

	desc := newDescriptor("addRoot", smartcontract.VoidType,
		manifest.NewParameter("root", smartcontract.StringType))
	md := newMethodAndPrice(n.addRoot, 3000000, callflag.WriteStates)
	n.AddMethod(md, desc)

	desc = newDescriptor("setPrice", smartcontract.VoidType,
		manifest.NewParameter("price", smartcontract.IntegerType))
	md = newMethodAndPrice(n.setPrice, 3000000, callflag.WriteStates)
	n.AddMethod(md, desc)

	desc = newDescriptor("getPrice", smartcontract.IntegerType)
	md = newMethodAndPrice(n.getPrice, 1000000, callflag.ReadStates)
	n.AddMethod(md, desc)

	desc = newDescriptor("isAvailable", smartcontract.BoolType,
		manifest.NewParameter("name", smartcontract.StringType))
	md = newMethodAndPrice(n.isAvailable, 1000000, callflag.ReadStates)
	n.AddMethod(md, desc)

	desc = newDescriptor("register", smartcontract.BoolType,
		manifest.NewParameter("name", smartcontract.StringType),
		manifest.NewParameter("owner", smartcontract.Hash160Type))
	md = newMethodAndPrice(n.register, 1000000, callflag.WriteStates)
	n.AddMethod(md, desc)

	desc = newDescriptor("renew", smartcontract.IntegerType,
		manifest.NewParameter("name", smartcontract.StringType))
	md = newMethodAndPrice(n.renew, 0, callflag.WriteStates)
	n.AddMethod(md, desc)

	desc = newDescriptor("setAdmin", smartcontract.VoidType,
		manifest.NewParameter("name", smartcontract.StringType),
		manifest.NewParameter("admin", smartcontract.Hash160Type))
	md = newMethodAndPrice(n.setAdmin, 3000000, callflag.WriteStates)
	n.AddMethod(md, desc)

	desc = newDescriptor("setRecord", smartcontract.VoidType,
		manifest.NewParameter("name", smartcontract.StringType),
		manifest.NewParameter("type", smartcontract.IntegerType),
		manifest.NewParameter("data", smartcontract.StringType))
	md = newMethodAndPrice(n.setRecord, 30000000, callflag.WriteStates)
	n.AddMethod(md, desc)

	desc = newDescriptor("getRecord", smartcontract.StringType,
		manifest.NewParameter("name", smartcontract.StringType),
		manifest.NewParameter("type", smartcontract.IntegerType))
	md = newMethodAndPrice(n.getRecord, 1000000, callflag.ReadStates)
	n.AddMethod(md, desc)

	desc = newDescriptor("deleteRecord", smartcontract.VoidType,
		manifest.NewParameter("name", smartcontract.StringType),
		manifest.NewParameter("type", smartcontract.IntegerType))
	md = newMethodAndPrice(n.deleteRecord, 1000000, callflag.WriteStates)
	n.AddMethod(md, desc)

	desc = newDescriptor("resolve", smartcontract.StringType,
		manifest.NewParameter("name", smartcontract.StringType),
		manifest.NewParameter("type", smartcontract.IntegerType))
	md = newMethodAndPrice(n.resolve, 3000000, callflag.ReadStates)
	n.AddMethod(md, desc)

	return n
}

// Metadata implements interop.Contract interface.
func (n *NameService) Metadata() *interop.ContractMD {
	return &n.ContractMD
}

// Initialize implements interop.Contract interface.
func (n *NameService) Initialize(ic *interop.Context) error {
	if err := n.nonfungible.Initialize(ic); err != nil {
		return err
	}
	if err := setIntWithKey(n.ID, ic.DAO, []byte{prefixDomainPrice}, DefaultDomainPrice); err != nil {
		return err
	}
	roots := stringList{}
	return putSerializableToDAO(n.ID, ic.DAO, []byte{prefixRoots}, &roots)
}

// OnPersist implements interop.Contract interface.
func (n *NameService) OnPersist(ic *interop.Context) error {
	now := uint32(ic.Block.Timestamp/1000 + 1)
	keys := []string{}
	ic.DAO.Seek(n.ID, []byte{prefixExpiration}, func(k, v []byte) {
		if binary.BigEndian.Uint32(k) >= now {
			return
		}
		// Removal is done separately because of `Seek` takes storage mutex.
		keys = append(keys, string(k))
	})

	var keysToRemove [][]byte
	key := []byte{prefixExpiration}
	keyRecord := []byte{prefixRecord}
	for i := range keys {
		key[0] = prefixExpiration
		key = append(key[:1], []byte(keys[i])...)
		if err := ic.DAO.DeleteStorageItem(n.ID, key); err != nil {
			return err
		}

		keysToRemove = keysToRemove[:0]
		key[0] = prefixRecord
		key = append(key[:1], keys[i][4:]...)
		ic.DAO.Seek(n.ID, key, func(k, v []byte) {
			keysToRemove = append(keysToRemove, k)
		})
		for i := range keysToRemove {
			keyRecord = append(keyRecord[:0], key...)
			keyRecord = append(keyRecord, keysToRemove[i]...)
			err := ic.DAO.DeleteStorageItem(n.ID, keyRecord)
			if err != nil {
				return err
			}
		}

		key[0] = prefixNFTToken
		n.burnByKey(ic, key)
	}
	return nil
}

// PostPersist implements interop.Contract interface.
func (n *NameService) PostPersist(ic *interop.Context) error {
	return nil
}

func (n *NameService) addRoot(ic *interop.Context, args []stackitem.Item) stackitem.Item {
	root := toString(args[0])
	if !rootRegex.Match([]byte(root)) {
		panic("invalid root")
	}

	n.checkCommittee(ic)
	roots, _ := n.getRootsInternal(ic.DAO)
	if !roots.add(root) {
		panic("name already exists")
	}

	err := putSerializableToDAO(n.ID, ic.DAO, []byte{prefixRoots}, &roots)
	if err != nil {
		panic(err)
	}
	return stackitem.Null{}
}

var maxPrice = big.NewInt(10000_00000000)

func (n *NameService) setPrice(ic *interop.Context, args []stackitem.Item) stackitem.Item {
	price := toBigInt(args[0])
	if price.Sign() <= 0 || price.Cmp(maxPrice) >= 0 {
		panic("invalid price")
	}

	n.checkCommittee(ic)
	si := &state.StorageItem{Value: bigint.ToBytes(price)}
	err := ic.DAO.PutStorageItem(n.ID, []byte{prefixDomainPrice}, si)
	if err != nil {
		panic(err)
	}
	return stackitem.Null{}
}

func (n *NameService) getPrice(ic *interop.Context, _ []stackitem.Item) stackitem.Item {
	return stackitem.NewBigInteger(n.getPriceInternal(ic.DAO))
}

func (n *NameService) getPriceInternal(d dao.DAO) *big.Int {
	si := d.GetStorageItem(n.ID, []byte{prefixDomainPrice})
	return bigint.FromBytes(si.Value)
}

func (n *NameService) parseName(item stackitem.Item) (string, []string, []byte) {
	name := toName(item)
	names := strings.Split(name, ".")
	if len(names) != 2 {
		panic("invalid name")
	}
	return name, names, n.getTokenKey([]byte(name))
}

func (n *NameService) isAvailable(ic *interop.Context, args []stackitem.Item) stackitem.Item {
	_, names, key := n.parseName(args[0])
	if ic.DAO.GetStorageItem(n.ID, key) != nil {
		return stackitem.NewBool(false)
	}

	roots, _ := n.getRootsInternal(ic.DAO)
	_, ok := roots.index(names[1])
	if !ok {
		panic("domain is not registered")
	}
	return stackitem.NewBool(true)
}

func (n *NameService) getRootsInternal(d dao.DAO) (stringList, bool) {
	var sl stringList
	err := getSerializableFromDAO(n.ID, d, []byte{prefixRoots}, &sl)
	if err != nil {
		// Roots are being stored in `Initialize()` and thus must always be present.
		panic(err)
	}
	return sl, true
}

func (n *NameService) register(ic *interop.Context, args []stackitem.Item) stackitem.Item {
	name, names, key := n.parseName(args[0])
	owner := toUint160(args[1])
	if !n.checkWitness(ic, owner) {
		panic("owner is not witnessed")
	}

	if ic.DAO.GetStorageItem(n.ID, key) != nil {
		return stackitem.NewBool(false)
	}

	roots, _ := n.getRootsInternal(ic.DAO)
	if _, ok := roots.index(names[1]); !ok {
		panic("missing root")
	}
	if !ic.VM.AddGas(n.getPriceInternal(ic.DAO).Int64()) {
		panic("insufficient gas")
	}
	token := &nameState{
		NFTTokenState: state.NFTTokenState{
			Owner: owner,
			Name:  name,
		},
		Expiration: uint32(ic.Block.Timestamp/1000 + secondsInYear),
	}
	n.mint(ic, token)
	err := ic.DAO.PutStorageItem(n.ID,
		makeExpirationKey(token.Expiration, token.ID()),
		&state.StorageItem{Value: []byte{0}})
	if err != nil {
		panic(err)
	}
	return stackitem.NewBool(true)
}

func (n *NameService) renew(ic *interop.Context, args []stackitem.Item) stackitem.Item {
	_, _, key := n.parseName(args[0])
	if !ic.VM.AddGas(n.getPriceInternal(ic.DAO).Int64()) {
		panic("insufficient gas")
	}
	token := new(nameState)
	err := getSerializableFromDAO(n.ID, ic.DAO, key, token)
	if err != nil {
		panic(err)
	}

	keyExpiration := makeExpirationKey(token.Expiration, token.ID())
	if err := ic.DAO.DeleteStorageItem(n.ID, keyExpiration); err != nil {
		panic(err)
	}

	token.Expiration += secondsInYear
	err = putSerializableToDAO(n.ID, ic.DAO, key, token)
	if err != nil {
		panic(err)
	}

	binary.BigEndian.PutUint32(key[1:], token.Expiration)
	si := &state.StorageItem{Value: []byte{0}}
	err = ic.DAO.PutStorageItem(n.ID, key, si)
	if err != nil {
		panic(err)
	}
	bi := new(big.Int).SetUint64(uint64(token.Expiration))
	return stackitem.NewBigInteger(bi)
}

func (n *NameService) setAdmin(ic *interop.Context, args []stackitem.Item) stackitem.Item {
	_, _, key := n.parseName(args[0])

	var admin util.Uint160
	_, isNull := args[1].(stackitem.Null)
	if !isNull {
		admin = toUint160(args[1])
		if !n.checkWitness(ic, admin) {
			panic("not witnessed by admin")
		}
	}

	token := new(nameState)
	err := getSerializableFromDAO(n.ID, ic.DAO, key, token)
	if err != nil {
		panic(err)
	}
	if !n.checkWitness(ic, token.Owner) {
		panic("only owner can set admin")
	}
	token.HasAdmin = !isNull
	token.Admin = admin
	err = putSerializableToDAO(n.ID, ic.DAO, key, token)
	if err != nil {
		panic(err)
	}
	return stackitem.Null{}
}

func (n *NameService) checkWitness(ic *interop.Context, owner util.Uint160) bool {
	ok, err := runtime.CheckHashedWitness(ic, owner)
	if err != nil {
		panic(err)
	}
	return ok
}

func (n *NameService) checkCommittee(ic *interop.Context) {
	if !n.NEO.checkCommittee(ic) {
		panic("not witnessed by committee")
	}
}

func (n *NameService) checkAdmin(ic *interop.Context, token *nameState) bool {
	if n.checkWitness(ic, token.Owner) {
		return true
	}
	return token.HasAdmin && n.checkWitness(ic, token.Admin)
}

func (n *NameService) setRecord(ic *interop.Context, args []stackitem.Item) stackitem.Item {
	name := toName(args[0])
	rt := toRecordType(args[1])
	data := toString(args[2])
	n.checkName(rt, data)

	domain := toDomain(name)
	token, _, err := n.tokenState(ic.DAO, []byte(domain))
	if err != nil {
		panic(err)
	}
	if !n.checkAdmin(ic, token.(*nameState)) {
		panic("not witnessed by admin")
	}
	key := makeRecordKey(domain, name, rt)
	si := &state.StorageItem{Value: []byte(data)}
	if err := ic.DAO.PutStorageItem(n.ID, key, si); err != nil {
		panic(err)
	}
	return stackitem.Null{}
}

func (n *NameService) checkName(rt RecordType, name string) {
	var valid bool
	switch rt {
	case RecordTypeA:
		// We can't rely on `len(ip) == net.IPv4len` because
		// IPv4 can be parsed to mapped representation.
		valid = ipv4Regex.MatchString(name) &&
			net.ParseIP(name) != nil
	case RecordTypeCNAME:
		valid = matchName(name)
	case RecordTypeTXT:
		valid = utf8.RuneCountInString(name) <= 255
	case RecordTypeAAAA:
		valid = ipv6Regex.MatchString(name) &&
			net.ParseIP(name) != nil
	}
	if !valid {
		panic("invalid name")
	}
}

func (n *NameService) getRecord(ic *interop.Context, args []stackitem.Item) stackitem.Item {
	name := toName(args[0])
	domain := toDomain(name)
	rt := toRecordType(args[1])
	key := makeRecordKey(domain, name, rt)
	si := ic.DAO.GetStorageItem(n.ID, key)
	if si == nil {
		return stackitem.Null{}
	}
	return stackitem.NewByteArray(si.Value)
}

func (n *NameService) deleteRecord(ic *interop.Context, args []stackitem.Item) stackitem.Item {
	name := toName(args[0])
	rt := toRecordType(args[1])
	domain := toDomain(name)
	key := n.getTokenKey([]byte(domain))
	token := new(nameState)
	err := getSerializableFromDAO(n.ID, ic.DAO, key, token)
	if err != nil {
		panic(err)
	}

	if !n.checkAdmin(ic, token) {
		panic("not witnessed by admin")
	}

	key = makeRecordKey(domain, name, rt)
	if err := ic.DAO.DeleteStorageItem(n.ID, key); err != nil {
		panic(err)
	}
	return stackitem.Null{}
}

func (n *NameService) resolve(ic *interop.Context, args []stackitem.Item) stackitem.Item {
	name := toString(args[0])
	rt := toRecordType(args[1])
	result, ok := n.resolveInternal(ic, name, rt, 2)
	if !ok {
		return stackitem.Null{}
	}
	return stackitem.NewByteArray([]byte(result))
}

func (n *NameService) resolveInternal(ic *interop.Context, name string, t RecordType, redirect int) (string, bool) {
	if redirect < 0 {
		panic("invalid redirect")
	}
	records := n.getRecordsInternal(ic.DAO, name)
	if data, ok := records[t]; ok {
		return data, true
	}
	data, ok := records[RecordTypeCNAME]
	if !ok {
		return "", false
	}
	return n.resolveInternal(ic, data, t, redirect-1)
}

func (n *NameService) getRecordsInternal(d dao.DAO, name string) map[RecordType]string {
	domain := toDomain(name)
	key := makeRecordKey(domain, name, 0)
	key = key[:len(key)-1]
	res := make(map[RecordType]string)
	d.Seek(n.ID, key, func(k, v []byte) {
		rt := RecordType(k[len(k)-1])
		var si state.StorageItem
		r := io.NewBinReaderFromBuf(v)
		si.DecodeBinary(r)
		if r.Err != nil {
			panic(r.Err)
		}
		res[rt] = string(si.Value)
	})
	return res
}

func makeRecordKey(domain, name string, rt RecordType) []byte {
	key := make([]byte, 1+util.Uint160Size+util.Uint160Size+1)
	key[0] = prefixRecord
	i := 1
	i += copy(key[i:], hash.Hash160([]byte(domain)).BytesBE())
	i += copy(key[i:], hash.Hash160([]byte(name)).BytesBE())
	key[i] = byte(rt)
	return key
}

func makeExpirationKey(expiration uint32, tokenID []byte) []byte {
	key := make([]byte, 1+4+util.Uint160Size)
	key[0] = prefixExpiration
	binary.BigEndian.PutUint32(key[1:], expiration)
	copy(key[5:], hash.Hash160(tokenID).BytesBE())
	return key
}

// ToMap implements nftTokenState interface.
func (s *nameState) ToMap() *stackitem.Map {
	m := s.NFTTokenState.ToMap()
	m.Add(stackitem.NewByteArray([]byte("expiration")),
		stackitem.NewBigInteger(new(big.Int).SetUint64(uint64(s.Expiration))))
	return m
}

// EncodeBinary implements io.Serializable.
func (s *nameState) EncodeBinary(w *io.BinWriter) {
	stackitem.EncodeBinaryStackItem(s.ToStackItem(), w)
}

// DecodeBinary implements io.Serializable.
func (s *nameState) DecodeBinary(r *io.BinReader) {
	item := stackitem.DecodeBinaryStackItem(r)
	if r.Err == nil {
		s.FromStackItem(item)
	}
}

// ToStackItem implements nftTokenState interface.
func (s *nameState) ToStackItem() stackitem.Item {
	item := s.NFTTokenState.ToStackItem().(*stackitem.Struct)
	exp := new(big.Int).SetUint64(uint64(s.Expiration))
	item.Append(stackitem.NewBigInteger(exp))
	if s.HasAdmin {
		item.Append(stackitem.NewByteArray(s.Admin.BytesBE()))
	} else {
		item.Append(stackitem.Null{})
	}
	return item
}

// FromStackItem implements nftTokenState interface.
func (s *nameState) FromStackItem(item stackitem.Item) error {
	err := s.NFTTokenState.FromStackItem(item)
	if err != nil {
		return err
	}
	elems := item.Value().([]stackitem.Item)
	if len(elems) < 5 {
		return errors.New("invalid stack item")
	}
	bi, err := elems[3].TryInteger()
	if err != nil || !bi.IsUint64() {
		return errors.New("invalid stack item")
	}

	_, isNull := elems[4].(stackitem.Null)
	if !isNull {
		bs, err := elems[4].TryBytes()
		if err != nil {
			return err
		}
		u, err := util.Uint160DecodeBytesBE(bs)
		if err != nil {
			return err
		}
		s.Admin = u
	}
	s.Expiration = uint32(bi.Uint64())
	s.HasAdmin = !isNull
	return nil
}

// Helpers

func domainFromString(name string) (string, bool) {
	i := strings.LastIndexAny(name, ".")
	if i < 0 {
		return "", false
	}
	i = strings.LastIndexAny(name[:i], ".")
	if i < 0 {
		return name, true
	}
	return name[i+1:], true

}

func toDomain(name string) string {
	domain, ok := domainFromString(name)
	if !ok {
		panic("invalid record")
	}
	return domain
}

func toRecordType(item stackitem.Item) RecordType {
	bi, err := item.TryInteger()
	if err != nil || !bi.IsInt64() {
		panic("invalid record type")
	}
	val := bi.Uint64()
	if val > math.MaxUint8 {
		panic("invalid record type")
	}
	switch rt := RecordType(val); rt {
	case RecordTypeA, RecordTypeCNAME, RecordTypeTXT, RecordTypeAAAA:
		return rt
	default:
		panic("invalid record type")
	}
}

func toName(item stackitem.Item) string {
	name := toString(item)
	if !matchName(name) {
		panic("invalid name")
	}
	return name
}

type stringList []string

// ToStackItem converts sl to stack item.
func (sl stringList) ToStackItem() stackitem.Item {
	arr := make([]stackitem.Item, len(sl))
	for i := range sl {
		arr[i] = stackitem.NewByteArray([]byte(sl[i]))
	}
	return stackitem.NewArray(arr)
}

// FromStackItem converts stack item to string list.
func (sl *stringList) FromStackItem(item stackitem.Item) error {
	arr, ok := item.Value().([]stackitem.Item)
	if !ok {
		return errors.New("invalid stack item")
	}
	res := make([]string, len(arr))
	for i := range res {
		s, err := stackitem.ToString(arr[i])
		if err != nil {
			return err
		}
		res[i] = s
	}
	*sl = res
	return nil
}

// EncodeBinary implements io.Serializable.
func (sl stringList) EncodeBinary(w *io.BinWriter) {
	stackitem.EncodeBinaryStackItem(sl.ToStackItem(), w)
}

// DecodeBinary implements io.Serializable.
func (sl *stringList) DecodeBinary(r *io.BinReader) {
	item := stackitem.DecodeBinaryStackItem(r)
	if r.Err == nil {
		sl.FromStackItem(item)
	}
}

func (sl stringList) index(s string) (int, bool) {
	index := sort.Search(len(sl), func(i int) bool {
		return sl[i] >= s
	})
	return index, index < len(sl) && sl[index] == s
}

func (sl *stringList) remove(s string) bool {
	index, has := sl.index(s)
	if !has {
		return false
	}

	copy((*sl)[index:], (*sl)[index+1:])
	*sl = (*sl)[:len(*sl)-1]
	return true
}

func (sl *stringList) add(s string) bool {
	index, has := sl.index(s)
	if has {
		return false
	}

	*sl = append(*sl, "")
	copy((*sl)[index+1:], (*sl)[index:])
	(*sl)[index] = s
	return true
}