state.gno
12.30 Kb · 310 lines
1package manager
2
3import "gno.land/p/nt/ufmt/v0"
4
5type State struct {
6 Roles map[RoleId]*RoleConfig
7 Targets map[string]*TargetConfig
8}
9
10func NewState() State {
11 return State{
12 Roles: make(map[RoleId]*RoleConfig),
13 Targets: make(map[string]*TargetConfig),
14 }
15}
16
17// =================================================== GETTERS ====================================================
18
19// CanCall reports whether caller can call target selector immediately.
20// This Gno port returns only immediate authorization because scheduled
21// execution and execution delay are intentionally not ported.
22// OpenZeppelin reference:
23// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L140-L156
24func (state *State) CanCall(caller address, target string, selector Selector) CanCallResult {
25 if state.IsTargetClosed(target) {
26 return NewCanCallResult(false)
27 }
28
29 role := state.GetTargetFunctionRole(target, selector)
30
31 membership := state.HasRole(role, caller)
32 if !membership.IsMember {
33 return NewCanCallResult(false)
34 }
35
36 return NewCanCallResult(true)
37}
38
39// IsAuthorized is a boolean convenience wrapper around CanCall.
40// OpenZeppelin reference:
41// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L140-L156
42func (state *State) IsAuthorized(caller address, target string, selector Selector) bool {
43 return state.CanCall(caller, target, selector).Immediate
44}
45
46// HasRole reports whether account currently has an active role membership.
47// This Gno port returns membership only because execution delay is not ported.
48// OpenZeppelin reference:
49// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L211-L220
50func (state *State) HasRole(role RoleId, account address) HasRoleResult {
51 if role == PublicRole {
52 return NewHasRoleResult(true)
53 }
54
55 roleConfig := state.getRole(role)
56 if roleConfig == nil {
57 return NewHasRoleResult(false)
58 }
59
60 return NewHasRoleResult(roleConfig.hasMember(account, CurrentTimePoint()))
61}
62
63// GetRoleMemberSince returns when account's role membership became active,
64// or zero if it is not a member. It corresponds to OpenZeppelin's since field;
65// execution-delay fields are not ported here.
66//
67// OpenZeppelin: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L205
68func (state *State) GetRoleMemberSince(role RoleId, account address) TimePoint {
69 roleConfig := state.getRole(role)
70 if roleConfig == nil {
71 return 0
72 }
73
74 access, found := roleConfig.Members[account]
75 if !found {
76 return 0
77 }
78
79 return access.Since
80}
81
82// GetRoleAdmin returns the admin role for role, defaulting to AdminRole.
83// OpenZeppelin reference:
84// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L183-L186
85func (state *State) GetRoleAdmin(role RoleId) RoleId {
86 roleConfig := state.getRole(role)
87 if roleConfig == nil {
88 return AdminRole
89 }
90
91 return roleConfig.adminRole()
92}
93
94// GetRoleGrantDelay returns the grant delay currently in effect for role. A
95// change scheduled by SetGrantDelay is not reflected until its effect timePoint.
96// OpenZeppelin: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L194-L196
97func (state *State) GetRoleGrantDelay(role RoleId) uint32 {
98 roleConfig := state.getRole(role)
99 if roleConfig == nil {
100 return 0
101 }
102
103 return roleConfig.grantDelay(CurrentTimePoint())
104}
105
106// GetRoleGrantDelayEffect returns when role's scheduled grant delay change
107// takes effect. No OpenZeppelin equivalent; added to avoid direct field access.
108func (state *State) GetRoleGrantDelayEffect(role RoleId) TimePoint {
109 roleConfig := state.getRole(role)
110 if roleConfig == nil {
111 return 0
112 }
113
114 return roleConfig.GrantDelay.effectDate
115}
116
117// GetTargetFunctionRole returns the role required for target selector.
118// Unconfigured selectors default to AdminRole in this Gno representation.
119// OpenZeppelin reference:
120// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L173-L176
121func (state *State) GetTargetFunctionRole(target string, selector Selector) RoleId {
122 targetConfig := state.getTarget(target)
123 if targetConfig == nil {
124 return AdminRole
125 }
126
127 return targetConfig.functionRole(selector)
128}
129
130// IsTargetClosed reports whether target is closed.
131// OpenZeppelin reference:
132// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L168-L171
133func (state *State) IsTargetClosed(target string) bool {
134 targetConfig := state.getTarget(target)
135
136 return targetConfig != nil && targetConfig.isClosed()
137}
138
139// =============================================== ROLE MANAGEMENT ===============================================
140
141// GrantRole grants role membership to account and returns true for a new member.
142// This Gno port retains grant delay but intentionally omits OZ execution delay.
143// OpenZeppelin references:
144// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L233-L236
145// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L271-L298
146func (state *State) GrantRole(role RoleId, account address) bool {
147 if role == PublicRole {
148 panic(errorWithDetails(errAccessManagerLockedRole, ufmt.Sprintf("role %d is locked", role)).Error())
149 }
150
151 state.ensureRole(role)
152
153 return state.getRole(role).grant(account, CurrentTimePoint())
154}
155
156// RevokeRole revokes role membership from account and reports whether it existed.
157// OpenZeppelin references:
158// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L238-L240
159// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L300-L319
160func (state *State) RevokeRole(role RoleId, account address) bool {
161 if role == PublicRole {
162 panic(errorWithDetails(errAccessManagerLockedRole, ufmt.Sprintf("role %d is locked", role)).Error())
163 }
164
165 state.ensureRole(role)
166
167 if role == AdminRole && state.isLastAdmin(account) {
168 panic(errAccessManagerLastAdmin.Error())
169 }
170
171 return state.getRole(role).revoke(account)
172}
173
174// isLastAdmin reports whether account is the only currently active AdminRole
175// member. Prevents bricking the system by removing the final admin.
176func (state *State) isLastAdmin(account address) bool {
177 adminRole := state.getRole(AdminRole)
178 if adminRole == nil {
179 return false
180 }
181
182 now := CurrentTimePoint()
183 if !adminRole.hasMember(account, now) {
184 return false
185 }
186
187 for member, access := range adminRole.Members {
188 if member != account && access.isActiveAt(now) {
189 return false
190 }
191 }
192
193 return true
194}
195
196// RenounceRole revokes caller-confirmed role membership from account.
197// OpenZeppelin reference:
198// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L243-L249
199func (state *State) RenounceRole(role RoleId, account address, callerConfirmation address) bool {
200 if account != callerConfirmation {
201 panic(errAccessManagerBadConfirmation.Error())
202 }
203
204 return state.RevokeRole(role, account)
205}
206
207// SetRoleAdmin sets the admin role that can grant or revoke role.
208// OpenZeppelin references:
209// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L251-L254
210// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L321-L337
211func (state *State) SetRoleAdmin(role RoleId, admin RoleId) {
212 RequireUnlockedConfigRole(role)
213
214 state.ensureRole(role)
215 state.getRole(role).setAdmin(admin)
216}
217
218// SetGrantDelay schedules newDelay behind a setback; it never overwrites the
219// active delay on the spot. Callers read GetRoleGrantDelay for the current
220// value or GetRoleGrantDelayEffect for the effect timePoint.
221// AdminRole is not locked here (unlike SetRoleAdmin) — OpenZeppelin only rejects PublicRole.
222// OpenZeppelin: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L262-L264,L362-L371
223func (state *State) SetGrantDelay(role RoleId, newDelay uint32) {
224 if role == PublicRole {
225 panic(errorWithDetails(errAccessManagerLockedRole, ufmt.Sprintf("role %d is locked", role)).Error())
226 }
227
228 state.ensureRole(role)
229 state.getRole(role).setGrantDelay(CurrentTimePoint(), newDelay)
230}
231
232// ============================================= FUNCTION MANAGEMENT ==============================================
233
234// SetTargetFunctionRole sets the role required for target selector.
235// OpenZeppelin reference:
236// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L385-L393
237func (state *State) SetTargetFunctionRole(target string, selector Selector, role RoleId) {
238 state.ensureTarget(target)
239 state.getTarget(target).setFunctionRole(selector, role)
240}
241
242// SetTargetFunctionRoles sets the same role for multiple target selectors.
243// OpenZeppelin reference:
244// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L373-L383
245func (state *State) SetTargetFunctionRoles(target string, selectors []Selector, role RoleId) {
246 state.ensureTarget(target)
247 state.getTarget(target).setFunctionRoles(selectors, role)
248}
249
250// =============================================== MODE MANAGEMENT ================================================
251
252// SetTargetClosed sets whether target rejects calls regardless of selector role.
253// OpenZeppelin references:
254// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L412-L416
255// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L418-L426
256func (state *State) SetTargetClosed(target string, closed bool) {
257 state.ensureTarget(target)
258 state.getTarget(target).setClosed(closed)
259}
260
261// ================================================= ADMIN LOGIC ==================================================
262
263// CanAdminRole reports whether caller has the admin role required for role.
264// OpenZeppelin reference:
265// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L652-L657
266func (state *State) CanAdminRole(role RoleId, caller address) CanCallResult {
267 adminRole := state.GetRoleAdmin(role)
268
269 membership := state.HasRole(adminRole, caller)
270 if !membership.IsMember {
271 return NewCanCallResult(false)
272 }
273
274 return NewCanCallResult(true)
275}
276
277// CanManageTarget reports whether caller can manage target configuration.
278// OpenZeppelin references:
279// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L101-L105
280// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/5fd1781b1454fd1ef8e722282f86f9293cacf256/contracts/access/manager/AccessManager.sol#L640-L650
281func (state *State) CanManageTarget(caller address) CanCallResult {
282 membership := state.HasRole(AdminRole, caller)
283 if !membership.IsMember {
284 return NewCanCallResult(false)
285 }
286
287 return NewCanCallResult(true)
288}
289
290func (state *State) getRole(role RoleId) *RoleConfig {
291 return state.Roles[role]
292}
293
294func (state *State) getTarget(target string) *TargetConfig {
295 return state.Targets[target]
296}
297
298func (state *State) ensureRole(role RoleId) {
299 roleConfig, found := state.Roles[role]
300 if !found || roleConfig == nil {
301 state.Roles[role] = NewRoleConfig(AdminRole, 0)
302 }
303}
304
305func (state *State) ensureTarget(target string) {
306 targetConfig, found := state.Targets[target]
307 if !found || targetConfig == nil {
308 state.Targets[target] = NewTargetConfig(false)
309 }
310}