Ponsilk Docs

Ponsilk makes a single web page for a token project on Robinhood Chain and gives it an address. It is not a chain, a wallet, an exchange or an analytics tool, and it never holds funds.

It is written for one reader: somebody who has just been handed a link and knows nothing about the project. Every decision in the layout — the order of the parts, the size of the type, what is left out — follows from that one assumption.

What goes in

The facts a project can state about itself: a name, a ticker, a contract, a sentence, a paragraph, a few links.

What comes out

One page at one address, and the link to it.

What is never invented

A figure Ponsilk cannot source is marked unavailable. Nothing is estimated, back-filled, or defaulted to zero to fill a gap.

The composer is the whole authoring surface. It takes about ten minutes if you already know what the project is for.

1. 01

   Open the composer

   Create a page from the navigation. There is nothing to install and nothing to sign into.

2. 02

   Name it

   Name and ticker. The address is derived from the name as you type, and you can edit it before publishing.

3. 03

   Add the contract, then verify it

   Paste the address and press Verify. Ponsilk reads the contract on Robinhood Chain and shows you its name, symbol, decimals and supply. A page cannot be published until that succeeds.

4. 04

   Write the one line

   Up to 110 characters, and the largest text on the finished page. If you cannot write it, the page is not the thing that needs fixing.

5. 05

   Shape it

   Still, Flow or Form. The preview answers immediately.

6. 06

   Check both widths

   The preview switches between desktop and phone. Most people will meet the page on a phone.

7. 07

   Review and publish

   A short summary of what is about to be written, then the page opens at its own address.

Two surfaces side by side: the fields on the left, the page itself on the right. Below large screens they become two tabs — Details & shape, and Preview — rather than a split view squeezed onto a phone.

Name, ticker and contract are required, and so is the address. Everything else can stay empty, and the page leaves out what it was not given rather than filling the gap.

Name

Up to 28 characters. The address is derived from it.

Ticker

Up to 16 characters, shown uppercase with a $. It must match the symbol the contract reports.

Contract

A 20-byte EVM address — 0x and 40 hex characters — which must then verify against Robinhood Chain.

Network

Fixed to Robinhood Chain. No other network is offered.

Supply

Not a field. Read from the verified contract and shown once verification succeeds.

Logo

Optional. Read in the browser and never uploaded. Without one, the page uses a generated mark.

One line

Up to 110 characters.

About

Up to 340 characters.

Links

Website, X, Telegram and explorer. All optional; a page with none of them says so rather than showing dead labels.

Every page is the same four parts in the same order. Nothing is reorderable, which is what lets somebody who has read one page read the next one without learning it again.

Identity

The address, the mark, the name and the ticker. Everything that says which project this is.

Context

The one line first, then the paragraph. Never the other way round.

Essentials

Network, supply, contract — the supply read from the contract itself. Stated as a table, not as hero statistics.

Links

Where to go next — only what the project actually supplied.

The product page shows the same four parts against a real page: point at a name and the region it refers to lights up.

One visual choice, not a colour picker. A treatment moves the atmosphere, the surface and the type together, and it never moves the layout or the order of the parts.

Still

Quiet and minimal. The words do the work.

Flow

Atmospheric and alive. Green light moves through it.

Form

Structured and architectural. Everything on a grid.

The treatment is stored with the page and carried through to the published one, so what you chose in the composer is what a reader opens.

The preview is live markup rather than a picture: the same data, the same treatment and the same material as the page you publish, rendered as you type. It is set as a card rather than a full destination, so the published page reads at a larger scale — the content and the order do not change between them.

On large screens it switches between desktop and phone width. On a phone it simply renders at the width you are holding, because there is nothing useful to simulate there.

The four labels beneath it are the page anatomy: point at one and the matching region of the preview lights up.

Publishing opens a short review first — name, ticker, network, supply, treatment and the address the page will take — so the last thing you do is read it rather than guess at it.

Confirming sends the page to the server, which checks it again — the composer's validation is a convenience, the server's is the one that decides — writes the record, marks it published, and takes you to its address. Nothing navigates until the write has actually succeeded, so a page you were shown as published is a page that exists.

From then on the page is served from the store rather than rebuilt from what you typed, which is why a refresh, a different browser or a different device all find the same page.

In production that store is Postgres. The row is inserted in one statement, and the address column carries a UNIQUE constraint — so two people publishing the same address at the same moment both reach the insert and exactly one of them wins. The other is told the address is taken; nothing is overwritten.

The honest limit, and it is a real one: nothing is attached to a page except the page. There is no account, so a published address cannot be edited, reclaimed or removed by anybody — including whoever made it. Choose the address as though it is permanent, because it is.

Every page lives under /p/ at the slug it was given:

ponsilk.fun/p/vellum

The slug is derived from the project name and can be edited until you publish. After that it is the address, and Ponsilk treats it as fixed — renaming a project does not move the page somebody already has the link to.

Allowed

Lowercase letters, numbers, and single hyphens between them.

Not allowed

Spaces, capitals, punctuation, or a leading or trailing hyphen.

Availability

The composer asks the server as you type, and counts the built-in examples as taken. It is a hint, not the guarantee — the database's unique constraint is what actually decides, at the moment of writing.

Normalisation

Whatever is typed is lowercased and hyphenated before it is judged, so the address that gets validated is the address that gets stored.

A published address opens the page itself: its own composition, at the scale a destination earns. It is deliberately not the composer with the controls hidden, and not the landing page with the words swapped.

It reads in one order — the ecosystem line, the identity, the one line, the paragraph, the essentials, the links — and the contract is shortened for reading, with a copy control that gives back the whole value.

A page whose contract verified on Robinhood Chain also carries the verified line and, under it, market figures and security signals where they exist. Those two arrive a moment after the rest, independently of each other, and are the only parts of the page that depend on anything outside this system.

Three example pages are built into the site and always resolve, whichever browser you open them in:

• /p/vellum
• /p/harbour
• /p/ashgrove

An address with nothing at it says so plainly, and explains why, rather than showing an error.

A page is a URL and behaves like one. The share control uses the browser's own share sheet where there is one and copies the link where there is not. Ponsilk does not post anywhere on your behalf and connects to no platform.

When the link unfurls, the title and description come from the page — change the one line and the description changes with it. The artwork beside them is not generated yet; that is listed under what is missing.

If you want to see how finished pages read, the showcase renders three of them at full size.

Ponsilk is built on Robinhood Chain — the network the tokens its pages describe are issued on. No other network is offered, and the name is not what decides: the server checks that the endpoint it is configured with actually reports chain 4663 before it believes a single value read from it.

A contract address is no longer a claim a page makes. Before a page can be published, the server reads the contract itself and the page carries what the chain answered.

Chain id

4663

What is read

name(), symbol(), decimals() and totalSupply() — the four calls that make a contract an ERC-20 identity.

How

One request. The four reads go through Multicall3 in a single round trip, server-side; a browser never talks to an RPC endpoint and never sees one.

Supply

The integer totalSupply() returns, rendered against the contract's own decimals. Exact integer arithmetic throughout — a supply is never a floating-point number and is never rounded.

Identity must agree

A page's name and ticker have to match what the contract reports. Where they differ the composer says so and offers the on-chain values; it never rewrites what you typed on its own.

Refused

An address that is not an address, one with nothing deployed at it, and a contract that does not answer those four calls. None of them can be published.

What is stored is the answer and its timestamp — chain id, name, symbol, decimals, the raw supply and verified_at — so a page can be served without asking again on every request. The chain stays the source of truth: a stored answer is a record of what it said at a moment, not a promise about now.

Nothing else is read from the chain — no balances, no holder count, no transfer history. The figures a published page shows beneath the contract come from somewhere else entirely, and market data sets out where.

A published page shows four figures under the contract: price, fully diluted valuation, liquidity and 24-hour volume. They are not on-chain reads and Ponsilk does not compute them. They come from GeckoTerminal, which is the one market provider confirmed to index this chain — CoinGecko lists an asset platform robinhood whose chain id is 4663, and GeckoTerminal's network of the same name carries that platform id.

Where it runs

Server-side only. The provider is called during the render, so a browser never talks to it and no key or endpoint is shipped to one. The free tier needs no key at all.

Precision

Figures arrive as decimal strings and stay strings. They are formatted for display without ever being parsed into a floating-point number, so what a page shows is what the provider published.

Caching

A market read is cached for one minute, an identity read for ten. Concurrent readers of the same page share one request. A failure is never cached — the next view tries again.

Not stored

None of it is written to the database. Market figures are fetched per render and discarded; the record holds identity and verification only.

Never blocking

The section streams in after the page. Publishing does not call the provider at all, so an outage there cannot stop a page being made or read.

Two figures are deliberately absent, and the page says unavailable rather than guessing at them:

Market cap

Needs a circulating supply, which nothing publishes for this chain. It is not the same number as total supply and is not derived from it — a token with most of its supply locked would be overstated several times over.

24h price change

Published per trading pool rather than per token. Picking one pool to speak for a token would be a choice presented as a fact, so no percentage is shown.

Any of the four can read unavailable too, and for the same reason: the provider did not have it. A token no exchange has heard of is a legitimate token, and its page is complete without a price. When the provider is unreachable, rate limited, or has never indexed the address, all four say so and everything the chain reports is unaffected.

A published page with a verified contract also carries security signals: what an automated analysis could establish about the contract itself. They come from the GoPlus Token Security API, which covers this chain — its supported-chains endpoint lists Robinhood at 4663, checked against the live API rather than assumed.

These are facts, not a verdict. Ponsilk does not score, grade or rank a token, and nothing on a page says safe, risky, legitimate or otherwise. A signal says what was measured; what to make of it is the reader's business.

What is shown

Only signals the provider actually returned. Contract behaviour where it could be analysed, taxes where they are known, and holder concentration where it is published.

Absent is not no

A signal the provider withheld produces no row. It never becomes a reassuring “No”, and an unknown tax is never rendered as 0% — the provider documents an empty tax as unknown, and on this chain that is every token so far.

Roles stay separate

Creator, owner and largest holder are three different things and are never merged. The account that deployed a contract is not necessarily the one that controls it.

Cached, not stored

Read at most once an hour per contract and never written to the database, so a finding cannot go stale in storage and later be served as current.

Never an all-clear

If the provider is unreachable, rate limited or has no record of the token, the section says so. A failure is never rendered as an absence of problems.

How much can be established depends on the contract. Where the analysis is thin the page gives the reason rather than leaving blanks:

No published source

Nothing can be analysed statically, so no behavioural signal is reported at all. This is the common case on this chain.

Proxy contract

Ownership and distribution are reported, but behaviour is not: the implementation behind the address can be replaced, so a finding about the code there today would not stay true.

One distinction worth stating plainly, because the words are close. Verified on Robinhood Chain is Ponsilk's own check — the ERC-20 identity read from the chain over RPC. A published source is a different thing entirely, reported by the security provider, and means the contract's code can be read on an explorer. A token can have either without the other, and the page keeps them in separate sections rather than collapsing both into one badge.

Ponsilk was built inside the Pons ecosystem and shares its visual heritage: the mark is cut from the same material, and the palette across this site is sampled from it.

It is a separate product with its own identity. A Ponsilk page is a Ponsilk page, not a Pons surface.

Short version: the browser never talks to the database. A publish is a server action; a page view is a server render. Both go through the same two layers, and neither knows which store is underneath.

The record

One page is one row: address, name, ticker, the one line, the paragraph, network, contract, the six verification columns, logo, four link columns, treatment, status and its timestamps. No market or security figure is ever written to it — the store is not a cache for somebody else's API.

Validation

One function, run by the composer for instant field errors and again by the server, where it is the one that decides. Supply, network, id, status and the timestamps are written by the server and never read from the payload.

Service layer

Rate-limits, validates, verifies the contract against the chain, then writes — in that order. It refuses the addresses the examples occupy, and turns anything the store throws into a short sentence. No SQL, connection string or stack ever reaches a browser.

Repository

Three methods — create, getBySlug, existsBySlug — behind one interface. There is nothing that edits or removes a page, because the product does not, and a method with no caller is a promise the code has not made. Swapping the store means writing one more implementation and nothing else.

Drivers

Postgres in production, chosen by DATABASE_URL. A JSON file for local development when no database is configured — and refused outright in production, so a deployment can never mistake a container's disk for a database.

Schema

SQL migration files applied by a command, never at request time. The table repeats the application's own rules as constraints, so a bug above it still cannot store a malformed row.

Configuration

DATABASE_URL selects Postgres; leaving it unset in development falls back to the file driver. No credential is committed — .env.example documents the variables and the real values stay out of the repository.

Three more layers sit beside the store, and all are server-only. A read-only chain client is the only thing that talks to Robinhood Chain: it is where the endpoint lives, so no component can reach an RPC and no caller can choose one, and it reads token identity and nothing else. Beside it sit two provider layers, one for market figures and one for security signals, each a cache in front of one external API. Callers never learn which provider replied, the two never merge into a single verdict, and none of the three writes anything to the database.

Named rather than implied. Everything here is absent from the current build, and the pages above do not pretend otherwise.

Accounts

Nothing to sign into, by decision rather than by omission. A page needs no owner to be worth reading, and an account would be a thing to maintain for a product whose whole output is one public address. The cost is that a published page cannot be edited or removed.

Market cap and 24h change

Neither can be sourced honestly for this chain — one needs a circulating supply nobody publishes, the other is per-pool rather than per-token. Both read unavailable rather than being estimated.

Charts

No price history. The explorer link on every page goes to a surface that has one.

A security score

Signals are reported and not ranked. No defensible scoring method exists for this data, and a number that averaged it would hide exactly the detail worth reading.

Re-verification

A page keeps the answer the chain gave when it was published, with the time it was given. Nothing re-reads it on a schedule yet.

Unfurl artwork

Links carry a real title and description. The image beside them is not generated.

Custom domains

Pages take a ponsilk.page address only.

Backups

The database keeps the pages; taking and restoring snapshots of it is an operational job nobody has done yet.

Do I need a wallet to make a page?

No. There is no wallet connection, no sign-up and no email. You type what goes on the page and that is the whole interaction.

Do I need an account?

No. There is nothing to sign into, no password to choose and no email to hand over. You type what goes on the page, verify the contract, and publish. The consequence is worth knowing: with no account there is no owner, so a published page cannot be edited or taken down afterwards.

Is my page live for other people?

Yes. The page is a row in the database, not something kept in your browser, so the link opens the same page for anyone on any device. What is not in place is any way to edit or remove it afterwards.

Does Ponsilk write the copy for me?

No. There is no model in the loop and nothing is generated from a prompt. The work Ponsilk does is typographic — it decides how your words are set, not what they say.

Is the contract address checked?

Yes. Before a page can be published the server reads the contract on Robinhood Chain and requires it to answer the four ERC-20 identity calls. The name, symbol, decimals and supply on a published page are what the chain reported, not what was typed.

Why can't I type the supply?

Because it is not an opinion. Supply is read from the contract's own totalSupply(), rendered against its decimals, and there is no field for it — a number nobody can mistype is a number that cannot be wrong.

Where do the price and liquidity figures come from?

GeckoTerminal, read on the server when the page renders. They are not on-chain values and Ponsilk does not calculate them — the page names its source and the time it was read, so you can check it against the provider.

Why does a figure say unavailable?

Because it could not be sourced. The token may not be indexed by any market, the provider may be rate limited or down, or the figure may be one nobody publishes for this chain — market cap and 24h change are both permanently in that last group. An unavailable figure is never replaced with a zero.

Does a page tell me whether a token is safe?

No, and it will not. A page reports security signals from an automated contract analysis — whether the source is published, whether the contract can mint or pause transfers, how concentrated the holders are. Those are measurements. Ponsilk does not score them, rank them or draw a conclusion from them, and an absent signal means the analysis did not report it rather than that nothing was found.

Can I use my own domain?

Not yet. Pages will take a ponsilk.page address first, and a custom domain will point at the same page without breaking the original address.

Is Ponsilk affiliated with Robinhood?

Ponsilk is built on Robinhood Chain. We have not claimed anything beyond that — no endorsement, no partnership — and nothing on this site should be read as implying one.