forked from TrueCloudLab/neoneo-go
750 lines
20 KiB
Go
750 lines
20 KiB
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
|
|
}
|