forked from hyperledger-archives/burrow
-
Notifications
You must be signed in to change notification settings - Fork 0
/
names.go
112 lines (89 loc) · 2.5 KB
/
names.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
// 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 (
"fmt"
"github.com/hyperledger/burrow/event/query"
"github.com/tendermint/go-amino"
)
var MinNameRegistrationPeriod uint64 = 5
const (
// NOTE: base costs and validity checks are here so clients
// can use them without importing state
// cost for storing a name for a block is
// CostPerBlock*CostPerByte*(len(data) + 32)
NameByteCostMultiplier uint64 = 1
NameBlockCostMultiplier uint64 = 1
MaxNameLength = 64
MaxDataLength = 1 << 16
)
var cdc = amino.NewCodec()
func (e *Entry) Encode() ([]byte, error) {
return cdc.MarshalBinary(e)
}
func (e *Entry) String() string {
return fmt.Sprintf("NameEntry{%v -> %v; Expires: %v, Owner: %v}", e.Name, e.Data, e.Expires, e.Owner)
}
type TaggedEntry struct {
*Entry
query.Tagged
}
func (e *Entry) Tagged() *TaggedEntry {
return &TaggedEntry{
Entry: e,
Tagged: query.MustReflectTags(e),
}
}
func DecodeEntry(entryBytes []byte) (*Entry, error) {
entry := new(Entry)
err := cdc.UnmarshalBinary(entryBytes, entry)
if err != nil {
return nil, err
}
return entry, nil
}
type Reader interface {
GetName(name string) (*Entry, error)
}
type Writer interface {
// Updates the name entry creating it if it does not exist
UpdateName(entry *Entry) error
// Remove the name entry
RemoveName(name string) error
}
type ReaderWriter interface {
Reader
Writer
}
type Iterable interface {
IterateNames(consumer func(*Entry) (stop bool)) (stopped bool, err error)
}
type IterableReader interface {
Iterable
Reader
}
type IterableReaderWriter interface {
Iterable
ReaderWriter
}
// base cost is "effective" number of bytes
func NameBaseCost(name, data string) uint64 {
return uint64(len(data) + 32)
}
func NameCostPerBlock(baseCost uint64) uint64 {
return NameBlockCostMultiplier * NameByteCostMultiplier * baseCost
}
func NameCostForExpiryIn(name, data string, expiresIn uint64) uint64 {
return NameCostPerBlock(NameBaseCost(name, data)) * expiresIn
}