acl.gno

  1package memba_notes_v1
  2
  3import (
  4	keys "gno.land/r/samcrew/enckeys_v1"
  5	"strings"
  6)
  7
  8func writer(n *note, who address) bool {
  9	for _, a := range n.Writers {
 10		if a == who {
 11			return true
 12		}
 13	}
 14	return false
 15}
 16func canWrite(cur realm, n *note, who address) bool {
 17	if who == n.Owner {
 18		return true
 19	}
 20	if n.Mode == ModePublicOpen {
 21		return false
 22	}
 23	if writer(n, who) {
 24		return true
 25	}
 26	if encrypted(n.Mode) && !contains(n.Readers, who) {
 27		return false
 28	}
 29	if n.GovWriters && n.Owner == govAddress && govMember(who) {
 30		return true
 31	}
 32	return policyAllows(cur, n, who, OpWrite)
 33}
 34func requireWrite(cur realm, n *note, who address) {
 35	if !canWrite(cur, n, who) {
 36		panic("notes: writer required")
 37	}
 38}
 39func AddWriter(cur realm, id [16]byte, baseRevision uint64, to address, opID [16]byte) {
 40	who := enter(cur, false)
 41	defer leave()
 42	mutateAddWriter(cur, who, id, baseRevision, to, opID)
 43}
 44func mutateAddWriter(cur realm, who address, id [16]byte, baseRevision uint64, to address, opID [16]byte) {
 45	n := live(id)
 46	owner(n, who)
 47	expected(n, baseRevision)
 48	if !public(n.Mode) {
 49		panic("notes: encrypted ACL requires atomic manifest")
 50	}
 51	to = keys.CanonicalAddress(to)
 52	if to == n.Owner || writer(n, to) {
 53		panic("notes: writer already present")
 54	}
 55	if len(n.Writers) >= MaxReaders {
 56		panic("notes: too many writers")
 57	}
 58	operation(n, opID)
 59	n.Writers = append(n.Writers, to)
 60	sharedIndex.Set(string(to)+":"+indexKey(n), idText(id))
 61	bump(n, who, opID, "writer-add")
 62}
 63func RemoveWriter(cur realm, id [16]byte, baseRevision uint64, to address, opID [16]byte) {
 64	who := enter(cur, false)
 65	defer leave()
 66	mutateRemoveWriter(cur, who, id, baseRevision, to, opID)
 67}
 68func mutateRemoveWriter(cur realm, who address, id [16]byte, baseRevision uint64, to address, opID [16]byte) {
 69	n := live(id)
 70	owner(n, who)
 71	expected(n, baseRevision)
 72	if !public(n.Mode) {
 73		panic("notes: encrypted ACL requires rotation")
 74	}
 75	to = keys.CanonicalAddress(to)
 76	if !writer(n, to) {
 77		panic("notes: writer missing")
 78	}
 79	operation(n, opID)
 80	for i, a := range n.Writers {
 81		if a == to {
 82			n.Writers = append(n.Writers[:i], n.Writers[i+1:]...)
 83			break
 84		}
 85	}
 86	sharedIndex.Remove(string(to) + ":" + indexKey(n))
 87	bump(n, who, opID, "writer-remove")
 88}
 89func ProposeOwner(cur realm, id [16]byte, baseRevision uint64, to address, opID [16]byte) {
 90	who := enter(cur, false)
 91	defer leave()
 92	mutateProposeOwner(cur, who, id, baseRevision, to, opID)
 93}
 94func mutateProposeOwner(cur realm, who address, id [16]byte, baseRevision uint64, to address, opID [16]byte) {
 95	n := live(id)
 96	owner(n, who)
 97	expected(n, baseRevision)
 98	if to != "" {
 99		to = keys.CanonicalAddress(to)
100	}
101	if to == n.Owner {
102		panic("notes: already owner")
103	}
104	operation(n, opID)
105	n.PendingOwner = to
106	bump(n, who, opID, "owner-propose")
107}
108func AcceptOwnership(cur realm, id [16]byte, baseRevision uint64, opID [16]byte) {
109	who := enter(cur, false)
110	defer leave()
111	mutateAcceptOwnership(cur, who, id, baseRevision, opID)
112}
113func mutateAcceptOwnership(cur realm, who address, id [16]byte, baseRevision uint64, opID [16]byte) {
114	n := live(id)
115	expected(n, baseRevision)
116	if n.PendingOwner == "" || who != n.PendingOwner {
117		panic("notes: pending owner required")
118	}
119	isRealm := strings.HasPrefix(cur.Previous().PkgPath(), "gno.land/r/") || who == govAddress
120	if encrypted(n.Mode) && (!isRealm && !contains(n.Readers, who) || isRealm && n.Mode == ModePrivate) {
121		panic("notes: encrypted ownership requires current wrap/shared mode")
122	}
123	if n.OwnerGeneration == ^uint64(0) {
124		panic("notes: owner generation exhausted")
125	}
126	operation(n, opID)
127	unindex(n)
128	n.OwnerIsRealm = isRealm
129	resetPublicWrites(n)
130	n.Owner = who
131	n.PendingOwner = ""
132	n.OwnerGeneration++
133	n.GovWriters = false
134	if encrypted(n.Mode) {
135		preserveTransferredWriters(n)
136	}
137	index(n)
138	bump(n, who, opID, "owner-accept")
139}
140func SetListed(cur realm, id [16]byte, baseRevision uint64, listed bool, opID [16]byte) {
141	who := enter(cur, false)
142	defer leave()
143	mutateSetListed(cur, who, id, baseRevision, listed, opID)
144}
145func mutateSetListed(cur realm, who address, id [16]byte, baseRevision uint64, listed bool, opID [16]byte) {
146	n := live(id)
147	if who != n.Owner && moderator(who) {
148		mutateModerateListing(cur, who, id, baseRevision, listed, opID)
149		return
150	}
151	owner(n, who)
152	expected(n, baseRevision)
153	if !public(n.Mode) {
154		panic("notes: public note required")
155	}
156	operation(n, opID)
157	unindex(n)
158	n.Listed = listed
159	index(n)
160	bump(n, who, opID, "listing")
161}
162func WritersJSON(idHex string) string {
163	n := find(readID(idHex))
164	out := "["
165	for i, a := range n.Writers {
166		if i > 0 {
167			out += ","
168		}
169		out += q(string(a))
170	}
171	return out + "]"
172}
173func ListSharedWithJSON(addr address, cursor string, limit int) string {
174	return page(sharedIndex, string(keys.CanonicalAddress(addr))+":", cursor, limit)
175}