/
state.go
157 lines (135 loc) · 4.96 KB
/
state.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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
package chain
import (
"errors"
"fmt"
"github.com/vitelabs/go-vite/common/types"
"github.com/vitelabs/go-vite/interfaces"
"github.com/vitelabs/go-vite/ledger"
"github.com/vitelabs/go-vite/vm/util"
"math/big"
)
func (c *chain) GetBalance(addr types.Address, tokenId types.TokenTypeId) (*big.Int, error) {
result, err := c.stateDB.GetBalance(addr, tokenId)
if err != nil {
cErr := errors.New(fmt.Sprintf("c.stateDB.GetBalance failed, Addr is %s, tokenId is %s. Error: %s", addr, tokenId, err))
c.log.Error(cErr.Error(), "method", "GetBalance")
return nil, cErr
}
return result, nil
}
func (c *chain) GetBalanceMap(addr types.Address) (map[types.TokenTypeId]*big.Int, error) {
result, err := c.stateDB.GetBalanceMap(addr)
if err != nil {
cErr := errors.New(fmt.Sprintf("c.stateDB.GetBalanceMap failed, Addr is %s. Error: %s,", addr, err))
c.log.Error(cErr.Error(), "method", "GetBalance")
return nil, cErr
}
return result, nil
}
// get confirmed snapshot Balance, if history is too old, failed
func (c *chain) GetConfirmedBalanceList(addrList []types.Address, tokenId types.TokenTypeId, sbHash types.Hash) (map[types.Address]*big.Int, error) {
balanceMap := make(map[types.Address]*big.Int, len(addrList))
if err := c.stateDB.GetSnapshotBalanceList(balanceMap, sbHash, addrList, tokenId); err != nil {
c.log.Error(err.Error(), "method", "GetConfirmedBalance")
return nil, err
}
return balanceMap, nil
}
// get contract code
func (c *chain) GetContractCode(contractAddress types.Address) ([]byte, error) {
code, err := c.stateDB.GetCode(contractAddress)
if err != nil {
cErr := errors.New(fmt.Sprintf("c.stateDB.GetCode failed, error is %s, Addr is %s", err, contractAddress))
c.log.Error(cErr.Error(), "method", "GetBalance")
return nil, cErr
}
return code, nil
}
func (c *chain) GetContractMeta(contractAddress types.Address) (*ledger.ContractMeta, error) {
if meta := ledger.GetBuiltinContractMeta(contractAddress); meta != nil {
return meta, nil
}
meta, err := c.stateDB.GetContractMeta(contractAddress)
if err != nil {
cErr := errors.New(fmt.Sprintf("c.stateDB.GetContractMeta failed, error is %s, Addr is %s", err, contractAddress))
c.log.Error(cErr.Error(), "method", "GetBalance")
return nil, cErr
}
return meta, nil
}
func (c *chain) GetContractMetaInSnapshot(contractAddress types.Address, snapshotHeight uint64) (*ledger.ContractMeta, error) {
if meta := ledger.GetBuiltinContractMeta(contractAddress); meta != nil {
return meta, nil
}
meta, err := c.stateDB.GetContractMeta(contractAddress)
if err != nil {
cErr := errors.New(fmt.Sprintf("c.stateDB.GetContractMeta failed, error is %s, Addr is %s", err, contractAddress))
c.log.Error(cErr.Error(), "method", "GetBalance")
return nil, cErr
}
if meta == nil {
return nil, nil
}
createBlockHash := meta.CreateBlockHash
confirmedHeight, err := c.indexDB.GetConfirmHeightByHash(&createBlockHash)
if err != nil {
return nil, err
}
if confirmedHeight <= 0 || confirmedHeight > snapshotHeight {
return nil, nil
}
return meta, nil
}
func (c *chain) GetContractList(gid types.Gid) ([]types.Address, error) {
addrList, err := c.stateDB.GetContractList(&gid)
if err != nil {
cErr := errors.New(fmt.Sprintf("c.stateDB.GetContractList failed, gid is %s. Error: %s", gid, err))
c.log.Error(cErr.Error(), "method", "GetContractList")
return nil, cErr
}
if util.IsDelegateGid(gid) {
addrList = append(addrList, types.BuiltinContracts...)
}
return addrList, nil
}
func (c *chain) GetVmLogList(logListHash *types.Hash) (ledger.VmLogList, error) {
if logListHash == nil {
return nil, nil
}
logList, err := c.stateDB.GetVmLogList(logListHash)
if err != nil {
cErr := errors.New(fmt.Sprintf("c.stateDB.GetVmLogList failed, error is %s, logListHash is %s", err, logListHash))
c.log.Error(cErr.Error(), "method", "GetVmLogList")
return nil, cErr
}
return logList, nil
}
func (c *chain) GetQuotaUnused(address types.Address) (uint64, error) {
_, quotaInfo, err := c.GetStakeQuota(address)
if err != nil {
cErr := errors.New(fmt.Sprintf("c.GetStakeQuota failed, address is %s. Error: %s", address, err))
c.log.Error(cErr.Error(), "method", "GetQuotaUnused")
return 0, cErr
}
return quotaInfo.Current(), nil
}
func (c *chain) GetGlobalQuota() types.QuotaInfo {
return c.cache.GetGlobalQuota()
}
func (c *chain) GetQuotaUsedList(address types.Address) []types.QuotaInfo {
//return c.cache.GetQuotaUsedList(&address)
return c.cache.GetQuotaUsedList(address)
}
func (c *chain) GetStorageIterator(address types.Address, prefix []byte) (interfaces.StorageIterator, error) {
ss := c.stateDB.NewStorageIterator(address, prefix)
return ss, nil
}
func (c *chain) GetValue(address types.Address, key []byte) ([]byte, error) {
value, err := c.stateDB.GetStorageValue(&address, key)
if err != nil {
cErr := errors.New(fmt.Sprintf("c.stateDB.GetStorageValue failed, address is %s. key is %s", address, key))
c.log.Error(cErr.Error(), "method", "GetStorageValue")
return nil, cErr
}
return value, err
}