Skip to content Search Apps Documentation Source Content Run Reset Eval Playground File Folder Download Copy Actions State String Boolean Number Struct Map Slice Pointer Function Closure Reference Nil Package Type Interface Unknown

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}