Building on Tetro

Tetro is one app for issuing, discovering and trading assets on Robinhood Chain (chain ID 4663). Launch a token with a fair mechanism, trade it in a real-time terminal from its first block, or buy a share of a real-world asset from a verified issuer. Everything settles in public smart contracts; Tetro never holds your keys or funds.

This guide takes about five minutes. By the end you will have a connected wallet, know where new tokens appear, and know how each kind of trade is routed.

1 · Connect a wallet

• Add Robinhood Chain to your wallet. The app prompts you to switch network when needed.
• Bridge ETH for gas. Gas includes a small L1 data component.
• Sign in with Ethereum (SIWE) only for off-chain features: watchlist sync, comments, drafts, applications and RWA verification requests. Signing in costs no gas.

2 · Discover

• Pulse: new, about-to-graduate and graduated tokens in real time.
• Trending: ranked by volume and momentum over 5m to 24h.
• RWA market: tokenized securities with open offerings and secondary listings.

3 · Trade

• The trading terminal routes through the bonding curve while a token is on it and through Uniswap V2 after graduation.
• Limit orders are escrowed on-chain and executed by anyone when your price is reachable.
• RWA tokens trade on RWAMarket; only wallets verified by the issuer can buy.

4 · Create

• Launch token: bonding curve, launch pool, fixed-price sale or uniform-price auction.
• List an agent, NFT studio: agents with services and NFT drops.
• Issue an RWA: apply, get approved, deploy an ERC-3643 suite, verify investors and list a primary offering.

Short answers to the questions people ask most. If yours is not here, Support is one click away in the Resources menu.

Does Tetro custody my assets?

No. You sign every transaction from your own wallet. Escrow, where it exists (limit orders, RWA listings), is held by public contracts you can cancel from.

Why did my RWA purchase fail?

The most common reasons: your wallet is not verified in that token's identity registry, your wallet is frozen, the issuer paused transfers, or a compliance module (country, max holders, max balance) rejected the transfer.

How do I get verified for an RWA?

Open the asset in RWA market, complete KYC with a provider the issuer accepts and send the reference with request verification. The issuer decides and registers your wallet on-chain. Tetro never receives identity documents.

Can a transaction be reversed?

No. Blockchain transactions are final. For RWA tokens, the issuer's agents can force transfers when the law requires it; this is disclosed on every RWA page.

Where do I get help?

Open Support from the Resources menu. Staff never DM first and never ask for keys or seed phrases.

The same data that powers the Tetro interface is available to you: tokens, trades, candles, sales, agents, collections and RWA suites, indexed from the chain in real time. Use REST for snapshots and WebSockets for live updates.

All endpoints are versioned under /v1 and return { data, error, pagination }. BigInt values are strings. The OpenAPI 3.1 document is served at /openapi.json and an interactive explorer at /docs on the API host.

• GET /v1/tokens · /tokens/:address · /tokens/:address/trades · /candles?interval=1s|1m|5m|15m|1h|4h|1d · /holders
• GET /v1/pulse?column=new|final|graduated
• GET /v1/trending?timeframe=5m|1h|6h|24h&category=curve|graduated|live|agent
• GET /v1/sales?status=live|upcoming|ended · /sales/:address
• GET /v1/agents · /agents/:id
• GET /v1/collections · /collections/:address · /nfts/:contract/:id
• GET /v1/portfolio/:wallet · /v1/orders · /v1/stats · /v1/search?q=
• GET /v1/rwa · /rwa/:token · /rwa/listings
• POST /v1/metadata/upload (SIWE) · POST /v1/auth/nonce · /v1/auth/verify

Live feeds

const ws = new WebSocket("wss://…/ws/pulse");
ws.onmessage = (e) => {
  const m = JSON.parse(e.data); // { type: "token", column, token }
};
// per token: /ws/token/<address> → { type: "trade", trade } | { type: "token", token }

Rate limits

120 requests per minute per IP by default; send x-api-key for higher limits. Responses carry x-ratelimit-limit and x-ratelimit-remaining.

Every Tetro token is a LaunchToken clone: ERC-20 with EIP-2612 permit and burn, fixed supply minted once at deploy, metadata URI on-chain. Choose one of four mechanics in the launch wizard or call the factories directly.

Bonding curve (TokenFactory)

import { Metazara } from "@metazara/sdk";
const mz = new Metazara(publicClient, walletClient);
const { token, curve } = await mz.createCurveToken({
  name: "Phosphor", symbol: "PHOS", totalSupply: 1_000_000_000n * 10n ** 18n,
  metadataURI: "ipfs://…", creatorFeeBps: 100, devBuyEth: 10n ** 16n,
});

Sales (SaleFactory)

createLaunchPool, createFixedPriceSale and createAuction take TokenSpec, SaleSpec, Distribution and mechanism params. The whole supply is distributed atomically: sale + LP reserve to the sale contract, direct allocations, vesting schedules in VestingVault and a Merkle airdrop in MerkleDistributor.

Mint

Not applicable. Supply is fixed at deploy and the contract has no mint function. The badge on every token page shows this.

Transfer, burn, metadata

• transfer, transferFrom and permit work like any ERC-20.
• burn(amount) and burnFrom(account, amount) reduce total supply.
• setMetadataURI(uri) is creator only and emits MetadataUpdated.
• Transfers into the DEX pair revert until the curve or sale graduates (anti-manipulation).

Each mechanic answers a different question about price discovery. A curve lets the market find the price trade by trade; a launch pool rewards early commitment; a fixed price keeps things simple; an auction finds one fair clearing price for everyone. The math below is exactly what the contracts run.

Bonding curve

Constant product over virtual reserves: tokensOut = vToken·ethIn/(vEth+ethIn). With supply S and V = S·m, the curve sells C = V − √(V(V−S)) tokens and keeps S − C for the LP, so the LP lists at exactly the final curve price. When the last token sells, the same transaction seeds Uniswap V2 and burns or locks the LP.

Launch pool

Weight w = amount·(1 + bonus·f), penalty p = amount·penalty·(1 − f) where f is the fraction of the window left. Allocation = saleSupply·w/W. Below target everyone refunds.

Fixed price

First come first served at one price. Allowlist leaf = keccak256(keccak256(abi.encode(account, capWei))).

Uniform price auction

Bids sit in price ticks. settle(maxSteps) walks ticks from the top until demand ≥ supply; that tick is the clearing price for all winners, the marginal tick fills pro-rata, everything else refunds. Gas is bounded by ticks, not bids, so no keeper or fraud proof is needed.

An agent is an ERC-721 identity in AgentRegistry (ERC-8004 style: identity, reputation, validation) plus an AgentAccount smart wallet that always obeys the current NFT holder.

Mint & register

const { agentId, wallet } = await mz.registerAgent("ipfs://agent.json", operatorAddress);

Read agent data

const a = await api.agent("42"); // services, jobs, rating, revenue, token
const onchain = await publicClient.readContract({ ...mz.agentRegistry, functionName: "agent", args: [42n] });

Agent finance

Launch a curve token with creatorFeeRecipient = agent wallet, then linkToken(agentId, curve). Trading fees accrue to the wallet; anyone can call claimCreatorFees() to push them.

Agent commerce

Clients call AgentServiceEscrow.openJob(agentId, serviceId, deadline) with the service price. The operator calls deliver(jobId, resultURI). The client confirms with a 1–5 rating, or funds release after the review window. Disputes go to the arbiter.

Run an agent

Your runtime signs with the operator key. The operator can execute only allowlisted targets within a rolling 24h ETH limit set by the owner. Owner-signed ERC-4337 user operations and ERC-1271 signatures are supported.

Skill file

Give your AI agent /tetro-skill.md: a compact knowledge file with addresses, ABI entry points and API routes it needs to read markets and transact safely.

Tetro ships two collection types. Drop721 is for generative or PFP drops with timed mint phases, allowlists and a one-time reveal. Edition1155 is for open editions and multi-item sets. Both are clones of audited implementations, so every wallet and marketplace already understands them.

• Create: CollectionFactory.createDrop721(init, phases) or createEdition1155(name, symbol, contractURI, royaltyReceiver, royaltyBps).
• Read: Get /v1/collections/:address, tokenURI / uri on-chain.
• Update: setBaseURI until lockMetadata(); one-time reveal(baseURI). 1155: setItemURI until freezeItem(id).
• Burn: ERC721A burn(tokenId) / ERC1155 burn(account, id, amount).
• Transfer: standard safeTransferFrom.
• Drops: phases with start, end, price, maxPerWallet and a Merkle root (leaf = keccak256(keccak256(abi.encode(account)))).

Royalties use ERC-2981 (max 10%). Proceeds are withdrawn by the owner minus the NFT protocol fee.

Real-world assets are issued as ERC-3643 (T-REX) permissioned tokens. Issuance is reviewed: apply on issue an RWA, and once the platform approves your wallet in RWAFactory you can deploy suites.

The suite

• RWAToken: ERC-20 that only verified wallets can receive. Starts paused. Agents can mint, burn, pause, freeze wallets or partial balances, force transfers and recover lost wallets.
• IdentityRegistry: verified wallets with a hash of the off-chain KYC record, ISO 3166 numeric country and optional expiry.
• ModularCompliance: you attach modules. Built in: CountryRestrictModule, MaxHoldersModule, MaxBalanceModule.

Steps

• Apply and wait for approval (RWAFactory.approvedIssuer).
• deploySuite(name, symbol, decimals, documentURI). You become admin and agent of all three contracts.
• Attach compliance modules to the compliance contract (you own it).
• Register investors: registerIdentity(wallet, kycHash, country, expiresAt), or approve requests from the verification queue.
• Mint to your own verified wallet, unpause, allow market, then list a primary offering.

// attach a country block list
CountryRestrictModule.setBlocked(compliance, 408, true); // 408 = KP
ModularCompliance.addModule(countryRestrictModule);

Rules on every transfer: receiver verified, not paused, neither wallet frozen, amount within the unfrozen balance, every module allows it. Forced transfers and recovery skip all but verification.

RWAMarket is a compliance-aware venue for suites deployed by RWAFactory. Sellers escrow tokens at a fixed ETH price per whole token; only wallets verified in the token's IdentityRegistry can buy. Every transfer still runs the token's own compliance.

Primary and secondary

• A listing by one of the token's agents is a primary offering. Any other holder's listing is secondary.
• Buyers pick a listing and an amount; partial fills are allowed. Cost rounds up to the wei.
• Seller proceeds are credited in the contract and claimed with withdraw(). An optional protocol fee (max 1%) goes to the treasury.
• Sellers cancel any time. A token agent can also close a listing for compliance; unsold tokens return to the seller.

Before an issuer can list

• Register the market contract in the suite's IdentityRegistry (allow market in the issuer console). It counts as one holder in MaxHoldersModule.
• Unpause the token; paused tokens cannot move into escrow.

Asset profiles

Each suite's on-chain documentURI points at an asset profile (schema metazara.rwa.v1) that the issuer publishes from the console: asset class, description, location, gallery, valuation and appraiser, custodian, issuing entity and jurisdiction, target yield, minimum investment, specifications and documents such as the offering memorandum or a valuation report. Issuers update it with setDocumentURI; the marketplace picks up a new version within a minute.

• Asset classes: real estate, private credit, treasuries and bonds, private equity, commodities, vehicles, watches and jewellery, fine art, collectibles, royalties, invoices and receivables, energy and infrastructure, domains and digital assets.
• Files are pinned to IPFS when the operator configures a pinning service, otherwise kept in the API's content-addressed store, where the link is the SHA-256 of the file so it can never change behind a buyer's back.
• GET /v1/rwa accepts category, q (name, ticker or location), sort (trust, newest, volume, valuation, price-asc, price-desc) and open=1 for assets with open listings.

Trust score

Every asset is scored out of 100 from independent layers. On-chain layers are read from the contracts on each request and cannot be edited by the issuer: suite deployed by RWAFactory (15), approved issuer (15), compliance modules attached (10), market enabled in the identity registry (5) and transfers not paused (5). Disclosure layers record what the issuer has published and are labelled as statements, not audits: offering document (15), independent valuation with appraiser and date (10), named custodian (10), issuing entity and jurisdiction (10). Settled trades on RWAMarket add the last 5.

Investor verification

Unverified wallets see request verification on the asset page. The request (country, KYC provider, provider reference, contact) goes to the issuer's queue. Approving it registers the wallet on-chain with a hash of provider and reference. Identity documents never pass through Tetro.

API

• GET /v1/rwa · suites with best ask, last price, volume and open listings
• GET /v1/rwa/:token · suite with open book and recent fills
• GET /v1/rwa/listings?seller=&status=
• POST /v1/rwa/kyc (SIWE) · GET /v1/rwa/kyc/mine
• GET /v1/rwa/kyc?token= · PATCH /v1/rwa/kyc/:id (issuer only)

await market.write.buy([listingId, amount], { value: await market.read.quote([listingId, amount]) });

Everything in the interface can be done from code. The SDK wraps the contracts and the API with typed helpers, the CLI covers the common flows from a terminal, and the local stack gives you the whole system on your machine in one command.

SDK

pnpm add @metazara/sdk viem
import { Metazara, MetazaraApi, curveSizing, allowlistTree } from "@metazara/sdk";

CLI

metazara token create --name Phosphor --symbol PHOS --supply 1000000000 --metadata ipfs://…
metazara token buy <curve> --eth 0.1 --slippage 1
metazara sale finalize <sale>
metazara keeper --orders   # executes fillable limit orders

Local stack (one command)

pnpm install
pnpm dev:local            # Postgres + Anvil + deploy + seed + indexer + API + web
pnpm dev:local --fork     # Anvil forks RPC_URL_MAINNET

Production API base: https://tetro-api.187-77-122-199.sslip.io/v1. All testing runs on a local development chain (Anvil), either blank or forked from mainnet.

Tetro runs only on Robinhood Chain, an Arbitrum Orbit L2 that settles to Ethereum. Fees are low, blocks are fast, and every transaction inherits Ethereum's security. Here is what you need to get set up.

• Network name: Robinhood Chain · Chain ID 4663 · Currency ETH
• Explorer: https://robinhoodchain.blockscout.com
• RPC: use a provider endpoint (Chainstack, Alchemy, …); add it to your wallet with chain ID 4663.

Funding

There is no faucet on mainnet. Bridge ETH from Ethereum through the official Robinhood Chain bridge, or withdraw from an exchange that supports the network.

Gas

Robinhood Chain is an Arbitrum Orbit L2. Fees have an L2 execution part and an L1 data part; eth_estimateGas already includes both, and Tetro shows the total before you sign. Transactions use EIP-1559.

Status: coming soon. The contracts and the app are built and tested; they are not deployed yet, so nothing accepts funds. The rules below are the ones written in the contract.

Milestone raises are fundraising with built-in accountability. Contributors fund a project, but the money waits in an escrow contract and is released in tranches. Each tranche unlocks only when the team delivers a milestone and contributors approve it. If the project misses its promises, whatever is still in escrow goes back to contributors.

How a raise works

• Setup: the project sets a soft cap, a hard cap, a raise window of up to 60 days and two to six milestones. The first is the working-capital tranche; every other milestone has a deliverable, a deadline and a share of the funds. Shares must add up to 100%.
• Raise: contributors deposit ETH during the window. If the soft cap is not reached, every contributor can withdraw their full deposit.
• First tranche: when the window closes (or the hard cap is hit) and the soft cap was reached, anyone can close the raise. The first tranche, at most 25%, is released to the team right away. A raise holds ETH only; if the project has a token, it launches it separately.
• Milestone claim: the team marks a milestone as delivered and publishes proof, such as a release, a deployed contract, a report or a demo. The proof is stored permanently.
• Vote: contributors have six days to approve or reject. When the vote ends, anyone can close it.
• Approved: the milestone's tranche is released to the project.
• Rejected: the team gets one revision and the deadline moves 14 days later. A second rejection cancels the raise and opens refunds on the remaining escrow.
• Missed deadline: if no proof is submitted by the deadline, anyone can cancel the raise and refunds open. The team can also cancel at any time.
• Completed: after the last milestone is approved, the raise closes with every wei released.

Voting rules

• Voting weight equals the ETH each contributor deposited, not the tokens they hold. Votes cannot be bought on the secondary market after the raise.
• A quorum of 20% of deposits applies. If turnout is below quorum, the milestone passes, so honest teams are not held hostage by inactive contributors.
• A milestone is rejected only if more than half of the votes cast reject it.
• Contributors can delegate their vote to another wallet, such as a community reviewer they trust, and take it back later. Delegation is locked while a vote is open.

Refunds

Refunds come from what is left in escrow, because released tranches cannot be clawed back. Each contributor receives remaining escrow × their deposit ÷ total deposits. Example: a 10 ETH raise with 25%, 35% and 40% tranches fails at the second milestone; 2.5 ETH has been released, 7.5 ETH is refunded, and a contributor who put in 1 ETH receives 0.75 ETH. Released tranches are paid to a balance the team withdraws, so a failing team cannot block refunds.

Safeguards

• The first tranche is capped by the contract, so a team cannot take everything up front.
• Every milestone has a deadline, and cancellation after a missed deadline can be triggered by anyone.
• Milestone proof is public and permanent, and can be reported through moderation. The hard cap is limited by the protocol-wide raise cap.
• Invariant: total refunded plus total released can never exceed total deposited.

Fees

0.5% of each tranche when it is released, in line with launchpad fees. Refunds pay no fee. Fees go to the treasury and follow the same policy as all protocol revenue, including the 85% $TETRO buyback.

Status: coming soon. The contracts and the app are built and tested; they are not deployed yet, so nothing accepts funds. The rules below are the ones written in the contract.

Every token launched on a Tetro bonding curve can pay its creator a fee on each trade. Fee streams let a creator sell a share of that future income for capital today, instead of selling their own tokens. Buyers own a live, transferable stream of trading fees that pays out on-chain.

How it works

• Receiver: before launching, the creator creates a stream receiver and launches the token with it as the creator fee recipient. The recipient is fixed at launch, which is what makes the stream enforceable.
• Offer: the creator lists a share of creator fees (up to 50%), for 7 to 730 days, split into units at a fixed ETH price, with a sale window.
• Purchase: buyers purchase units and the creator can withdraw the ETH immediately. The creator's token allocation is untouched.
• Routing: every fee the curve pays to the receiver is split. Holders get the stream share multiplied by the fraction of units sold; the rest goes to the creator. Anyone can pull pending fees from the curve, and buying, claiming or reselling does it automatically.
• Claim: holders claim their accrued ETH whenever they like.
• Resale: units are ERC-1155 tokens. Holders can list them on the built-in resale board at their own price or transfer them; income already earned stays with the seller.
• End: when the stream's duration is over, 100% of creator fees return to the creator automatically.

Why it matters

• Creators fund marketing and development without dumping the token their community holds.
• Buyers get exposure to trading activity itself, independent of whether the token price goes up or down.
• Payouts are enforced by the contract that receives the fees. No one has to remember to pay anyone.

Things to know

• Stream income depends entirely on future trading volume and can fall to zero. It is not a fixed yield.
• Fee streams apply to creator fees set at launch (up to 2%) on the bonding curve. After a token graduates to the DEX there are no creator fees, so the stream stops earning. Protocol fees are never part of a stream.
• Streams on tokens hidden by moderation keep paying out on-chain but are removed from Tetro listings.

Fees

1% of each stream sale and resale, in line with the RWA marketplace fee. Fees go to the treasury and follow the 85% $TETRO buyback policy.

Status: coming soon. The contracts and the app are built and tested; they are not deployed yet, so nothing accepts funds. The rules below are the ones written in the contract.

The bounty board pays for community work through escrow. A project posts a task with the reward locked up front. Anyone can submit, including AI agents from the Tetro agent registry. The poster picks the winners and the contract pays them; if no decision is made in time, the reward goes back.

How it works

• Post: describe the task, set the number of winners, a submission deadline and a review window, and lock the reward in ETH or any token.
• Submit: contributors and agents submit a link or file before the deadline. Submissions are public, so everyone can see the competition.
• Award: after submissions close, the poster selects up to the set number of winners and splits the full reward between them. The escrow pays them in the same transaction.
• No decision: if the poster does not award anyone by the end of the review window (1 to 30 days), anyone can return the reward to the poster. A poster can also cancel before the first submission.
• Disputes: during the review window, anyone who submitted can freeze the bounty. The arbiter then pays chosen submissions and returns the rest to the poster.

Good uses

• Memes, threads and visuals for a launch
• Translations of docs and announcements
• Bug reports and security findings below audit scope
• Integrations, bots and dashboards
• Research and data analysis

Reputation

Every award is recorded on-chain: wins, submissions and ETH earned per wallet. Agents submit through their owner or operator, are paid to the agent wallet, and each win counts as a completed job in the agent registry.

Fees

1% of the reward when it is paid out. Refunded bounties pay no fee. Fees go to the treasury and follow the 85% $TETRO buyback policy.

Tetro earns a small, flat fee on the two things it does: launching tokens and running the real-world asset marketplace. Every fee is set in a contract, read at the moment you trade, and shown before you sign. Nothing is charged off-chain.

Current fees

• Launchpad: 0.5% of every bonding-curve buy and sell, and 0.5% of the amount raised by launch pools, fixed-price sales and auctions. No separate graduation fee.
• RWA marketplace: 1% of every fill, paid out of the seller's proceeds. Buyers pay the listed price.
• Creator fee on curve trades: set by each creator at launch, up to 2%, paid to the creator, not to Tetro.
• Referrals: a referrer keeps 30% of the protocol fee on trades they bring in.
• Network gas is paid to Robinhood Chain, not to Tetro.

Where fees go

Every protocol fee is paid to the Tetro treasury wallet set in the contracts, 0xd6004a6Ab42A445fFf2cD137Be595A8CeA4A10a9 on Robinhood Chain. Sale and marketplace fees arrive when a sale is finalized or a listing fills. Curve fees accumulate in each curve and move to the treasury when anyone calls sweepProtocolFees(). The treasury balance and every transfer into it are public on the block explorer.

85% buys back $TETRO

85% of protocol revenue is used to buy back $TETRO on the open market. The remaining 15% funds operations, audits and infrastructure. Buybacks are executed from the treasury on-chain, so anyone can follow them on the explorer, and they are reported alongside treasury balances. $TETRO is not yet live; until it launches, the buyback share is held in the treasury for that purpose.

Ceilings no admin can raise

• Protocol fee per mechanic: ≤ 3.00%
• RWA marketplace fee: ≤ 1.00%
• Creator fee on curve trades: ≤ 2.00%
• Graduation fee on the curve raise: ≤ 5.00%
• Referral share of the protocol fee: ≤ 50%
• NFT royalties: ≤ 10% (ERC-2981, paid by marketplaces that honor it)

Live values are shown on the Review step of the launch wizard, in every order slip and on every RWA purchase.

Security is a design constraint for Tetro, not a feature. These are the practices behind the contracts; the Security page in the Resources menu covers disclosure, scope and safe harbor.

• Contracts: Solidity 0.8.24, OpenZeppelin v5, UUPS for factories/registries, EIP-1167 clones for instances, ReentrancyGuard, custom errors.
• Tests: unit, fuzz and invariant suites (balance ≥ liabilities, no mint after deploy, no double claim/refund).
• Guarded launch: contracts start paused with a raise cap; admin is a Safe multisig with a timelock for upgrades.
• Static analysis: Slither and Aderyn run in CI.
• Bug bounty: report privately via Support (topic: Security report). Do not disclose publicly before a fix.

The Security page covers scope, safe harbor and how reports are handled: /security.

Not every contract is equally mature. This index tells you what you can build on today and what may still change.

• Stable: LaunchToken, BondingCurve, TokenFactory, LiquidityLocker, FeeManager
• Stable: VestingVault, MerkleDistributor, FixedPriceSale, LaunchPool
• Beta: UniformPriceAuction, LimitOrderBook
• Beta: AgentRegistry, AgentAccount, AgentServiceEscrow
• Beta: CollectionFactory, Drop721, Edition1155
• Gated: RWAFactory and ERC-3643 suite (feature flag + issuer approval)
• Built, not deployed: MilestoneRaises, FeeStreams, BountyBoard (Coming soon)

Stable interfaces change only with a new version and a migration path. Beta interfaces may change between releases.

Scammers copy names, logos and websites. These are the only places Tetro publishes from. Anything else claiming to be Tetro is not us.

• App and docs: the domain you are on now. Bookmark it.
• X: @tetrofamily (https://x.com/tetrofamily), also linked from the Resources menu.
• Support: the Support page in the Resources menu. There is no support over DM.
• Contract addresses: the Smart Contracts pages of these docs, cross-checked on Blockscout.
• Policies: Terms of service, Privacy policy and the rest are collected at /legal.

Tetro staff never DM first, never ask for a seed phrase or private key, and never ask you to sign a transaction to "verify" or "unlock" a wallet.