Yutok

Turn attention on-chain.

Yutok is a discovery layer for short-form video and a non-custodial token launchpad that connects viral internet culture with Pons V2 launches on Robinhood Chain.

Discover viral Shorts · Launch with your wallet · Track on-chain

Features · Architecture · Run locally · Launch flow · Security

About Yutok
Current product status
Key features
Architecture
Data flow diagram
Token launch flow
Pons V2 transaction lifecycle
Technology stack
Repository structure
Environment setup
Running the project
Developer commands
Application routing
API server
Contracts and network
Local launch data model
Wallet and signing
Market data and Token Terminal
YouTube feed source
Deployment
Troubleshooting
Security and risk
Roadmap
Contributing
License

About Yutok

Yutok is built around one question:

What if the videos receiving the most attention could become the starting point for a transparent on-chain experience controlled by the creator?

The product combines three layers:

Discovery — a live feed of public YouTube Shorts from a curated set of channels.
Creation — a launch form that uses video metadata as a starting point and lets creators edit the name, ticker, description, image, and social links.
Verification — on-chain reads for launch events, token metadata, reserves, prices, and bonding-curve status on Robinhood Chain.

Yutok is non-custodial. The application does not store private keys and does not submit transactions without explicit confirmation from the connected wallet.

Product principles

Attention first — discovery starts with content, not a contract list.
Wallet-owned — users keep their wallet and approve transactions themselves.
On-chain readable — launch data and market state are read from public contracts.
Local registry aware — Tokens, Profile, and Token Terminal only list launches known to have originated from Yutok.
Fail explicitly — when the RPC, feed, or simulation is unavailable, the UI shows an error or empty state instead of inventing on-chain data.

Current product status

Active

Yutok landing page with a dark aurora visual system.
Live YouTube Shorts feed through public RSS/Atom feeds.
Vertical scroll-snap video feed at /app.
Injected wallet support for:
- MetaMask
- Robinhood Wallet
- Rabby
- Generic EIP-1193 browser wallets
Network switching to Robinhood Chain.
Native Pons V2 token launches from inside the application.
Pons V2 pair assets, including ETH and factory-approved pair tokens.
Initial buy during launch.
Creator wallet, creator tax, snipe-tax exemptions, and holder fee sharing.
Yutok token registry backed by localStorage.
Token list, Profile, leaderboard, market data, chart, trading, and activity views.
Product whitepaper at /whitepaper.

Temporarily disabled

The Long.xyz launch option has been removed from the Yutok launch menu for now.
Yutok currently exposes only the Pons V2 launch path.
Remaining Long.xyz research and configuration files are retained for future work, but they are not shown in the UI and are not used to submit transactions.

Current limitations

YouTube data comes from public RSS, not the YouTube Data API.
RSS exposes only a recent window of items for each channel.
Tokens saved in browser localStorage are not automatically synchronized across devices.
Market data depends on a responsive Robinhood Chain RPC.
Token Terminal is currently designed for Yutok-registered Pons V2 launches.
Available pairs and launch configuration are determined by Pons V2 on-chain state, not by the frontend alone.

Key features

1. Landing page

The landing page explains Yutok through:

Hero section with a launchpad CTA.
Dark aurora styling with cyan, violet, magenta, and emerald accents.
Live feed section.
Token leaderboard.
Interactive preview.
FAQ.
CTA banner.
Footer and official social links.

2. Live YouTube Shorts feed

The API server aggregates public YouTube RSS/Atom feeds and:

validates Shorts items;
deduplicates by video ID;
combines all available feeds;
randomizes the latest items;
caches successful results for five minutes;
returns metadata, thumbnails, channels, URLs, and available statistics.

3. Pons V2 launchpad

Creators can start a launch from a selected video and review:

token name;
token symbol;
description;
image/logo URI;
X/Twitter;
Telegram;
website;
pair asset;
initial buy;
creator wallet;
creator tax;
snipe-tax exemption wallets;
holder fee sharing.

Before a transaction is submitted, the frontend reads:

launch fee;
enabled launch configuration;
global launch status;
launcher permission;
pair approval;
economics preview;
pair-asset balance;
estimated gas and transaction affordability.

4. Token Terminal

Token Terminal reads token runtime data from the chain and displays:

name and symbol;
logo;
total supply;
pair asset;
current reserves;
real quote reserve;
price;
quote-denominated market cap;
curve fee;
graduated status;
ready-to-graduate status;
reserve-based historical chart;
wallet balances;
bonding-curve buy/sell actions;
launch transaction hash.

5. Yutok token registry

Because the Pons V2 factory is global and can receive launches from other applications, Yutok uses a local registry to distinguish tokens created through Yutok from unrelated factory launches.

The registry is used by:

Tokens
Profile
Token Terminal

The global Pons feed may still be used for certain market discovery surfaces, but it is not treated as the source of truth for Yutok's own token list.

Architecture

Yutok uses a pnpm monorepo with a web artifact, an API artifact, and shared internal libraries.

flowchart TB
    User((Creator / Trader))
    Browser["Yutok Web<br/>React + Vite"]
    Wallet["Injected Wallet<br/>EIP-1193"]
    API["API Server<br/>Express 5"]
    YouTube["Public YouTube RSS/Atom"]
    RPC["Robinhood Chain RPC"]
    Pons["Pons V2 Factory<br/>Bonding Curve Contracts"]
    Storage["Browser localStorage<br/>Yutok launch registry"]
    Explorer["Robinhood Chain Explorer"]

    User --> Browser
    Browser --> Wallet
    Browser --> API
    Browser --> Storage
    Browser --> RPC
    API --> YouTube
    API --> RPC
    Wallet --> Pons
    RPC --> Pons
    Browser --> Explorer

    classDef ui fill:#17123a,stroke:#62f7ff,color:#f4f7ff;
    classDef service fill:#20194d,stroke:#b55cff,color:#f4f7ff;
    classDef chain fill:#082a32,stroke:#50f5a4,color:#f4f7ff;
    classDef external fill:#24152c,stroke:#ff4fd8,color:#f4f7ff;

    class Browser,Storage ui;
    class API service;
    class Pons,RPC,Wallet chain;
    class User,YouTube,Explorer external;

Responsibility by layer

Layer	Components	Responsibility
Presentation	`artifacts/yutok`	Routing, UI, wallet selection, forms, charts, Token Terminal
API	`artifacts/api-server`	YouTube RSS aggregation and Pons token feed
Shared contracts	`lib/api-spec`	OpenAPI source of truth
Shared validation	`lib/api-zod`	Runtime request and response schemas
Generated client	`lib/api-client-react`	React Query hooks and custom fetch
Chain adapter	`artifacts/yutok/src/lib/pons.ts`	ABI, reads, simulation, gas, signing, receipt
Local persistence	Browser `localStorage`	Launch registry created through Yutok
Data sources	YouTube RSS and Robinhood RPC	Public and on-chain data

Data flow diagram

flowchart LR
    subgraph Video["Video discovery"]
        Channels["Curated YouTube channels"]
        RSS["YouTube RSS/Atom feeds"]
        Parse["Parse + validate Shorts"]
        Cache["API cache<br/>5 minutes"]
        Feed["Randomized feed response"]
    end

    subgraph App["Yutok app"]
        UI["Feed UI"]
        Form["Launch form"]
        Registry["Yutok local registry"]
        Terminal["Token Terminal"]
    end

    subgraph Chain["On-chain"]
        Factory["Pons V2 factory"]
        Curve["Bonding curve"]
        Events["Launch / Buy / Sell events"]
    end

    Channels --> RSS --> Parse --> Cache --> Feed --> UI
    UI --> Form
    Form --> Factory
    Factory --> Curve
    Factory --> Events
    Events --> Registry
    Registry --> Terminal
    Terminal --> Factory
    Terminal --> Curve
    Terminal --> Events

Why are there two token data sources?

Yutok intentionally separates:

The Yutok registry, which answers “which tokens were launched from this application?”
On-chain reads, which answer “what is the current state of this token?”

This separation prevents the UI from treating every token in the global Pons V2 factory as a Yutok token.

Token launch flow

sequenceDiagram
    autonumber
    actor Creator
    participant UI as Yutok Launchpad
    participant Wallet as Injected Wallet
    participant RPC as Robinhood RPC
    participant Pons as Pons V2 Factory
    participant Registry as Yutok localStorage

    Creator->>UI: Select a Shorts video
    UI->>UI: Prefill name, symbol, description, and logo
    Creator->>UI: Edit metadata and launch settings
    UI->>RPC: Read launch fee and enabled config
    UI->>RPC: Validate pair, balance, tax, and wallet
    RPC-->>UI: Readiness and economics
    Creator->>UI: Click Launch
    UI->>RPC: Simulate launch / launchAndBuy
    RPC-->>UI: Calldata result or revert reason
    UI->>Wallet: Request transaction confirmation
    Wallet->>Pons: Submit approved transaction
    Pons-->>RPC: Receipt and TokenLaunched event
    RPC-->>UI: Successful receipt
    UI->>Registry: Save token, curve, pair, and tx hash
    UI-->>Creator: Open /token/:address

Important launch behavior

The UI does not treat a transaction return value as the only source of the token address. It parses the TokenLaunched event from the receipt.
For ERC-20 pairs, allowance and approval are handled before launch/buy.
For native ETH pairs, the transaction value includes the launch fee and the initial buy.
Calldata must be simulated before the wallet is asked to sign.
The final calldata must be estimated for gas after all parameters are known.

Pons V2 transaction lifecycle

stateDiagram-v2
    [*] --> Disconnected
    Disconnected --> Connected: connect wallet
    Connected --> WrongNetwork: chain != 4663
    WrongNetwork --> Connected: switch to Robinhood Chain
    Connected --> Checking: open launch form
    Checking --> Ready: reads valid
    Checking --> Blocked: RPC error / config unavailable
    Ready --> Simulating: click Launch
    Simulating --> Rejected: simulation revert
    Simulating --> AwaitingSignature: simulation succeeds
    AwaitingSignature --> Rejected: user rejects
    AwaitingSignature --> Submitted: wallet broadcasts
    Submitted --> Confirmed: receipt status success
    Submitted --> Failed: receipt status failed
    Confirmed --> Registered: parse event + save local registry
    Registered --> TokenTerminal: navigate to token page
    Blocked --> Checking: retry
    Rejected --> Ready: edit and retry
    Failed --> Ready: inspect and retry

Technology stack

Frontend

React 19
TypeScript
Vite
Tailwind CSS v4
Framer Motion
Lucide React
Recharts
Wouter
Viem
TanStack React Query
Radix UI primitives

Backend

Node.js 24
Express 5
TypeScript
Pino and Pino HTTP
Zod
Node's built-in Fetch API

Workspace

pnpm workspaces
OpenAPI
Orval-generated API client
PostgreSQL and Drizzle package available in lib/db
Artifact routing and managed workflows

External data sources

Public YouTube RSS/Atom feeds
Robinhood Chain RPC
Robinhood Chain Blockscout explorer
Injected browser wallets through EIP-1193

Repository structure

.
├── README.md
├── package.json
├── pnpm-workspace.yaml
├── pnpm-lock.yaml
├── tsconfig.json
├── artifacts/
│   ├── yutok/
│   │   ├── package.json
│   │   ├── vite.config.ts
│   │   └── src/
│   │       ├── App.tsx
│   │       ├── main.tsx
│   │       ├── index.css
│   │       ├── components/
│   │       ├── hooks/
│   │       ├── lib/
│   │       │   ├── pons.ts
│   │       │   ├── long.ts
│   │       │   └── yutok-launches.ts
│   │       └── pages/
│   │           ├── Home.tsx
│   │           ├── AppLaunchpad.tsx
│   │           ├── TokenTerminal.tsx
│   │           └── Whitepaper.tsx
│   ├── api-server/
│   │   ├── package.json
│   │   └── src/
│   │       ├── app.ts
│   │       ├── index.ts
│   │       └── routes/
│   │           ├── index.ts
│   │           ├── health.ts
│   │           ├── youtube.ts
│   │           └── pons.ts
│   └── mockup-sandbox/
├── lib/
│   ├── api-spec/
│   │   └── openapi.yaml
│   ├── api-zod/
│   ├── api-client-react/
│   └── db/
├── attached_assets/
└── scripts/
    └── post-merge.sh

Important frontend files

File	Purpose
`artifacts/yutok/src/App.tsx`	Path routing for home, app, token, and whitepaper
`artifacts/yutok/src/pages/Home.tsx`	Landing page composition
`artifacts/yutok/src/pages/AppLaunchpad.tsx`	Feed, launch modal, wallet flow, and Pons launch
`artifacts/yutok/src/pages/TokenTerminal.tsx`	Token detail, market data, trading, and activity
`artifacts/yutok/src/lib/pons.ts`	Pons V2 ABI and chain helpers
`artifacts/yutok/src/lib/yutok-launches.ts`	Yutok token registry
`artifacts/yutok/src/hooks/useWallet.ts`	Wallet discovery, connect, disconnect, and chain switching
`artifacts/yutok/src/index.css`	Design tokens and aurora palette

Important backend files

File	Purpose
`artifacts/api-server/src/index.ts`	Server bootstrap and `PORT` validation
`artifacts/api-server/src/app.ts`	Express middleware, CORS, and `/api` mount
`artifacts/api-server/src/routes/youtube.ts`	YouTube RSS aggregation and caching
`artifacts/api-server/src/routes/pons.ts`	Pons event and market-data reads
`lib/api-spec/openapi.yaml`	API contract source of truth
`lib/api-zod/src/generated/api.ts`	Generated Zod schemas

Environment setup

Prerequisites

Node.js 24 or a compatible runtime.
pnpm.
A modern browser with ES module support.
An EIP-1193-compatible browser wallet for on-chain features.
Access to the Robinhood Chain RPC for on-chain reads and writes.

Install dependencies

pnpm install

The workspace uses minimumReleaseAge in pnpm-workspace.yaml as a supply-chain defense. Do not disable this protection without a clear security reason.

Environment variables

Frontend Vite

Variable	Required	Description
`PORT`	Required by workflow	Vite development server port
`BASE_PATH`	Optional	Artifact base path; usually `/`

API server

Variable	Required	Description
`PORT`	Yes	Express listener port
`NODE_ENV`	No	Controls logger mode
`LOG_LEVEL`	No	Pino logger level; defaults to `info`

DATABASE_URL is required only when using the database/Drizzle package for database operations. The current YouTube feed and Pons endpoints read public sources and chain data directly.

Never place a private key, seed phrase, session credential, or API key in the repository, README, or browser bundle. Use the environment secret manager for sensitive values.

Running the project

Run the frontend

pnpm --filter @workspace/yutok run dev

The frontend is run by the Yutok artifact workflow. When running Vite directly in a terminal, it uses the PORT value from the environment.

Run the API server

pnpm --filter @workspace/api-server run dev

The API server builds the backend and starts the generated output. It requires a valid PORT value.

Run both services in the workspace

The project has separate workflows:

Workflow	Command	Purpose
`artifacts/yutok: web`	`pnpm --filter @workspace/yutok run dev`	Vite frontend
`artifacts/api-server: API Server`	`pnpm --filter @workspace/api-server run dev`	Express API
`artifacts/mockup-sandbox: Component Preview Server`	Mockup sandbox package	Isolated component previews

In the hosted preview, use the artifact path rather than hardcoding a localhost URL into application source.

Developer commands

Typecheck every package

pnpm run typecheck

Typecheck the frontend

pnpm --filter @workspace/yutok run typecheck

Typecheck the API

pnpm --filter @workspace/api-server run typecheck

Build every artifact

pnpm run build

The root command runs typechecking and then builds packages that provide a build script.

Build the frontend only

pnpm --filter @workspace/yutok run build

Check diff whitespace

git diff --check

Regenerate the API client and schemas

When lib/api-spec/openapi.yaml changes:

pnpm --filter @workspace/api-spec run codegen

Do not manually edit generated files as the source of truth. Update the OpenAPI specification first, then run code generation.

Application routing

Yutok uses simple path routing from App.tsx.

Path	Page	Purpose
`/`	`Home`	Landing page and discovery overview
`/app`	`AppLaunchpad`	Shorts feed, wallet, launch form, Tokens, Profile
`/token/:address`	`TokenTerminal`	Market data and trading for a Yutok token
`/whitepaper`	`Whitepaper`	Protocol documentation and risk disclosure

/token/:address accepts an EVM address with a 0x prefix followed by 40 hexadecimal characters.

Supported query parameters

Path	Parameter	Purpose
`/app?tab=tokens`	`tab=tokens`	Open the token list
`/app?tab=profile`	`tab=profile`	Open the creator profile
`/app`	`tab=launch`	Default launch tab

API server

All API routes are mounted below /api.

Health check

GET /api/healthz

Example response:

{
  "status": "ok"
}

YouTube feed

GET /api/youtube/feed?q=shorts&maxResults=20

Parameters:

Parameter	Default	Limit	Description
`q`	`shorts`	1–80 characters	Query label for the API contract
`pageToken`	empty	200 characters	Reserved for pagination
`maxResults`	`100`	1–1000	Maximum number of items

Each response item contains:

{
  "id": "youtube-video-id",
  "title": "Short title",
  "description": "Description",
  "channelTitle": "Channel",
  "channelId": "channel-id",
  "publishedAt": "2026-08-31T00:00:00.000Z",
  "thumbnailUrl": "https://i.ytimg.com/...",
  "views": 0,
  "likes": 0,
  "comments": 0,
  "durationSeconds": 0,
  "url": "https://www.youtube.com/shorts/..."
}

Notes:

comments and durationSeconds may be 0 because they are not available from the RSS data used by the server.
If every feed fails or produces no items, the server returns 502.
Some feeds may fail while items from successful feeds are still returned.
The in-memory cache lasts for the lifetime of the API process.

Pons token feed

GET /api/pons/tokens?limit=20

Filter launches by deployer:

GET /api/pons/tokens?limit=50&deployer=0xYourWalletAddress

Parameters:

Parameter	Default	Limit	Description
`limit`	`20`	1–50	Maximum number of items
`deployer`	empty	EVM address	Filter by deployer wallet

Each response item includes:

tokenAddress
curveAddress
deployerAddress
pairTokenAddress
launchConfigId
graduationThreshold
blockNumber
transactionHash
name
symbol
logo
totalSupply
marketCap
currentPrice
quoteSymbol
priceHistory

This endpoint reads TokenLaunched events and ERC-20/curve data directly from Robinhood Chain. The backend cache lasts approximately 30 seconds.

Error behavior

Condition	Status	Response
Invalid query	`400`	`{ "message": "..." }`
Public feed unavailable	`502`	Feed unavailable
Pons RPC unavailable with no cache	`502`	On-chain data unavailable
Pons RPC fails while cache exists	`200`	Cached response

Contracts and network

Robinhood Chain

Property	Value
Chain name	Robinhood Chain
Chain ID	`4663`
Chain ID hex	`0x1237`
Native currency	ETH
RPC	`https://rpc.mainnet.chain.robinhood.com`
Explorer	`https://robinhoodchain.blockscout.com`

Pons V2 deployments

Contract	Address
Pons V2 factory	`0x7eD598BcEf8bd9Edd8C97A195C6d13f40801EC7e`
Launch and buy helper	`0xe33E9E479dF8802cb0866d5d05258bEc4cF62948`
Fee distributor factory	`0x70e95CC5f03DB2906081E7a8D16e4C4209291507`

Explorer links:

Pons V2 launch surface

The frontend supports reading and using relevant functions such as:

launchFee()
launchConfigCount()
getLaunchConfig()
canLaunch(address)
launchEnabled()
approvedPairTokens(address)
pairTokenEconomics(address)
previewLaunchEconomics(uint256,address)
launchToken(...)
launchAndBuy(...)
TokenLaunched event

The frontend ABI and chain helpers live in:

artifacts/yutok/src/lib/pons.ts

Long.xyz note

Long.xyz is not currently used by the Yutok launchpad. The remaining research and configuration must not be treated as a production-ready write path. Do not construct new calldata by guessing opaque parameters, modules, fees, initializers, or hooks without authoritative verification and successful simulation.

Local launch data model

The browser registry uses this key:

yutok:launches

The record shape is conceptually:

type YutokLaunchRecord = {
  tokenAddress: Address;
  curveAddress?: Address;
  pairTokenAddress?: Address;
  pairSymbol?: string;
  pairDecimals?: number;
  name?: string;
  symbol?: string;
  logo?: string;
  deployerAddress: Address;
  transactionHash: Hex;
  feeSharing?: boolean;
  sourceVideoId?: string;
  sourceVideoUrl?: string;
  createdAt: string;
};

Registry rules

Token addresses are compared case-insensitively.
New launches are inserted at the top.
Duplicate token addresses are removed.
Legacy records from session storage can still be imported.
Verified launches may be preloaded as seed data.
ipfs:// and ipns:// images are normalized to HTTP gateways.
The registry is not a public database and is not proof of ownership.

Adding a registry field

When adding a field:

update the record type;
update the launch writer;
update Tokens, Profile, and Token Terminal consumers;
preserve compatibility with old records;
never store private keys or sensitive data.

Wallet and signing

useWallet.ts manages browser providers and connection state. The normal flow is:

flowchart TD
    Detect["Detect EIP-1193 providers"] --> Choose["User chooses wallet"]
    Choose --> Connect["eth_requestAccounts"]
    Connect --> ChainCheck{"Chain 4663?"}
    ChainCheck -- No --> Switch["wallet_switchEthereumChain"]
    Switch --> ChainCheck
    ChainCheck -- Yes --> Ready["Wallet ready"]
    Ready --> Read["Read on-chain state"]
    Read --> Sim["Simulate final transaction"]
    Sim --> Sign["Wallet confirmation"]
    Sign --> Send["eth_sendTransaction / writeContract"]
    Send --> Receipt["Wait for receipt"]
    Receipt --> Done["Decode event and update UI"]

Wallet safety rules

Never request or accept a seed phrase or private key in the UI.
Do not change chains silently; show clear network state.
Always show the wrong-network state.
Do not call a write method before simulating the final calldata.
Do not hardcode a gas limit from an old transaction.
Estimate gas after final approval and transaction parameters are available.
Wait for the receipt and verify its status before saving a launch.
A connected wallet does not mean that a transaction has been approved.

Market data and Token Terminal

Pons V2 curves use a constant-product model. Conceptually:

x × y = k

In the implementation:

x represents the quote reserve;
y represents the token reserve;
price is derived from quote reserve divided by token reserve;
curve fees and graduation affect trading behavior;
market cap is the quote price multiplied by total supply.

Market cap interpretation

Yutok displays market cap in the quote asset's denomination:

an ETH pair produces a market cap in ETH;
a token pair produces a market cap in that pair symbol;
the number is not automatically a USD market cap;
price and reserves are rapidly changing snapshots.

Trading

Before a buy or sell:

make sure the wallet is connected;
make sure the chain is correct;
make sure the curve has not graduated;
validate that the amount is greater than zero;
perform approval if the pair asset is an ERC-20;
simulate the trade;
calculate minimum output from slippage;
request wallet signature;
wait for a successful receipt.

YouTube feed source

The curated channel list is maintained in:

artifacts/api-server/src/routes/youtube.ts

The source URL format is:

https://www.youtube.com/feeds/videos.xml?channel_id=<CHANNEL_ID>

Feed characteristics

No YouTube API key is required.
Channels are fetched in parallel.
One failed channel does not immediately fail the entire feed.
Items are accepted only when the link contains /shorts/.
Items are deduplicated by video ID.
The response is randomized so the same newest video is not always first.
Successful results are cached in memory for five minutes.

Changing the channel list

When adding or removing a channel:

verify the channel ID;
verify that the source publishes Shorts;
consider content category and quality;
run typechecking;
check /api/youtube/feed;
check the UI for broken thumbnails.

Deployment

The frontend artifact is configured in its artifact configuration file:

artifacts/yutok/artifact configuration

Important settings:

kind: web
preview path: /
static production output: artifacts/yutok/dist/public
production rewrite: /* to /index.html
build command: pnpm --filter @workspace/yutok run build

The API artifact is configured in its artifact configuration file:

artifacts/api-server/artifact configuration

Important settings:

kind: api
path: /api
health check: /api/healthz
production entrypoint: artifacts/api-server/dist/index.mjs
listener port comes from PORT

Pre-publish checklist

Troubleshooting

Blank preview

Confirm that artifacts/yutok: web is running.
Restart the workflow after changing Vite configuration or dependencies.
Check the browser console.
Confirm that PORT and BASE_PATH match the artifact.
Confirm that Vite allows the proxied host.
Confirm that index.html and the production rewrite are available.

API server does not open a port

The API intentionally fails fast when PORT is missing or invalid.

echo "$PORT"
pnpm --filter @workspace/api-server run typecheck

In managed workflows, use the artifact configuration that supplies the port.

Empty YouTube feed

Possible causes:

YouTube RSS is rate-limiting requests;
all channels timed out;
channels have no /shorts/ items in the RSS window;
the network is temporarily unavailable.

The server returns 502 when no item is available. Check API logs for the number of failed feeds.

Pons endpoint returns `502`

Possible causes:

Robinhood Chain RPC timeout;
RPC HTTP error;
provider limits on eth_getLogs;
historical reserve calls are unavailable;
no cached response exists.

The endpoint can return a cached response when one is available.

Wallet is on the wrong network

Switch the wallet to:

Robinhood Chain
Chain ID: 4663
Hex: 0x1237

Do not send a transaction until the chain ID is correct.

Launch simulation fails

Check:

the wallet has enough ETH for the launch fee and gas;
the pair asset is approved;
ERC-20 initial-buy allowance is sufficient;
creator tax is within the factory limit;
token name and symbol are valid;
snipe-tax exemption entries are valid addresses;
launch configuration is still enabled;
the economics read still matches the transaction parameters.

Chart or market cap is empty

Chart data requires:

a valid factory record;
a valid curve address;
readable reserves;
valid total supply and decimals;
an RPC that can serve historical calls.

null market cap does not necessarily mean that the token is missing. It may mean that one of the required data points is not currently available.

Security and risk

Yutok interacts with smart contracts and third-party data. Users must understand the risks before connecting a wallet or signing a transaction.

Wallet risk

Verify the domain and chain.
Review recipient, contract, value, and gas in the wallet.
Use a separate wallet for experimentation when appropriate.
Never share a seed phrase or private key.

Smart-contract risk

Pons V2 is an external protocol dependency.
Contract state can change even when the frontend does not.
Simulation does not eliminate every transaction risk.
A revert reason does not guarantee that the next transaction will succeed.

Market risk

Bonding-curve prices can move quickly.
Liquidity may be limited.
Market cap is not a guarantee of value or the ability to sell.
Slippage can result in lower output than expected.
Graduation may close curve trading.

Content risk

Videos can be removed, restricted, or have their metadata changed.
Thumbnails and descriptions come from third parties.
Using video metadata is not proof of ownership or endorsement.
Creators are responsible for rights to names, images, and content they use.

Data risk

RSS and RPC services can time out or return delayed data.
Browser localStorage can be cleared.
The local registry is not a centralized database.
Use the block explorer to verify important transactions.

Yutok is an interface and data reader. It is not financial advice and does not guarantee the performance, value, liquidity, or success of any token.

Roadmap

Current focus

Keep in-app launches focused on Pons V2.
Strengthen read paths, simulation, gas estimation, registry behavior, and Token Terminal.
Preserve a mobile-first UX centered on Shorts discovery.

Add automated tests for receipt and event decoding.
Improve RPC fallback and historical-read resilience.
Build a registry that can be verified across devices.
Expand activity indexing without mixing external launches into Yutok's own launch list.
Re-enable other launch providers only after their ABI, calldata, simulation, and deployment path are authoritatively verified.

Requirements for a new launch provider

A new provider should appear in the UI only after:

its write ABI is clear;
all modules and parameters are verified;
fee and pair configuration are known;
calldata can be generated without guessing;
simulation succeeds on the target network;
receipt events can be decoded;
the registry and Token Terminal are provider-aware;
a safe fallback remains available if the provider is unavailable.

Contributing

Contribution workflow

Create a clearly named branch.
Understand which artifact the change affects.
Preserve the existing package structure.
Change the source of truth, not generated files manually.
Run the relevant typecheck and build commands.
Run git diff --check.
Check the preview for UI changes.
Explain the risk when a change touches wallets or on-chain transactions.

Commit messages

Use short commit messages that describe the user-visible impact:

feat: add token activity to terminal
fix: handle stale Robinhood RPC responses
docs: expand launch flow documentation

On-chain changes

Any change to contract addresses, ABIs, chain IDs, transaction builders, simulation, gas estimation, or event decoding requires additional review. Do not submit calldata based only on the similarity of historical transactions.

License

The root workspace is licensed under MIT. Review the license for each package and dependency before distributing builds or using third-party assets.

References

_{Yutok · Discover attention. Launch transparently.}

Name		Name	Last commit message	Last commit date
api-server		api-server
attached_assets		attached_assets
lib		lib
mockup-sandbox		mockup-sandbox
scripts		scripts
yutok		yutok
README.md		README.md
logoss.png		logoss.png
package.json		package.json
pnpm-lock.yaml		pnpm-lock.yaml
pnpm-workspace.yaml		pnpm-workspace.yaml
tsconfig.base.json		tsconfig.base.json
tsconfig.json		tsconfig.json

Latest commit

History

Folders and files

Repository files navigation

Yutok

Table of contents

About Yutok

Product principles

Current product status

Active

Temporarily disabled

Current limitations

Key features

1. Landing page

2. Live YouTube Shorts feed

3. Pons V2 launchpad

4. Token Terminal

5. Yutok token registry

Architecture

Responsibility by layer

Data flow diagram

Why are there two token data sources?

Token launch flow

Important launch behavior

Pons V2 transaction lifecycle

Technology stack

Frontend

Backend

Workspace

External data sources

Repository structure

Important frontend files

Important backend files

Environment setup

Prerequisites

Install dependencies

Environment variables

Frontend Vite

API server

Running the project

Run the frontend

Run the API server

Run both services in the workspace

Developer commands

Typecheck every package

Typecheck the frontend

Typecheck the API

Build every artifact

Build the frontend only

Check diff whitespace

Regenerate the API client and schemas

Application routing

Supported query parameters

API server

Health check

YouTube feed

Pons token feed

Error behavior

Contracts and network

Robinhood Chain

Pons V2 deployments

Pons V2 launch surface

Long.xyz note

Local launch data model

Registry rules

Adding a registry field

Wallet and signing

Wallet safety rules

Market data and Token Terminal

Market cap interpretation

Trading

YouTube feed source

Feed characteristics

Changing the channel list

Deployment

Pre-publish checklist

Troubleshooting

Blank preview

API server does not open a port

Empty YouTube feed

Pons endpoint returns `502`