v0 source pure

Admin is the whole governance surface behind one entry point, so a realm using this package declares one function instead of one per governance action.

 1accept <path>     make a registered candidate live, unless its schema
 2                  would break a caller of the one it replaces
 3accept-breaking <path>
 4                  the same, allowing a breaking schema change
 5withdraw <path>   drop a candidate
 6rollback          restore the previous handler
 7forget            drop the rollback history
 8freeze            end upgradeability, permanently
 9extend <path>     let another realm act as this one
10unextend <path>   revoke that
11owner <address>   hand authority to an address
12govern <paths>    hand authority to governance realms (comma-separated)

Every one of them is authority-gated by the proxy, except that a realm may always withdraw its own candidate. Returns "ok", or panics.

Authority describes who may upgrade.

Bind teaches the app its own path, which is what every later caller check compares against. Call it once, from your realm's init:

1func init(cur realm) { a.Bind(0, cur) }

It is separate from New because a package-level var initializer runs before there is a realm frame to read the path from.

Call decodes payload against the live handler's declaration for verb, and dispatches.

An unknown verb, a payload with the wrong number of fields, or a field that does not parse as its declared kind are all refused here, before the handler runs, with a message naming the verb and its signature.

Extensions returns the realms permitted to act as this app.

Frozen reports whether upgradeability has ended.

HistoryPaths returns the handlers already served, oldest first. A non-empty result is what makes rollback available.

LivePath returns the realm path of the handler currently serving, or "".

PendingPaths returns the candidate handler paths awaiting acceptance.

Proxy exposes the underlying proxy, for realms that want typed entry points beside Call or their own Render.

Register nominates the calling realm's handler. Forward it from your realm and call it from the implementation's init.

A handler that declares no verbs is refused here rather than at first call: an app whose API cannot be enumerated is the thing this package exists to avoid.

Render is a gnoweb page describing the app's current wiring: what serves, what could, what it used to, who decides, and how much state there is.

Schema returns the live handler's declaration, or nil if nothing is live.

SchemaJSON renders the API for tooling: enough to build a form without reading any Gno source.

Signature returns one verb's declaration, or "" if it is not answered.

Store hands out a Store accessor to code running on this app's cur: the live handler, and any realm the authority has registered as an extension.

A realm holding a perfectly valid cur of its own is refused, because that cur carries its own path. And because the accessor carries the cur and re-checks it on every operation, the grant cannot outlive this call frame: a handler that stashes the accessor aborts the transaction (a realm value cannot be persisted), so rollback and freeze can no longer be undermined by a captured reference. See Store.

Supports reports whether the live handler answers verb.

Verbs enumerates the API. This is the query a caller makes first.

Address returns an address parameter, or the zero address if it was optional and omitted.

Bool returns a bool parameter, or false if it was optional and omitted.

Has reports whether an optional parameter was supplied.

Int returns an int parameter, or 0 if it was optional and omitted.

Raw returns the decoded fields in declaration order, for a handler that would rather loop than name them.

Signature returns the declaration this payload was checked against, which is worth putting in a panic message.

String returns a string parameter, or "" if it was optional and omitted.

Verb returns the name of the verb being called.

Valid reports whether k is a known kind.

Diff reports what upgrading from prev to s would break for existing callers. An empty result means every payload that worked before still works.

Breaking: a verb disappears, a parameter disappears or changes kind or position, a new required parameter appears, or a result kind changes. Not breaking: a new verb, a new optional parameter at the end, new documentation.

JSON renders the schema for tooling: a client can build a form from this without reading any Gno source.

Lookup returns the verb by name.

Markdown renders the API as a table, for Render.

Names returns the verb names, sorted.

Signature renders one verb, or "" if it is not declared.

Verbs returns a copy of the declarations.

AddInt adds delta to k and returns the new value.

Delete removes k, reporting whether it was there.

Get returns the value at k, or "" if absent. An absent key and a key set to "" read the same; use Has to tell them apart.

GetInt reads k as an int64, returning 0 if it is absent or unparsable.

Has reports whether k is present.

Keys returns a copy of the keys, in order.

KeysWithPrefix returns the keys under a prefix, in order. Prefixes are how a Store holds more than one collection: "task/1", "task/2", "meta/owner".

Len returns the number of keys.

Set writes v at k.

SetInt writes an int64 at k.

Required returns how many leading parameters must be supplied.

Signature renders the verb as a one-line declaration:

1add(text:string, urgent:bool?) -> int