How WETPIXCLAW works

Overview

WETPIXCLAW turns a text prompt into a single piece of pixel art: a cyberpunk city, at night, in the rain. The aesthetic never changes — chunky pixels, falling rain, neon signs reflected in wet ground. What changes is everything inside that frame, driven entirely by your words.

Each painting is hung on a shared wall (the gallery). Anyone can like a painting as many times as they want, and the most-liked prompts rise up the leaderboard. OpenClaw adds a bounty layer: mystery paintings whose secret prompt you can try to crack for a prize. After $WPCLAW goes live on pump.fun, the agent unlocks and the limits lift.

The painting loop

• Write — a place, a mood, a tiny story. The stranger the prompt, the stranger the city.
• Paint — the engine renders your scene in the locked style. Preview is free and instant.
• Hang — commit it to the wall. This is the one shot that counts.
• Love — anyone can spam the heart. Likes are uncapped and decide the leaderboard.

How the engine paints

There is no diffusion model and no external image service. The renderer is a deterministic, layered pixel painter. It builds the scene back-to-front, then upscales a small canvas with nearest-neighbour sampling so the pixels stay crisp and chunky.

• Sky — a vertical gradient with a soft glow halo near the horizon.
• Far buildings — dark silhouettes for depth (parallax).
• Mid buildings — lit windows in a warm/cool mix.
• Billboards & neon signs — the dominant cyberpunk light, each with a glow.
• Foreground — railing, cables, a staircase, a platform.
• Character — sometimes a lone silhouette in the rain, rim-lit by neon.
• Wet reflection — the lit half mirrored and blurred into the ground.
• Atmosphere & rain — fog, vignette, and diagonal rain whose density the prompt sets.

Because it's pure CPU code, a painting costs effectively nothing to produce — no per-image API bill, however viral the wall gets.

Mood & keywords

Your prompt is scanned for keywords that select one of five palettes. If nothing matches, a weighted fallback keeps the signature wet-neon look.

Determinism

Your prompt is hashed into a seed, and that seed drives every random choice — palette, building heights, window patterns, sign placement, rain density, whether a figure appears. The same prompt always paints the same scene, and two different prompts almost never collide. That's what makes a prompt feel like your painting — and it's exactly what makes OpenClaw possible.

OpenClaw — crack the painting

OpenClaw shows a handful of mystery paintings. Each was rendered from a secret prompt. Because the engine is deterministic, there is exactly one set of words that paints that exact city — and if you name it, you crack the claw and win the pot.

• You see the painting and a short hint.
• You type your guess and hit Crack.
• Your guess is normalized (lowercased, trimmed, spaces collapsed) and hashed. If the hash matches the puzzle's, you've cracked it.
• The first correct cracker wins; the prize is paid on-chain after a quick verification.

How secret prompts stay safe

The whole point is that nobody can read the answer off the page. So the secret prompt is never shipped to the site — not in the HTML, not in the JS, not in a comment.

What is public:

• the rendered PNG (pre-generated offline by the team), and
• a SHA-256 hash of the normalized secret prompt — a one-way fingerprint.

A hash can verify a guess without revealing the answer: hashing is one-way, so you can't run it backwards, and brute-forcing a natural-language sentence through SHA-256 is infeasible. The plaintext prompt lives only offline (a sealed file or a Railway environment variable), used once to render the image.

Fairness & payout

Verification is deterministic and identical for everyone — there's no judge and no favouritism. When a guess matches, the win is recorded server-side (first correct entry wins) and the puzzle is marked cracked for everyone. Prizes are paid on-chain after the team confirms the winning entry. Until $WPCLAW launches, OpenClaw runs on a house pot; after launch, bounties scale up.

One shot per person

Pre-launch, each person can hang exactly one painting on the wall. This keeps the wall meaningful and the cost near zero. It's enforced by a visitor key (a hash of IP + a lightweight browser fingerprint) on the server, backed by a unique index in the database so it holds even under races. Previewing in the studio is unlimited — only hanging counts. (OpenClaw guesses are separate and unlimited.)

Likes & leaderboard

Likes are intentionally uncapped — mash the heart. Each like is an atomic increment, and the leaderboard is simply the wall sorted by likes. No team curation: the best prompt wins.

$WPCLAW & the agent

WETPIXCLAW launches as a fair launch on pump.fun. Before launch, the wall is one-shot and the studio runs the in-browser engine. When $WPCLAW is live, the gallery agent wakes up: unlimited prompts, richer scenes, bigger OpenClaw bounties, and on-chain bragging rights for the top of the wall.

CA & buy link

The contract address lives in exactly one place — js/config.js — and the buy link is always pump.fun/coin/<CA> with no launch gating. To go live, you change one string and bump the cache-buster.

// js/config.js — the single source of truth
window.CFG = {
  CA:     "TBA",        // change ONLY this at launch
  TICKER: "$WPCLAW",
  X:      "https://x.com/wetpixclaw",
  TG:     "https://t.me/wetpixclaw"
};

<!-- bump ?v=N every time you change config.js -->
<script src="js/config.js?v=2"></script>

API reference

The backend is a single FastAPI service (it also runs the renderer). Base URL is CFG.API; leave it blank to run the in-browser demo.

// POST /openclaw/guess
{ "id": "claw1", "guess": "red neon ramen alley" }

// 200 OK — never returns the secret, only correctness
{ "correct": true, "solved": false }

Self-host

Static site on any host, Python API on Railway, Postgres + storage on Supabase.

• Supabase — run schema.sql, make the paintings bucket public.
• Railway — deploy the API; set SUPABASE_URL, SUPABASE_SERVICE_KEY, ALLOWED_ORIGINS (www + non-www), and OPENCLAW_HASHES (id:hash pairs). Don't set PORT.
• Frontend — set CFG.API, upload the site. Render mystery PNGs offline and drop them in img/openclaw/; keep the secret prompts out of the repo.

# run locally
pip install -r requirements.txt
python renderer.py          # eyeball sample_*.png
uvicorn app:app --reload    # API on :8000

FAQ

Is it real AI art?

It's algorithmic generative art driven by your prompt — not a diffusion model. The upside: the style stays coherent, every scene is unique to its prompt, and it costs nothing to run at any scale.

Can OpenClaw be cheated by reading the page?

No. The secret prompt is never on the site — only the image and a one-way hash. You can't reverse a hash, and guessing a sentence by brute force isn't feasible. You actually have to figure out the words.

Why only one painting on the wall?

Scarcity makes the wall mean something and keeps things fair pre-launch. The agent lifts the limit after launch. OpenClaw guesses aren't limited.

How do I buy $WPCLAW?

Use the Buy button in the nav once the CA is live. We post the CA on X and Telegram first — ignore any address from DMs or replies.