Docs
How the Enjin Governance client works, the EGOV1 off-chain metadata standard, and integration notes for indexers, wallets, and other front-ends.
What this is
A production web client for Enjin OpenGov - the on-chain governance system that lives on the Enjin Relaychain. Any tokenholder can browse referenda, vote with conviction, unlock expired locks, and file new treasury proposals end-to-end without leaving the browser. Mainnet is supported today; Canary is available from the chain selector for testing flows before committing real funds.
The chain RPC is the source of truth for everything that votes, moves money, or locks tokens. The off-chain layer is for the parts a chain shouldn't carry: long-form narrative, comments, attachments, proposer profiles.
How a proposal flows
The wizard composes up to four calls and wraps them in a single utility.batchAll so the submission either lands whole or reverts whole:
preimage.notePreimage(call_bytes)- stores the actual treasury call. Returns a (hash, length) pair the referendum will reference.referenda.submit(origin, Lookup {hash, len}, enactment)- opens the referendum on the smallest treasury track whose authority covers the spend amount.preimage.notePreimage("EGOV1:{u, h}")- stores a content-addressed pointer to the off-chain JSON (see EGOV1 standard).referenda.setMetadata(index, blake2_256(envelope))- binds that pointer to the referendum, whereindexisreferendumCount()read at build time. If another submission lands first the index is stale, the runtime rejects it withNoPermission, and the whole batch reverts - a stale index can never annotate someone else's referendum.
Step 1 is skipped when an account already noted these exact bytes. The wizard reads api.query.preimage.requestStatusFor(hash) right before signing - if the status is Unrequested, re-noting would abort with AlreadyNoted and revert the whole batch, so the wizard drops step 1 and signs the remaining three calls. The referendum still references the same (hash, len) pair, so the on-chain outcome is identical. A Requested preimage keeps step 1: noting it is accepted, and it may not hold the bytes yet.
The proposer separately places the per-track decision deposit (any account can pay it) - it is never part of the submission batch. Neither deposit comes back by itself: once the referendum concludes, anyone can submit referenda.refundDecisionDeposit, and referenda.refundSubmissionDeposit if it was approved or cancelled. A rejected or timed-out referendum keeps its submission deposit reserved for good; a killed one forfeits both. Voters cast convictionVoting.vote over the decision period; the chain dispatches the noted call at enactment if approval and support curves are satisfied.
Spend authority is mapped from amount to track by pickOriginForAmount, using the runtime's per-origin spend limits. They aren't exposed in metadata, so the app carries a copy per runtime spec version (amounts in ENJ, cENJ on Canary):
| Origin | Spec 1070 | Spec 1080 |
|---|---|---|
| SmallTipper | 100 | 2,500 |
| BigTipper | 5,000 | 10,000 |
| SmallSpender | 50,000 | 50,000 |
| MediumSpender | 250,000 | 250,000 |
| BigSpender | 2,500,000 | 2,500,000 |
| TreasuryAdmin | 25,000,000 | 25,000,000 |
The wizard reads the connected chain's runtime spec version and files under that version's limits, held to the lowest value any later listed version allows, so a referendum filed before a listed upgrade still enacts after it. On a runtime newer than every listed version it uses the newest limits and warns; on an older one it won't file a spend. TreasuryAdmin (Enjin's counterpart to Polkadot's Treasurer) is the top tier and carries a much larger decision deposit. Requests above its limit are not supported and the wizard blocks them.
EGOV1 off-chain metadata standard
EGOV1 is the standard the client uses to attach a title, summary, body, attachments, and signature to an on-chain referendum without bloating chain state. It's designed so any third party - Polkassembly, Subscan, an indexer, or another client - can rebuild the proposal corpus by resolving referenda.metadataOf through the preimage pallet and filtering for the EGOV1: magic prefix.
On-chain envelope
The submission batch notes a preimage with the UTF-8 payload below and binds its blake2-256 to the referendum via referenda.setMetadata:
EGOV1:{"u":"<url>","h":"<sha256-hex>"}u- public URL of the canonicalproposal.json.h- sha256 of the canonical (sorted-keys-at-every-level) JSON bytes. Pinned forever by the on-chain envelope.- Canonical means keys sorted lexicographically at every level, no insignificant whitespace (
JSON.stringify's default separators), UTF-8 bytes; arrays keep their order. Pretty-printing the same object yields a different sha256, so a reimplementation that indents will read every proposal as tampered. - Non-ASCII characters are emitted literally as UTF-8, never as
\uXXXXescapes. This is the second way a reimplementation silently diverges: Python'sjson.dumpsescapes non-ASCII by default, so any proposal containing an em dash, a curly quote or an accented name hashes differently unless it passesensure_ascii=False.
proposal.json shape
{
"schema": "enjin-governance-proposal",
"version": "1.1.0" | "1.2.0",
"network": "enjin-relay" | "enjin-matrix" | "canary-relay" | "canary-matrix",
"proposer": "<SS58 address>",
"title": "<≤ 200 chars>",
"summary": "<≤ 500 chars> | null",
"body_markdown": "<≤ 100000 chars>",
"track": "<track name, e.g. SmallTipper or root — ≤ 80 chars>" | null,
"spend": {
"beneficiary": "<SS58 address>",
"amount_planck": "<decimal string>"
} | null,
"attachments": [{
"name": "<filename>",
"url": "<public URL>",
"sha256": "<hex>",
"content_type": "<MIME>",
"size_bytes": <int>
}],
"call": { // 1.2.0, optional
"section": "<pallet, e.g. system>",
"method": "<call, e.g. authorizeUpgrade>",
"origin": "<track origin, e.g. Root>",
"preimage_hash": "<0x… blake2-256 of the call>",
"preimage_len": <int>,
"inline": <bool>,
"code_hash": "<0x… blake2-256 of the runtime> | null"
} | null,
"enactment": { "type": "At" | "After", "block": <int> } | null, // 1.2.0
"preimage_hash": "<0x… hex> | null",
"preimage_len": <int> | null,
"created_at": "<ISO 8601>",
"edited_at": "<ISO 8601> | null",
"edit_count": <int>,
"signature": {
"address": "<SS58>",
"sig": "<hex>"
} | null
}All amount_planck values are decimal strings (not numbers) to preserve precision - the relay has 18 decimals, which overflows Number.
Version 1.2.0 adds the optional call and enactment sections, written for proposals filed through the advanced composer (runtime upgrades, cancel / kill, whitelisting, remarks, raw calls). Every other field is unchanged, so 1.1.0 readers keep working. The call section is what the proposer recorded; the proposal page still decodes the call from the preimage on chain, and for runtime upgrades shows the code hash computed from it. Referenda filed elsewhere can get the same details afterwards: the account that submitted one signs preimage.notePreimage + referenda.setMetadata while it is ongoing.
Attachments live next to the JSON under proposals/<network>/<id>/media/. The server builds each url from that key, and images are stored without their metadata (no GPS) and scaled to fit 2560 px; the sha256 is of the stored file. The body can show an attachment with . Only the proposal's own attachments render as images; any other image link is shown as a plain link, so nothing in a proposal can be swapped or used to track readers after voting starts.
track is a free-form label, not an enum, and its casing is not normalised. Treasury proposals filed through this client carry the PascalCase Origins variant (SmallTipper); proposals filed elsewhere carry whatever their author wrote, typically the runtime track name (root). Match case-insensitively, and treat an unrecognised value as opaque rather than dropping the proposal.
Discovery for indexers
- Read
referenda.metadataOf(index)and resolve the hash through thepreimagepallet to the envelope bytes. For referenda filed before this binding shipped, fall back to scanning finalised blocks forsystem.remarkcalls nested in the submission'sutility.batchAll. - Filter payloads whose UTF-8 bytes start with
EGOV1:. - JSON-parse the suffix to get
{u, h}. - Fetch
u. The bytes are guaranteed to start as the JSON committed on chain ath; if the proposer edited later (see Editing & withdrawal) the bucket bytes will differ fromh- that's the public signal an edit happened. - The referendum link is explicit:
MetadataOfis keyed by index. For legacy remarks, link via the same extrinsic: the batch that emitted the remark is the one that emittedreferenda.Submitted{index}.
Result: anyone can rebuild the proposal corpus without any dependency on this app's database.
Editing & withdrawal
Proposers can update the off-chain narrative after submission from the Edit Proposal page on the referendum. The PATCH endpoint overwrites proposal.json at the same bucket key, so existing URLs keep resolving - but the sha256 changes, and the on-chain envelope still pins the original hash. The detail page shows an (edited) chip and the EGOV1 source modal explains the divergence.
What you can edit: title, summary, body, attachments. What you can't: spend amount, beneficiary, preimage, proposer address, track - those are baked into the referendum and would invalidate the on-chain state.
Withdraw is the social signal for "I filed this in error, please vote NAY": it records a withdrawn_at timestamp plus an optional reason, and the detail page renders a destructive-tone banner. The on-chain referendum is unchanged - substrate's referenda.cancel is locked to the ReferendumCanceller origin, not the proposer. To actually move the tally you can vote NAY yourself with high conviction, file a separate cancellation referendum, or wait for the decision period to expire if the deposit isn't placed (it is here, so that path is moot).
Voting & conviction locks
Votes carry a conviction multiplier between 1x and 6x. Higher conviction multiplies the vote's tally weight but locks the underlying balance for a period after the referendum resolves. The lock grows with conviction, doubling each step: 1x = 1, 2x = 2, 3x = 4, 4x = 8, 5x = 16, 6x = 32 lock periods. One period is set by the runtime (7 days on Enjin and Canary) and is the same on every track, so 6x locks for 224 days.
What voters can do
- Cast a vote -
vote(pollIndex, accountVote, currency)with an Aye or Nay verdict, a 1x-6x conviction multiplier, and a vote source (liquid ENJ or a specific sENJ pool). - Abstain - a
SplitAbstainvote with the whole amount on abstain. It counts toward support, not approval, and has no conviction, so nothing stays locked once the referendum ends. - Change a vote - re-submit
votefor the same referendum to swap the verdict, conviction, or source. The chain overwrites the previousAccountVotein the same lock class - no separate "edit" extrinsic. - Remove a vote -
removeVote(trackId, pollIndex)pulls your weight back out of the tally. Called before the decision period ends, it withdraws the vote and starts the lock from now; called after the referendum resolves, it just frees the vote record so the lock can be unlocked. - Unlock locked balance - the
/unlockpage readsconvictionVoting.classLocksFor(account)and lets you submitunlock(class, target)for any class whose lock period has expired.
Vote source: liquid ENJ or sENJ
Enjin's extended AccountVote carries a currency arg so a single voter can source a vote from either:
- Liquid ENJ -
{ Enj: null }. The default. - Staked ENJ from a specific pool -
{ SEnj: <poolId> }. sENJ lives in themultiTokenspallet under collection1withtokenId === poolId. Your balance for pool N istokenAccounts(1, N, account).balance. Pool art (the "Degens" NFTs) lives separately in collection2.
sENJ accrues staking rewards, so 1 sENJ > 1 ENJ. The per-pool stake factor is staking.ledger(stash).active / multiTokens.tokens(1, N).supply, and the ENJ-equivalent is senjBalance * stakeFactor. The vote panel shows both numbers next to each source. The chain counts the sENJ amount 1:1 like ENJ, for approval and for support: the stake factor only shows what the sENJ is worth and adds no voting weight.
The vote panel automatically detects every pool you hold sENJ in and lets you pick which source to vote from. When you have no sENJ, the selector hides and you just vote with liquid ENJ. From runtime 1080, a pool that is being destroyed is listed but can't be picked: its sENJ can no longer vote or delegate. Conviction multipliers and lock periods apply the same way to either source. A vote locks the sENJ where it is: it stays in its pool and keeps collecting staking rewards, but the locked part can't be unbonded or transferred until the lock ends.
voteManager vs convictionVoting
Enjin Relay's governance runs on a multi-token fork of the standard convictionVoting pallet - the same OpenGov semantics (Aye/Nay verdict, 1x-6x conviction multipliers, per-class lock schedule, support/approval curves), with one addition: every vote, delegation, and unlock carries a currency argument so it can source liquid ENJ or a staked-ENJ pool token (sENJ).
convictionVoting.vote(pollIndex, accountVote, currency)- the deployed Enjin surface (3-arg, multi-token). Stock Substrate / Polkadot is the 2-arg version withoutcurrency.voteManager- a fallback surface the client also supports for any runtime that exposes it; the current Enjin Relay runtime does not, so governance goes throughconvictionVoting.
The client probes runtime metadata to pick the right pallet and the right call arity automatically, so the per-vote currency argument is never dropped. If you compare past Subscan extrinsics they may show votemanager (vote) or Convictionvoting (Vote) depending on which pallet the runtime exposed at the time.
Fellowship & the fast track
The Fellowship is the relaychain's ranked technical collective (fellowshipCollective), with its own referenda (fellowshipReferenda). Its referenda are numbered separately and shown as F#N: F#7 and public #7 are different referenda. The Fellowship page lists members, every F# and the calls waiting on the whitelist; it only appears on networks that run the pallets.
Ranks, tracks and vote weight
- Ten tracks, 0 (candidates) to 9 (grand masters). Track N needs rank N to vote; a lower rank is told which rank it needs.
- A vote weighs
(e+1)(e+2)/2withe = rank - track minimum: 1 at the minimum, 3 one rank above, 6 two above. Approval is by weight, support by members voting Aye. - Votes are Aye or Nay, without conviction or locks. The first vote on a referendum is free; changing it pays the normal fee.
Filing an F#
Members of rank I and up file from the advanced composer's Fellowship chamber, with a title, summary and EGOV1 record like any proposal. It offers whitelisting a call (by call data or hash), removing a whitelisted call, adding, promoting, demoting or removing a member, and a raw call, and recommends the origin each needs:
whitelistCallandremoveWhitelistedCall- Fellows (track 3).- Add a member - 1Dan; promote, demote or remove rank r - (r+2)Dan, on the track of that rank.
There is no submission deposit. The decision deposit (10 to 100,000 ENJ by track) can be placed later by anyone from the F# page. In the EGOV1 JSON an F# says "referenda_pallet": "fellowshipReferenda", and /api/proposals/by-index/N?pallet=fellowshipReferenda reads it.
The fast track
- An F# on the Fellows track runs
whitelist.whitelistCall(hash). - Once it is enacted, the call's hash sits in
whitelist.whitelistedCall. - A public referendum on the WhitelistedCaller track runs
dispatchWhitelistedCallWithPreimage(call), with shorter terms than Root. - When it passes, the call is dispatched as Root.
Both referenda show these four steps and link each other by the call's hash. Until the call is whitelisted, the public one warns that enactment would fail with CallIsNotWhitelisted.
Verification
The badge on every proposal's About card maps the bucket JSON's integrity to one of four colour-coded states:
- EGOV1 · VerifiedBucket sha256 matches our DB record and the hash pinned on chain at submission - the narrative you see is byte-for-byte what the proposer submitted.
- EGOV1 · EditedThe proposer set
edited_at: they overwrote the bucket JSON after submission. Bucket sha256 still matches our (updated) DB record, but it diverges from the sha256 pinned on chain - that divergence is the public edit signal. - EGOV1 · UnverifiedBucket sha256 doesn't match what we expected and no edit is recorded. Treat the narrative with suspicion until the issue is investigated.
- EGOV1 · Fetch FailedThe bucket URL didn't respond. Not a verification result, just a transport failure - retry when the CDN recovers.
External indexers should additionally check that the bucket sha256 matches the h pinned by the on-chain envelope. When that fails but edited_at is present in the JSON, the proposer edited after submission; when edited_at is absent, treat the content as tampered.
Wallet integration
Supported connectors:
- Enjin Wallet - WalletConnect v2, desktop QR or mobile deep link
- Polkadot browser extensions - Polkadot.js, Talisman, SubWallet, PolkaGate
All connectors implement the same Connector interface and produce a Polkadot Signer the rest of the app uses identically.
Known issues
WalletConnect deep links on iOS Safari must fire from inside a fresh user-gesture frame, not a promise callback. The sign-request modal wraps the "Open in Enjin Wallet" button accordingly - if it stops working, check that no async hop sits between the click and the deep link.
Double sign prompts on iOS - iOS Safari can fire two click handlers when the app-switcher prompt returns. Sign flows guard against this with a module-level in-flight lock.
SS58 prefix drift - some wallets return addresses in their default prefix instead of the active chain's.encodeForChain normalises before display, and ownership checks compare by public key (samePublicKey) so the same wallet on Canary (cn…) still matches a proposal filed on Enjin Relay (en…).
RPC reconnects - the relay RPC can drop briefly under load. Tx builders wait up to a few seconds for the API to come back before failing with a friendly "please try again" error; the proposal list auto-refreshes on tab focus.
Identity & comments
A connected wallet is enough to browse referenda and cast votes - everything that touches chain state runs through a signed extrinsic, so the wallet is the only authority that matters. On top of that, the client adds a lightweight social layer so voters can put a face to an address and talk through proposals before they go to tally. It's deliberately minimal: a profile, a verified comment thread per referendum, no DMs, no upvotes, no forum.
Sign-in with wallet (proof of control)
Connecting a wallet only proves the wallet exposed an address; signing a server-issued nonce proves the wallet controls the private key. The sign-in flow follows the SIWE pattern adapted for Substrate: POST /api/auth/nonce hands back a 16-byte hex nonce, the client builds a plain-text message ("Enjin Governance - sign in" + address + nonce + issued timestamp), the wallet signs it, and POST /api/auth/verify checks the signature with @polkadot/util-crypto's signatureVerify (accepts the wallet's <Bytes> wrapping, plain, and 0x-hex forms).
Sign-in uses the address in the format of the network you're on: Enjin Relaychain (en…) or Canary Relaychain (cn…). The client converts whatever the wallet shows - a generic 5… address, say - before it asks for a nonce, and the server refuses other formats, so every account belongs to one network and its handle is unique there.
On success the server returns a 32-byte opaque bearer token in the enjin-governance:session cookie (HttpOnly, Secure in production, SameSite=Lax, 30-day TTL). Only the SHA-256 hash of the token lives in wallet_sessions - the raw secret never persists, so a DB leak doesn't hand out live sessions. Sessions never authorise on-chain transactions; they only gate the off-chain social writes below.
Profile
Once signed in, an address can attach a profile to itself:
- Handle - case-insensitive unique, 3-32 chars,
[a-z0-9_]. - Display name - up to 80 chars, free text. Invisible and text-direction characters are removed and odd spaces become plain ones before it's checked and stored.
- Bio - up to 500 chars.
- Avatar - PNG/JPEG/WebP/GIF up to 4 MB (larger photos are shrunk in the browser first), transcoded server-side to a 150×150 PNG with EXIF stripped, stored in R2 at
user-avatars/{user_uuid}.png.
Profiles are read publicly via GET /api/users/by-address/{address} (no auth, cached 60s edge / 600s stale-while-revalidate) and written only by the owner via PATCH /api/users/me. A separate is_verified boolean is reserved for manual attestation by the maintainers - there's no self-service path to turn it on.
Public comments
Each referendum carries a flat comment thread. GET /api/proposals/{uuid}/comments is public; POST requires a valid session, accepts 1-10,000 chars of markdown, and stamps the comment with the signer's user_id and address so authorship is always traceable to a wallet that proved control. Comment rows surface author_handle, author_display_name,author_avatar_url, and author_is_verified for the UI.
Authors can edit their own comment for 15 minutes after posting via PATCH /api/comments/{id} - same 1-10,000 character limit, not once it's deleted or hidden by moderators, and not while their posting is paused. The new text replaces the old one (no history is kept), edited_at is set so the thread shows "edited", and the automatic text check runs again on the new text.
Authors can soft-delete their own comments via DELETE /api/comments/{id} - the row stays with is_deleted = true and the body replaced by [deleted]. Moderators don't delete comments; they can hide them (see Content policy & moderation). There is no reaction or upvote UI. The parent_id column on comments reserves space for threading, but the current UI renders the thread flat by created_at.
Address page
/user/{address} is the public profile view: avatar, display name (or @handle, or shortened address as a fallback), verified badge, bio, full address, and a list of referenda the address has authored. Addresses that have never signed in still resolve - the page just shows "No profile yet" in place of the social fields and continues to list their on-chain activity.
What's intentionally out of scope
No direct messages, no upvotes or reactions, no proposal-agnostic forum, no threaded reply UI, no comment edit history. The social layer exists to give voters context and let proposers respond - if the conversation outgrows what a flat per-referendum thread can carry, that's the signal to move the discussion to a dedicated venue, not to build one inside this client.
Chain coordinates
Values come from lib/chain/chains.ts. Mainnet is Enjin Relay; Canary mirrors the same governance pallets for testing flows before committing real funds.
Enjin Relaychain
Mainnet- RPC
- wss://rpc.relay.blockchain.enjin.io
- SS58 prefix
- 2135 (en…)
- Decimals
- 18
- Ticker
- ENJ
- Treasury
- enD9wdMEaQa3MEDUc7dtsCC86JYGMN5JBE2NBRoMyC37dX4iA
- CAIP-2
- d8761d3c88f26dc12875c00d3165f7d6
Canary Relaychain
Testnet- RPC
- wss://rpc.relay.canary.enjin.io
- SS58 prefix
- 69 (cn…)
- Decimals
- 18
- Ticker
- cENJ
- Treasury
- enD9wdMEaQa3MEDUc7dtsCC86JYGMN5JBE2NBRoMyC37dX4iA
- CAIP-2
- 735d8773c63e74ff8490fee5751ac07e
Timing primitives
Each track has its own periods:
- Prepare period - from submission until a decision can start. Deciding also needs the decision deposit; without it the referendum times out after
referenda.undecidingTimeout. - Decision period - voting is open; approval and support curves are evaluated continuously. Support is measured against active issuance (total minus inactive) up to runtime spec 1079, and against total issuance from spec 1080.
- Confirm period - the curves must hold continuously for the full confirm duration to pass.
- Enactment delay - after approval, the scheduler dispatches the noted call at least this many blocks later, or later still if the proposal asked for a later block. A treasury
spend_localthen waits for the next spend period to be paid.
Read the live values from api.consts.referenda.tracks. The lifecycle progress bar on each proposal mirrors them.
How much support a referendum needs
Every referendum has to meet two requirements while it is being decided:
- Approval - the share of aye votes, weighted by conviction. On every Enjin track it ends at 50%.
- Support - how much ENJ backs the referendum, as a share of issuance. Aye and abstain votes count with their plain amount, without conviction. Nay votes don't count toward support.
Both requirements start high and fall over the decision period. A referendum starts confirming as soon as it meets both, and passes if it still meets them at the end of the confirm period. If it never meets them before the decision period ends, it is rejected. On a proposal's Decision slide the chip shows where it stands and when it would pass if the votes stay as they are; tap it for the details.
Loading the live values from Enjin Relay…
Cancellation paths
A proposer cannot dispatch referenda.cancel(idx) themselves - it's gated to ReferendumCanceller. The realistic levers:
- Don't place the decision deposit - the referendum times out after
referenda.undecidingTimeout. The submission deposit then stays reserved for good. - Self-NAY - vote against your own proposal with high conviction. Only on-chain action that actually shifts the tally.
- File a cancellation referendum - a separate proposal on a privileged track that dispatches
referenda.cancel(idx)if it passes. Heavy and rarely justified. - Off-chain withdrawal (this app) - the Withdraw button sets
withdrawn_atand surfaces a banner. Doesn't change on-chain state, but tells voters clearly to vote NAY.
Content policy & moderation
Proposals, images and comments are public. These aren't allowed:
- Secrets: wallet recovery phrases, private keys or screenshots showing them - anyone could take the funds.
- Personal data of others: ID documents, home addresses, phone numbers, private photos.
- Scams and phishing: fake airdrops, impersonation, links that ask for a wallet signature or seed.
- Sexual or violent content, and harassment or hate.
- Illegal content and spam.
How it works. Anyone signed in can report a proposal (the "…" menu on its About card), an image (in the image viewer) or a comment. Moderators review reports in one queue and can keep, blur, hide or restore content; only admins can delete a file, for legal takedowns, or pause someone's posting. Every decision needs a reason and appears in the public moderation log. Proposers can remove their own attachments at any time.
Automatic checks (when enabled): uploaded images and PDFs are checked by an AI model (Anthropic's Claude) before they are stored. Clear violations, such as a readable recovery phrase, are rejected or held, depending on the admins' setting; borderline files are held back and sent to the moderators' queue, and appear once a moderator has looked. Animated images always wait for a moderator, because the model sees only their first frame. Proposal text and comments are only ever flagged for a human - the machine never hides text on its own. Admins choose the model, what is checked and a daily limit; past the limit, uploads wait for a moderator and text is moderated by reports as usual.
What moderation never does: nobody can rewrite someone else's text, and referenda, votes and on-chain records are never touched. A proposal's proposal.json stays byte-identical, so its EGOV1 verification keeps working even when an image is hidden or removed. Hidden images are no longer served by this site; deleted files are removed from storage itself. Older proposals may still link straight to the storage bucket, where a hidden (not deleted) file stays reachable - legal takedowns therefore use "delete file".
Links
- Polkadot OpenGov reference - the SDK pallets this client wraps.
- Enjin developer docs - broader platform reference.
- - report an issue or send feedback directly; the modal stays on this page so you don't lose your spot.
- Report a security issue - private vulnerability disclosures, kept off public channels until resolved.