AURA
AURA CLIcomposable surface

Prove any pull
from your terminal.

The AURA CLI is the composable, scriptable surface for AURA - the same actions as the app, driven from any terminal or script. A single static binary, no runtime to install. The headline is aura verify: it recomputes a Relic’s rarity and subject from the on-chain seed locally, so a gacha pull is rig-evident: you recompute the result yourself, no trust in our API.

single static binaryno runtime dependencymacOS · Linux · Windowsscriptable (--json)
Install01

One line. Any shell.

macOS and Linux, any shell. A single static binary, no Node needed. The installer detects your OS and arch, verifies the checksum, and places aura on your PATH.

macOS / Linux
curl -fsSL https://aura.topengdev.com/install.sh | sh
Windows (PowerShell)
irm https://aura.topengdev.com/install.ps1 | iex
Anywhere with Node (no install)
npx @aura/cli verify 23
Per-OS notes
  • macOSx64 + arm64 (Apple silicon). Single static binary.
  • Linuxx64 + arm64. Single static binary, no Node runtime.
  • Windowsx64 binary via PowerShell. arm64 runs under x64 emulation.
  • npxNode 18+ fallback. Runs the node bundle, no install.

Binaries embed the runtime, so there is zero dependency to install. Hosting and download use a gzip artifact (about a third the size); the installer gunzips after a checksum check.

Commands02

Seven commands.

The same actions as the AURA app - browse, verify a pull, summon, and chat with an Aura - driven from a terminal. Output is rarity-tinted, respects NO_COLOR and non-TTY pipes, and every command supports scripting.

aura agents

List every Aura (creative agent).

aura agents
returnsAll Auras: id, name, style, royalty, relic count, tagline.
aura explore [n]

List the n most recent Relics with rarity (default 15).

aura explore 5
returnsRecent Relics, rarity-tinted (Common gray, Rare cyan, Epic magenta, Legendary gold).
aura aura <name|id>

Inspect an Aura - lore, style, royalty, relic count.

aura aura nokturne
returnsLore, aesthetic, signature, model, royalty.
aura relic <id>

Inspect a Relic - image, owner, on-chain provenance.

aura relic 23
returnsImage URL, owner, seed, provenance, TEE attestation.
aura verify <id>

Recompute a Relic's rarity + subject from the on-chain seed, locally (trustless).

aura verify 23
returnsA local, byte-exact recompute of the seed, rarity, and subject - no API trust. The money command.
aura summon <name|id>

Explain + watch a summon (--watch <requestId> to follow one).

aura summon nokturne
returnsExplains the escrow tx + watches a summon through to mint.
aura chat <name|id> "<msg>"

Talk to an Aura - in-character, grounded in its on-chain identity, TEE-attested when 0G serves it.

aura chat nokturne "what have you earned?"
returnsA reply (TEE-attested when 0G serves it) plus any guarded tool action. Signs in with AURA_KEY (off-chain SIWE); --health needs no key.
The proof03

aura verify proves the pull.

trustless · local

verify does not trust the API’s rarity verdict. It fetches the on-chain economic proof and the public preimage, then recomputes the seed locally - seedRoot = keccak256(abi.encode(DOMAIN_PULL, requestId, buyer, agentId, summonBlockHash)), byte-for-byte the same derivation the contract anchors - asserts it equals the committed on-chain seed, then derives the rarity and the 12-dimension subject from that seed. What it recomputed locally is labeled separately from what it fetched. The recompute is a verbatim copy of the server gacha derivation, so there is zero drift between server, web verifier, and CLI.

aura verify 23
aura verify 23 · live API · the RARE pull
Verify Relic #23   Rare ◆  Recomputed locally by this CLI (keyless recompute - re-derived from the on-chain preimage the API relays)  ✔ seed recomputes from public preimage  (seedRoot == on-chain seed)  ✔ seed is a real provable-pull seed  (>= 2^64 keccak root)  ✔ PROVABLE: rig-evident, recompute it yourself    rarity  Rare ◆  roll 8054 / 9999  subject  tiger hermit as frost mechanical form, casting cradling something, in a salt-flat           at dawn during an eclipse ...   Public on-chain preimage (fetched - on-chain values relayed by the API)    requestId  4        buyer  0x6072C05AdD8Eb43f5aE7Dc7817889ab8AE64d8Fa      agentId  20    blockHash  0x2aa222b94b8864e990ea296703aaec86ad8e58f9ec9bafb6135d617e3c4b4e70  onChainSeed  106543224641626748915671244648347594258244032279370252980128457404203602199003   recomputed  106543224641626748915671244648347594258244032279370252980128457404203602199003   (== match)
What it asserts
  • The seed recomputes from the public preimage (seedRoot == on-chain seed).
  • The seed is a real provable-pull seed (a keccak root, not a low number).
  • RIG-EVIDENT: rarity and subject re-derived locally, so a substituted result would not match.

Confirmed three ways: from source, from the compiled binary, and from the node bundle. The locally recomputed seed is byte-exact equal to the on-chain seed; the derived rarity is Rare, roll 8054 - exactly the on-chain pull.

Script it

Every command speaks JSON. Pipe the proof straight into a CI check or a wallet flow.

aura verify 23 --json | jq .recomputedLocally.provable # => true
Trust boundary04

Honest about the one assumption.

The preimage fields and onChainSeed are public, immutable on-chain values that the API merely relays; the CLI re-derives the seed, rarity, and subject from them itself. The one remaining trust assumption is that the API reported those on-chain values faithfully. A fully paranoid verifier would read onChainSeed (from OutputNFT.provenanceOf) and the block hash (from the Summoned event) directly from a 0G RPC. That direct-RPC cross-check is a clean future --rpc flag; v1 recomputes from the relayed preimage, the same model the web verifier uses.

Verify in the browser ->
CLI source on GitHub ->