From cac5416216889dd47a3f73483d0520ad0259f236 Mon Sep 17 00:00:00 2001
From: Silas Davis <silas@monax.io>
Date: Tue, 12 Jun 2018 15:59:39 +0100
Subject: [PATCH] Rename NameReg and make more canonical
Signed-off-by: Silas Davis <silas@monax.io>
---
execution/execution.go | 4 +-
execution/execution_test.go | 20 ++++----
execution/executors/call.go | 6 +--
execution/executors/name.go | 12 ++---
.../names/{namereg_cache.go => cache.go} | 48 ++++++++---------
.../{namereg_cache_test.go => cache_test.go} | 0
execution/names/namereg.go | 51 -------------------
execution/names/names.go | 36 +++++++++++++
execution/state.go | 18 +++----
rpc/filters/namereg.go | 8 +--
rpc/result.go | 4 +-
rpc/service.go | 12 ++---
rpc/tm/client/client.go | 2 +-
rpc/tm/integration/shared.go | 2 +-
rpc/tm/methods.go | 2 +-
rpc/v0/methods.go | 2 +-
16 files changed, 106 insertions(+), 121 deletions(-)
rename execution/names/{namereg_cache.go => cache.go} (66%)
rename execution/names/{namereg_cache_test.go => cache_test.go} (100%)
delete mode 100644 execution/names/namereg.go
diff --git a/execution/execution.go b/execution/execution.go
index 56d69d3b..74e6ce5f 100644
--- a/execution/execution.go
+++ b/execution/execution.go
@@ -61,7 +61,7 @@ type executor struct {
runCall bool
state *State
stateCache state.Cache
- nameRegCache *names.NameRegCache
+ nameRegCache *names.Cache
eventCache *event.Cache
logger *logging.Logger
vmOptions []func(*evm.VM)
@@ -93,7 +93,7 @@ func newExecutor(name string, runCall bool, backend *State, tip *bcm.Tip, publis
state: backend,
stateCache: state.NewCache(backend, state.Name(name)),
eventCache: event.NewEventCache(publisher),
- nameRegCache: names.NewNameRegCache(backend),
+ nameRegCache: names.NewCache(backend),
logger: logger.With(structure.ComponentKey, "Executor"),
}
for _, option := range options {
diff --git a/execution/execution_test.go b/execution/execution_test.go
index d506f48e..93fb03b4 100644
--- a/execution/execution_test.go
+++ b/execution/execution_test.go
@@ -976,7 +976,7 @@ func TestNameTxs(t *testing.T) {
}
}
- validateEntry := func(t *testing.T, entry *names.NameRegEntry, name, data string, addr crypto.Address, expires uint64) {
+ validateEntry := func(t *testing.T, entry *names.Entry, name, data string, addr crypto.Address, expires uint64) {
if entry == nil {
t.Fatalf("Could not find name %s", name)
@@ -1005,7 +1005,7 @@ func TestNameTxs(t *testing.T) {
if err := execTxWithState(state, txEnv); err != nil {
t.Fatal(err)
}
- entry, err := state.GetNameRegEntry(name)
+ entry, err := state.GetNameEntry(name)
require.NoError(t, err)
validateEntry(t, entry, name, data, testPrivAccounts[0].Address(), startingBlock+numDesiredBlocks)
@@ -1025,7 +1025,7 @@ func TestNameTxs(t *testing.T) {
if err := execTxWithStateNewBlock(state, blockchain, txEnv); err != nil {
t.Fatal(err)
}
- entry, err = state.GetNameRegEntry(name)
+ entry, err = state.GetNameEntry(name)
require.NoError(t, err)
validateEntry(t, entry, name, data, testPrivAccounts[0].Address(), startingBlock+numDesiredBlocks*2)
@@ -1036,7 +1036,7 @@ func TestNameTxs(t *testing.T) {
if err := execTxWithStateNewBlock(state, blockchain, txEnv); err != nil {
t.Fatal(err)
}
- entry, err = state.GetNameRegEntry(name)
+ entry, err = state.GetNameEntry(name)
require.NoError(t, err)
validateEntry(t, entry, name, data, testPrivAccounts[0].Address(), startingBlock+numDesiredBlocks*3)
@@ -1060,7 +1060,7 @@ func TestNameTxs(t *testing.T) {
if err := execTxWithStateAndBlockchain(state, blockchain.Tip, txEnv); err != nil {
t.Fatal(err)
}
- entry, err = state.GetNameRegEntry(name)
+ entry, err = state.GetNameEntry(name)
require.NoError(t, err)
validateEntry(t, entry, name, data, testPrivAccounts[1].Address(), blockchain.LastBlockHeight()+numDesiredBlocks)
@@ -1075,7 +1075,7 @@ func TestNameTxs(t *testing.T) {
if err := execTxWithStateAndBlockchain(state, blockchain.Tip, txEnv); err != nil {
t.Fatal(err)
}
- entry, err = state.GetNameRegEntry(name)
+ entry, err = state.GetNameEntry(name)
require.NoError(t, err)
validateEntry(t, entry, name, data, testPrivAccounts[1].Address(), blockchain.LastBlockHeight()+numDesiredBlocks)
@@ -1088,7 +1088,7 @@ func TestNameTxs(t *testing.T) {
if err := execTxWithStateNewBlock(state, blockchain, txEnv); err != nil {
t.Fatal(err)
}
- entry, err = state.GetNameRegEntry(name)
+ entry, err = state.GetNameEntry(name)
require.NoError(t, err)
if entry != nil {
t.Fatal("Expected removed entry to be nil")
@@ -1105,7 +1105,7 @@ func TestNameTxs(t *testing.T) {
if err := execTxWithStateAndBlockchain(state, blockchain.Tip, txEnv); err != nil {
t.Fatal(err)
}
- entry, err = state.GetNameRegEntry(name)
+ entry, err = state.GetNameEntry(name)
require.NoError(t, err)
validateEntry(t, entry, name, data, testPrivAccounts[0].Address(), blockchain.LastBlockHeight()+numDesiredBlocks)
// Fast forward
@@ -1121,7 +1121,7 @@ func TestNameTxs(t *testing.T) {
if err := execTxWithStateNewBlock(state, blockchain, txEnv); err != nil {
t.Fatal(err)
}
- entry, err = state.GetNameRegEntry(name)
+ entry, err = state.GetNameEntry(name)
require.NoError(t, err)
if entry != nil {
t.Fatal("Expected removed entry to be nil")
@@ -1465,7 +1465,7 @@ proof-of-work chain as proof of what happened while they were gone `
t.Errorf("Unexpected newAcc0 balance. Expected %v, got %v",
acc0.Balance()-entryAmount, newAcc0.Balance())
}
- entry, err := stateNameTx.GetNameRegEntry(entryName)
+ entry, err := stateNameTx.GetNameEntry(entryName)
require.NoError(t, err)
if entry == nil {
t.Errorf("Expected an entry but got nil")
diff --git a/execution/executors/call.go b/execution/executors/call.go
index caf19a5b..f377e914 100644
--- a/execution/executors/call.go
+++ b/execution/executors/call.go
@@ -234,13 +234,13 @@ func (ctx *CallContext) Deliver(inAcc, outAcc acm.Account, value uint64) error {
return nil
}
-func (ctx *CallContext) FireCallEvents(ret []byte, exception errors.CodedError) {
+func (ctx *CallContext) FireCallEvents(ret []byte, err error) {
// Fire Events for sender and receiver
// a separate event will be fired from vm for each additional call
if ctx.EventPublisher != nil {
- events.PublishAccountInput(ctx.EventPublisher, ctx.tx.Input.Address, ctx.txEnv.Tx, ret, errors.AsCodedError(exception))
+ events.PublishAccountInput(ctx.EventPublisher, ctx.tx.Input.Address, ctx.txEnv.Tx, ret, errors.AsCodedError(err))
if ctx.tx.Address != nil {
- events.PublishAccountOutput(ctx.EventPublisher, *ctx.tx.Address, ctx.txEnv.Tx, ret, errors.AsCodedError(exception))
+ events.PublishAccountOutput(ctx.EventPublisher, *ctx.tx.Address, ctx.txEnv.Tx, ret, errors.AsCodedError(err))
}
}
}
diff --git a/execution/executors/name.go b/execution/executors/name.go
index da825636..dbd2978a 100644
--- a/execution/executors/name.go
+++ b/execution/executors/name.go
@@ -18,7 +18,7 @@ type NameContext struct {
Tip blockchain.TipInfo
StateWriter state.Writer
EventPublisher event.Publisher
- NameReg names.NameRegWriter
+ NameReg names.Writer
Logger *logging.Logger
tx *payload.NameTx
}
@@ -74,7 +74,7 @@ func (ctx *NameContext) Execute(txEnv *txs.Envelope) error {
"last_block_height", lastBlockHeight)
// check if the name exists
- entry, err := ctx.NameReg.GetNameRegEntry(ctx.tx.Name)
+ entry, err := ctx.NameReg.GetNameEntry(ctx.tx.Name)
if err != nil {
return err
}
@@ -99,7 +99,7 @@ func (ctx *NameContext) Execute(txEnv *txs.Envelope) error {
// (owners if not expired, anyone if expired)
ctx.Logger.TraceMsg("Removing NameReg entry (no value and empty data in tx requests this)",
"name", entry.Name)
- err := ctx.NameReg.RemoveNameRegEntry(entry.Name)
+ err := ctx.NameReg.RemoveNameEntry(entry.Name)
if err != nil {
return err
}
@@ -134,7 +134,7 @@ func (ctx *NameContext) Execute(txEnv *txs.Envelope) error {
"credit", credit)
}
entry.Data = ctx.tx.Data
- err := ctx.NameReg.UpdateNameRegEntry(entry)
+ err := ctx.NameReg.UpdateNameEntry(entry)
if err != nil {
return err
}
@@ -144,7 +144,7 @@ func (ctx *NameContext) Execute(txEnv *txs.Envelope) error {
return fmt.Errorf("Names must be registered for at least %d blocks", names.MinNameRegistrationPeriod)
}
// entry does not exist, so create it
- entry = &names.NameRegEntry{
+ entry = &names.Entry{
Name: ctx.tx.Name,
Owner: ctx.tx.Input.Address,
Data: ctx.tx.Data,
@@ -153,7 +153,7 @@ func (ctx *NameContext) Execute(txEnv *txs.Envelope) error {
ctx.Logger.TraceMsg("Creating NameReg entry",
"name", entry.Name,
"expires_in", expiresIn)
- err := ctx.NameReg.UpdateNameRegEntry(entry)
+ err := ctx.NameReg.UpdateNameEntry(entry)
if err != nil {
return err
}
diff --git a/execution/names/namereg_cache.go b/execution/names/cache.go
similarity index 66%
rename from execution/names/namereg_cache.go
rename to execution/names/cache.go
index d21c110b..074ff290 100644
--- a/execution/names/namereg_cache.go
+++ b/execution/names/cache.go
@@ -20,33 +20,33 @@ import (
"sync"
)
-// The NameRegCache helps prevent unnecessary IAVLTree updates and garbage generation.
-type NameRegCache struct {
+// The Cache helps prevent unnecessary IAVLTree updates and garbage generation.
+type Cache struct {
sync.RWMutex
- backend NameRegGetter
+ backend Getter
names map[string]*nameInfo
}
type nameInfo struct {
sync.RWMutex
- entry *NameRegEntry
+ entry *Entry
removed bool
updated bool
}
-var _ NameRegWriter = &NameRegCache{}
+var _ Writer = &Cache{}
-// Returns a NameRegCache that wraps an underlying NameRegCacheGetter to use on a cache miss, can write to an
-// output NameRegWriter via Sync.
+// Returns a Cache that wraps an underlying NameRegCacheGetter to use on a cache miss, can write to an
+// output Writer via Sync.
// Not goroutine safe, use syncStateCache if you need concurrent access
-func NewNameRegCache(backend NameRegGetter) *NameRegCache {
- return &NameRegCache{
+func NewCache(backend Getter) *Cache {
+ return &Cache{
backend: backend,
names: make(map[string]*nameInfo),
}
}
-func (cache *NameRegCache) GetNameRegEntry(name string) (*NameRegEntry, error) {
+func (cache *Cache) GetNameEntry(name string) (*Entry, error) {
nameInfo, err := cache.get(name)
if err != nil {
return nil, err
@@ -59,7 +59,7 @@ func (cache *NameRegCache) GetNameRegEntry(name string) (*NameRegEntry, error) {
return nameInfo.entry, nil
}
-func (cache *NameRegCache) UpdateNameRegEntry(entry *NameRegEntry) error {
+func (cache *Cache) UpdateNameEntry(entry *Entry) error {
nameInfo, err := cache.get(entry.Name)
if err != nil {
return err
@@ -67,7 +67,7 @@ func (cache *NameRegCache) UpdateNameRegEntry(entry *NameRegEntry) error {
nameInfo.Lock()
defer nameInfo.Unlock()
if nameInfo.removed {
- return fmt.Errorf("UpdateNameRegEntry on a removed name: %s", nameInfo.entry.Name)
+ return fmt.Errorf("UpdateNameEntry on a removed name: %s", nameInfo.entry.Name)
}
nameInfo.entry = entry
@@ -75,7 +75,7 @@ func (cache *NameRegCache) UpdateNameRegEntry(entry *NameRegEntry) error {
return nil
}
-func (cache *NameRegCache) RemoveNameRegEntry(name string) error {
+func (cache *Cache) RemoveNameEntry(name string) error {
nameInfo, err := cache.get(name)
if err != nil {
return err
@@ -83,15 +83,15 @@ func (cache *NameRegCache) RemoveNameRegEntry(name string) error {
nameInfo.Lock()
defer nameInfo.Unlock()
if nameInfo.removed {
- return fmt.Errorf("RemoveNameRegEntry on removed name: %s", name)
+ return fmt.Errorf("RemoveNameEntry on removed name: %s", name)
}
nameInfo.removed = true
return nil
}
-// Writes whatever is in the cache to the output NameRegWriter state. Does not flush the cache, to do that call Reset()
+// Writes whatever is in the cache to the output Writer state. Does not flush the cache, to do that call Reset()
// after Sync or use Flusth if your wish to use the output state as your next backend
-func (cache *NameRegCache) Sync(state NameRegWriter) error {
+func (cache *Cache) Sync(state Writer) error {
cache.Lock()
defer cache.Unlock()
// Determine order for names
@@ -107,13 +107,13 @@ func (cache *NameRegCache) Sync(state NameRegWriter) error {
nameInfo := cache.names[name]
nameInfo.RLock()
if nameInfo.removed {
- err := state.RemoveNameRegEntry(name)
+ err := state.RemoveNameEntry(name)
if err != nil {
nameInfo.RUnlock()
return err
}
} else if nameInfo.updated {
- err := state.UpdateNameRegEntry(nameInfo.entry)
+ err := state.UpdateNameEntry(nameInfo.entry)
if err != nil {
nameInfo.RUnlock()
return err
@@ -125,15 +125,15 @@ func (cache *NameRegCache) Sync(state NameRegWriter) error {
}
// Resets the cache to empty initialising the backing map to the same size as the previous iteration.
-func (cache *NameRegCache) Reset(backend NameRegGetter) {
+func (cache *Cache) Reset(backend Getter) {
cache.Lock()
defer cache.Unlock()
cache.backend = backend
cache.names = make(map[string]*nameInfo)
}
-// Syncs the NameRegCache and Resets it to use NameRegWriter as the backend NameRegGetter
-func (cache *NameRegCache) Flush(state NameRegWriter) error {
+// Syncs the Cache and Resets it to use Writer as the backend Getter
+func (cache *Cache) Flush(state Writer) error {
err := cache.Sync(state)
if err != nil {
return err
@@ -142,12 +142,12 @@ func (cache *NameRegCache) Flush(state NameRegWriter) error {
return nil
}
-func (cache *NameRegCache) Backend() NameRegGetter {
+func (cache *Cache) Backend() Getter {
return cache.backend
}
// Get the cache accountInfo item creating it if necessary
-func (cache *NameRegCache) get(name string) (*nameInfo, error) {
+func (cache *Cache) get(name string) (*nameInfo, error) {
cache.RLock()
nmeInfo := cache.names[name]
cache.RUnlock()
@@ -156,7 +156,7 @@ func (cache *NameRegCache) get(name string) (*nameInfo, error) {
defer cache.Unlock()
nmeInfo = cache.names[name]
if nmeInfo == nil {
- entry, err := cache.backend.GetNameRegEntry(name)
+ entry, err := cache.backend.GetNameEntry(name)
if err != nil {
return nil, err
}
diff --git a/execution/names/namereg_cache_test.go b/execution/names/cache_test.go
similarity index 100%
rename from execution/names/namereg_cache_test.go
rename to execution/names/cache_test.go
diff --git a/execution/names/namereg.go b/execution/names/namereg.go
deleted file mode 100644
index 157fe2f4..00000000
--- a/execution/names/namereg.go
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright 2017 Monax Industries Limited
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package names
-
-import "github.com/hyperledger/burrow/crypto"
-
-// NameReg provides a global key value store based on Name, Data pairs that are subject to expiry and ownership by an
-// account.
-type NameRegEntry struct {
- // registered name for the entry
- Name string
- // address that created the entry
- Owner crypto.Address
- // data to store under this name
- Data string
- // block at which this entry expires
- Expires uint64
-}
-
-type NameRegGetter interface {
- GetNameRegEntry(name string) (*NameRegEntry, error)
-}
-
-type NameRegUpdater interface {
- // Updates the name entry creating it if it does not exist
- UpdateNameRegEntry(entry *NameRegEntry) error
- // Remove the name entry
- RemoveNameRegEntry(name string) error
-}
-
-type NameRegWriter interface {
- NameRegGetter
- NameRegUpdater
-}
-
-type NameRegIterable interface {
- NameRegGetter
- IterateNameRegEntries(consumer func(*NameRegEntry) (stop bool)) (stopped bool, err error)
-}
diff --git a/execution/names/names.go b/execution/names/names.go
index cfa656d6..586fb7b3 100644
--- a/execution/names/names.go
+++ b/execution/names/names.go
@@ -14,6 +14,8 @@
package names
+import "github.com/hyperledger/burrow/crypto"
+
var (
MinNameRegistrationPeriod uint64 = 5
@@ -29,6 +31,40 @@ var (
MaxDataLength = 1 << 16
)
+// NameReg provides a global key value store based on Name, Data pairs that are subject to expiry and ownership by an
+// account.
+type Entry struct {
+ // registered name for the entry
+ Name string
+ // address that created the entry
+ Owner crypto.Address
+ // data to store under this name
+ Data string
+ // block at which this entry expires
+ Expires uint64
+}
+
+type Getter interface {
+ GetNameEntry(name string) (*Entry, error)
+}
+
+type Updater interface {
+ // Updates the name entry creating it if it does not exist
+ UpdateNameEntry(entry *Entry) error
+ // Remove the name entry
+ RemoveNameEntry(name string) error
+}
+
+type Writer interface {
+ Getter
+ Updater
+}
+
+type Iterable interface {
+ Getter
+ IterateNameEntries(consumer func(*Entry) (stop bool)) (stopped bool, err error)
+}
+
// base cost is "effective" number of bytes
func NameBaseCost(name, data string) uint64 {
return uint64(len(data) + 32)
diff --git a/execution/state.go b/execution/state.go
index d70646fc..469b1082 100644
--- a/execution/state.go
+++ b/execution/state.go
@@ -271,9 +271,9 @@ func (s *State) IterateStorage(address crypto.Address,
//-------------------------------------
// State.nameReg
-var _ names.NameRegIterable = &State{}
+var _ names.Iterable = &State{}
-func (s *State) GetNameRegEntry(name string) (*names.NameRegEntry, error) {
+func (s *State) GetNameEntry(name string) (*names.Entry, error) {
_, valueBytes := s.tree.Get(prefixedKey(nameRegPrefix, []byte(name)))
if valueBytes == nil {
return nil, nil
@@ -282,13 +282,13 @@ func (s *State) GetNameRegEntry(name string) (*names.NameRegEntry, error) {
return DecodeNameRegEntry(valueBytes), nil
}
-func (s *State) IterateNameRegEntries(consumer func(*names.NameRegEntry) (stop bool)) (stopped bool, err error) {
+func (s *State) IterateNameEntries(consumer func(*names.Entry) (stop bool)) (stopped bool, err error) {
return s.tree.IterateRange(nameRegStart, nameRegEnd, true, func(key []byte, value []byte) (stop bool) {
return consumer(DecodeNameRegEntry(value))
}), nil
}
-func (s *State) UpdateNameRegEntry(entry *names.NameRegEntry) error {
+func (s *State) UpdateNameEntry(entry *names.Entry) error {
w := new(bytes.Buffer)
var n int
var err error
@@ -300,7 +300,7 @@ func (s *State) UpdateNameRegEntry(entry *names.NameRegEntry) error {
return nil
}
-func (s *State) RemoveNameRegEntry(name string) error {
+func (s *State) RemoveNameEntry(name string) error {
s.tree.Remove(prefixedKey(nameRegPrefix, []byte(name)))
return nil
}
@@ -315,19 +315,19 @@ func (s *State) Copy(db dbm.DB) *State {
return state
}
-func DecodeNameRegEntry(entryBytes []byte) *names.NameRegEntry {
+func DecodeNameRegEntry(entryBytes []byte) *names.Entry {
var n int
var err error
value := NameRegDecode(bytes.NewBuffer(entryBytes), &n, &err)
- return value.(*names.NameRegEntry)
+ return value.(*names.Entry)
}
func NameRegEncode(o interface{}, w io.Writer, n *int, err *error) {
- wire.WriteBinary(o.(*names.NameRegEntry), w, n, err)
+ wire.WriteBinary(o.(*names.Entry), w, n, err)
}
func NameRegDecode(r io.Reader, n *int, err *error) interface{} {
- return wire.ReadBinary(&names.NameRegEntry{}, r, names.MaxDataLength, n, err)
+ return wire.ReadBinary(&names.Entry{}, r, names.MaxDataLength, n, err)
}
func prefixedKey(prefix string, suffices ...[]byte) []byte {
diff --git a/rpc/filters/namereg.go b/rpc/filters/namereg.go
index df617a24..6d822fb1 100644
--- a/rpc/filters/namereg.go
+++ b/rpc/filters/namereg.go
@@ -82,7 +82,7 @@ func (nrnf *NameRegNameFilter) Configure(fd *FilterData) error {
}
func (nrnf *NameRegNameFilter) Match(v interface{}) bool {
- nre, ok := v.(*names.NameRegEntry)
+ nre, ok := v.(*names.Entry)
if !ok {
return false
}
@@ -121,7 +121,7 @@ func (nrof *NameRegOwnerFilter) Configure(fd *FilterData) error {
}
func (nrof *NameRegOwnerFilter) Match(v interface{}) bool {
- nre, ok := v.(*names.NameRegEntry)
+ nre, ok := v.(*names.Entry)
if !ok {
return false
}
@@ -157,7 +157,7 @@ func (nrdf *NameRegDataFilter) Configure(fd *FilterData) error {
}
func (nrdf *NameRegDataFilter) Match(v interface{}) bool {
- nre, ok := v.(*names.NameRegEntry)
+ nre, ok := v.(*names.Entry)
if !ok {
return false
}
@@ -188,7 +188,7 @@ func (nref *NameRegExpiresFilter) Configure(fd *FilterData) error {
}
func (nref *NameRegExpiresFilter) Match(v interface{}) bool {
- nre, ok := v.(*names.NameRegEntry)
+ nre, ok := v.(*names.Entry)
if !ok {
return false
}
diff --git a/rpc/result.go b/rpc/result.go
index 06a70a36..4dc921fc 100644
--- a/rpc/result.go
+++ b/rpc/result.go
@@ -162,7 +162,7 @@ type ResultPeers struct {
type ResultListNames struct {
BlockHeight uint64
- Names []*names.NameRegEntry
+ Names []*names.Entry
}
type ResultGeneratePrivateAccount struct {
@@ -206,7 +206,7 @@ type ResultListUnconfirmedTxs struct {
}
type ResultGetName struct {
- Entry *names.NameRegEntry
+ Entry *names.Entry
}
type ResultGenesis struct {
diff --git a/rpc/service.go b/rpc/service.go
index 72b40f1c..dab10524 100644
--- a/rpc/service.go
+++ b/rpc/service.go
@@ -46,7 +46,7 @@ const AccountsRingMutexCount = 100
type Service struct {
ctx context.Context
state state.Iterable
- nameReg names.NameRegIterable
+ nameReg names.Iterable
mempoolAccounts *execution.Accounts
subscribable event.Subscribable
blockchain *bcm.Blockchain
@@ -55,7 +55,7 @@ type Service struct {
logger *logging.Logger
}
-func NewService(ctx context.Context, state state.Iterable, nameReg names.NameRegIterable,
+func NewService(ctx context.Context, state state.Iterable, nameReg names.Iterable,
checker state.Reader, subscribable event.Subscribable, blockchain *bcm.Blockchain, keyClient keys.KeyClient,
transactor *execution.Transactor, nodeView *query.NodeView, logger *logging.Logger) *Service {
@@ -321,7 +321,7 @@ func (s *Service) GetAccountHumanReadable(address crypto.Address) (*ResultGetAcc
// Name registry
func (s *Service) GetName(name string) (*ResultGetName, error) {
- entry, err := s.nameReg.GetNameRegEntry(name)
+ entry, err := s.nameReg.GetNameEntry(name)
if err != nil {
return nil, err
}
@@ -331,9 +331,9 @@ func (s *Service) GetName(name string) (*ResultGetName, error) {
return &ResultGetName{Entry: entry}, nil
}
-func (s *Service) ListNames(predicate func(*names.NameRegEntry) bool) (*ResultListNames, error) {
- var nms []*names.NameRegEntry
- s.nameReg.IterateNameRegEntries(func(entry *names.NameRegEntry) (stop bool) {
+func (s *Service) ListNames(predicate func(*names.Entry) bool) (*ResultListNames, error) {
+ var nms []*names.Entry
+ s.nameReg.IterateNameEntries(func(entry *names.Entry) (stop bool) {
if predicate(entry) {
nms = append(nms, entry)
}
diff --git a/rpc/tm/client/client.go b/rpc/tm/client/client.go
index 0083da72..1b03a76e 100644
--- a/rpc/tm/client/client.go
+++ b/rpc/tm/client/client.go
@@ -125,7 +125,7 @@ func Call(client RPCClient, fromAddress, toAddress crypto.Address, data []byte)
return res, nil
}
-func GetName(client RPCClient, name string) (*names.NameRegEntry, error) {
+func GetName(client RPCClient, name string) (*names.Entry, error) {
res := new(rpc.ResultGetName)
_, err := client.Call(tm.GetName, pmap("name", name), res)
if err != nil {
diff --git a/rpc/tm/integration/shared.go b/rpc/tm/integration/shared.go
index 2263a193..d01322d0 100644
--- a/rpc/tm/integration/shared.go
+++ b/rpc/tm/integration/shared.go
@@ -173,7 +173,7 @@ func callContract(t *testing.T, client tmClient.RPCClient, fromAddress, toAddres
}
// get the namereg entry
-func getNameRegEntry(t *testing.T, client tmClient.RPCClient, name string) *names.NameRegEntry {
+func getNameRegEntry(t *testing.T, client tmClient.RPCClient, name string) *names.Entry {
entry, err := tmClient.GetName(client, name)
if err != nil {
t.Fatal(err)
diff --git a/rpc/tm/methods.go b/rpc/tm/methods.go
index 6c815b38..47883f6d 100644
--- a/rpc/tm/methods.go
+++ b/rpc/tm/methods.go
@@ -168,7 +168,7 @@ func GetRoutes(service *rpc.Service, logger *logging.Logger) map[string]*server.
// Names
GetName: server.NewRPCFunc(service.GetName, "name"),
ListNames: server.NewRPCFunc(func() (*rpc.ResultListNames, error) {
- return service.ListNames(func(*names.NameRegEntry) bool {
+ return service.ListNames(func(*names.Entry) bool {
return true
})
}, ""),
diff --git a/rpc/v0/methods.go b/rpc/v0/methods.go
index a0ffe912..e391f533 100644
--- a/rpc/v0/methods.go
+++ b/rpc/v0/methods.go
@@ -348,7 +348,7 @@ func GetMethods(codec rpc.Codec, service *rpc.Service, logger *logging.Logger) m
if err != nil {
return nil, rpc.INVALID_PARAMS, err
}
- list, err := service.ListNames(func(entry *names.NameRegEntry) bool {
+ list, err := service.ListNames(func(entry *names.Entry) bool {
return filter.Match(entry)
})
if err != nil {
--
GitLab