ArbiForge documentation

Overview

ArbiForge is a zero-capital token launchpad on Arbitrum One. One transaction deploys a fixed-supply ERC-20, creates its Uniswap V3 pool at the 1% fee tier, places the entire supply in that pool as a single-sided position that is locked forever, and makes the creator the earner of the pool's trading fees. The creator adds no ETH: buyers' ETH becomes the liquidity as the price rises.

What makes it different:

• No liquidity capital. Launching costs a small flat fee plus gas. There is no pool to fund.
• Creators earn on every trade. Each buy and sell pays the pool's 1% fee; 80% belongs to the creator (claimable any time), 20% to the platform — fixed per token at launch.
• Liquidity locked by construction. The position NFT lives in the ForgeLocker, which has no function to remove liquidity — not for the creator, not for the platform.
• Real-world-asset pairs. Price your token in ETH, stablecoins, ARB, tokenized gold (XAUt0) or tokenized stocks (Reality rTokens). Buyers still pay with ETH — the swap routes through the pair asset.
• Clean token. No owner, no tax, no mint, no blacklist, no pause, no proxy. A 30-second anti-sniper window is the only rule.
• No migration. The pool a token launches in is the pool it trades in forever, so it appears in wallets, aggregators and DexScreener from the first block.

Quick start

1. Install a wallet (MetaMask, Rabby, OKX…) and fund it with a little ETH on Arbitrum One for gas (usually under $1; launching itself is free unless the operator sets a fee), plus an optional first buy.
2. Open Launch, fill in name, ticker, logo and links.
3. Pick the pair asset (ETH is the simplest). Every token opens at the same $10,000 market cap. Optionally set a first buy.
4. Review, tick the confirmation box and press Launch. For an ERC-20 pair with a first buy, approve the pair asset first — the button guides you.
5. Share your token page. The token is tradable immediately on the Swap page and anywhere Uniswap V3 is routed.

Wallet & network

The site detects every installed wallet through EIP-6963 and, when configured, WalletConnect for mobile wallets. On a phone the browser itself can't hold a wallet, so the Connect dialog offers one-tap Open in MetaMask / Trust Wallet / Coinbase Wallet links that reopen the current page inside the wallet app's own browser. If your wallet is on another network, the header shows Switch to Arbitrum; one click adds or switches to Arbitrum One (chain ID 42161, RPC https://arb1.arbitrum.io/rpc, explorer arbiscan.io).

Launch wizard

The wizard has three steps. Your draft is kept in this browser only, so you can leave and come back.

Token

Every launch is a LaunchToken with a fixed supply of 1,000,000,000 tokens and 18 decimals. The whole supply is minted once to the factory and goes straight into the pool; dust the position manager can't place is burned. The contract has no owner and no mint function.

Logo, category & profile

Upload a logo in the wizard: your browser crops it to a square, resizes it to 128 px and compresses it (WebP) to a few kilobytes — small GIFs keep their animation — then it is stored on-chain together with the description, links and category. No image server, nothing that can go offline. You can also paste an https:// or ipfs:// link instead. The profile is a JSON document of at most 8 KB in the factory registry and the creator can update it from the token page.

Categories (Meme, AI, Gaming, DeFi, RWA, Community, Culture) power the filters on the Explore page.

Pairs & real-world assets

The pair (quote) asset is what your token is priced in, what sellers receive and the asset most of your creator fees accrue in. Buyers can still pay with ETH: the swap routes ETH → pair asset → your token in one transaction. The Pairs page lists every curated asset with live price, liquidity tier and pool readiness.

Tokenized stocks — Reality rTokens

Reality issues U.S. stocks and ETFs as rTokens on Arbitrum One (rAAPL, rNVDA, rSPY, rGLD, rSGOV…): each token is backed 1:1 by a share held in regulated custody, reserves are attested daily by an independent CPA firm, and dividends are paid in stablecoins.

• Why they work as a pair: rTokens use the ERC-8056 “UI multiplier” model — stock splits change a display multiplier, not on-chain balances — so a Uniswap pool stays consistent. Every listed rToken passed a simulated pool round-trip in our checks: pulled into a contract with transferFrom, paid back out to a brand-new address, exact amounts on every leg.
• Curated set: 17 well-known rTokens appear in the pair picker. rAAPL, rCRCL, rHOOD and rSPCX have Uniswap V3 pools on Arbitrum (still thin); the rest currently trade mainly on Bitget.
• Full catalog: 1,000+ rTokens — every one already held on Arbitrum and pool-safe — are searchable on the Pairs page and in the picker's Stocks tab. Operators refresh it with npm run sync:reality, which re-checks every address on-chain and leaves out rTokens that are paused, delisted, fail the pool round-trip, or that nobody holds on Arbitrum yet (they return once someone withdraws them from Bitget).
• Before you pair: if the rToken has no DEX route, buyers must already hold it (e.g. withdrawn from Bitget to Arbitrum). rTokens may not be offered to U.S. persons, and dividends go to the holder address — a pool contract holding rTokens may not be able to use them. Reality can pause an rToken or freeze individual addresses; a frozen pool would lock the rToken side of its liquidity.

Why some RWAs are “not poolable”

Institutional funds such as BlackRock BUIDL, Franklin Templeton BENJI or Spiko's T-bill funds only move between KYC-whitelisted wallets — a transfer to a new pool reverts. They are listed for information only.

RWA-specific risks

• Issuers can freeze addresses; a frozen pool would trap the quote side of the liquidity.
• Some products are not available to U.S. persons or other jurisdictions — check the issuer's terms.
• Buyers coming from ETH need a route to the pair asset; thin pair liquidity means extra slippage.

Liquidity: the single-sided pool

The factory creates the token's Uniswap V3 pool at the 1% fee tier (tick spacing 200), initializes it at the starting price you chose and mints one liquidity position that holds the whole supply on one side of the price:

starting price    = starting market cap ÷ 1,000,000,000
position range    = from the first tick above the starting price to the maximum price
position contents = 1,000,000,000 tokens, 0 pair asset

Every buy moves the price up into the range and leaves the buyer's ETH (or pair asset) in the pool; every sell moves it back down. In effect the position is a bonding curve that lives inside a real Uniswap pool — there is no separate curve contract and no migration. A buy of x (after the 1% fee) at a market cap M receives about x ÷ (M + x) of the supply.

The position NFT is minted directly to the ForgeLocker. The locker has no function that removes liquidity, transfers the NFT or changes a token's fee split — the liquidity is locked forever.

Creator fees

Uniswap charges 1% on the input of every swap through the pool. Those fees accrue to the locked position and are split when collected:

• Claim any time. The token page shows the claimable amount (an eth_call of collectFees) and what was paid out so far. Anyone can trigger collectFees(token) — the money always goes to the creator recipient and the platform, never to the caller.
• Hand over the stream. The current creator recipient can move future fees to another wallet with setCreatorRecipient (e.g. a team multisig). Nobody else can — including the platform.
• The fee is enforced by the Uniswap pool itself, so it applies no matter which router or aggregator a trader uses, and it is not a token tax: the token contract stays 0% tax on scanners.

Creator first buy

Optionally, the creator can buy their own token inside the launch transaction, right after the pool is created — before any other wallet can trade. The factory swaps through Uniswap's SwapRouter02 and sends the tokens to the creator.

• Paid in the pair asset (ETH for ETH pairs; approve the ERC-20 first for other pairs).
• Capped at 10% of the supply; the launch reverts if the first buy would receive more.
• Fully transparent: recorded in the registry (firstBuyTokens), emitted as a FirstBuy event and shown in the token page's safety checklist.

Anti-sniper window

At the end of the launch transaction (after the first buy) the token starts a 30-second window in which no wallet may hold more than 1% of the supply. The pool, the locker, the position manager and the factory are exempt, so selling is never blocked.

• The window expires automatically and can never be extended, shortened or switched back on — the token has no owner.
• During the window a single buy is limited to ~1% of the supply; routers count too, so a large buy through any router reverts until the window ends.

After launch

Your token page (/token?address=…) shows price, market cap, liquidity and 24h volume, plus:

• Chart — candles or a line, price or market cap, 5m to 1d, drawn from the pool's own Swap events (works from the first trade, no indexer).
• Trades and Holders — read from the chain; holders are rebuilt from the token's Transfer events and labelled (pool, locker, creator, you).
• Your position — balance, value and P&L from your trades in this pool.
• Creator fees — claimable and paid-out amounts, the Claim button and, for the recipient, Change recipient.
• Watchlist — star tokens to follow them on Explore (stored in your browser).
• Edit profile — description, logo, links (creator only).
• Share — your phone's share sheet, or a link with one-click posts to X and Telegram on desktop.

Your Portfolio lists the tokens you hold with their live value, the tokens you launched, the creator fees they earned and what you can claim now. Every wallet also has a public profile at /portfolio?address=0x…; token pages link to their creator's.

Heat & the Forged milestone

Every token shows a heat meter: its fully diluted market cap measured against the Forged milestone (default $50,000, set in config.js). Stages: Spark (< 33%), Flame (33–66%), Blaze (66–99%) and Forged (≥ 100%). Forged tokens get their own row and filter on the Explore page. Heat is a display metric computed from the live pool price — nothing migrates and trading never pauses.

Live feed & analytics

The Forge feed under the header streams the latest buys and sells across all launch pools. The Analytics page shows launches per day, daily trading volume, creator and platform fees paid out, pair mix, top markets and top creators by fees earned.

Swap & routing

The swap page queries two sources in parallel and executes the better quote:

1. ArbiForge Router (on-chain). The front-end discovers Uniswap V3 pools (all fee tiers) and Uniswap/SushiSwap/Camelot V2 pairs between your tokens and routing hubs (WETH, USDC, USDT0, ARB and the pair asset of any launched token), then quotes the candidate routes in one Multicall3 call via ForgeRouter.quote. Routes can mix venues and hops, e.g. ETH → ARB (0.05%) → NEW (1%), and run atomically through ForgeRouter.swap. Fresh launch pools are quoted even before their first trade.
2. KyberSwap aggregator for established tokens across dozens of Arbitrum DEXes. Built transactions are only sent if they target KyberSwap's known router address.

ForgeRouter is ownerless and fee-less, holds no funds between transactions, only calls DEX routers fixed at deployment, and validates that every leg starts with the token the previous leg produced.

Slippage & price impact

Price impact is how much your trade moves the pool price (estimated by comparing your quote with a tiny probe trade). Slippage tolerance (default 0.5%; the token page's quick trade uses at least 1%) is how much worse than the quote you accept before the transaction reverts. Remember that launch pools charge a 1% fee on top. The swap button turns red above 15% impact.

Fees

Security model

What nobody can do

• Remove a launch's liquidity or transfer its position — the locker has no such function.
• Add a tax, blacklist holders, pause transfers, mint or upgrade a launched token — the template has no owner and no such code.
• Change a token's fee split after launch, or redirect a creator's fees without the creator recipient's own signature.
• Trade before the creator's first buy, or extend the anti-sniper window.

What the platform operator can do

• Change the launch fee (≤ 0.05 ETH) and the fee recipient; change the platform share for future launches (≤ 30%); pause new launches; recover tokens accidentally sent to the factory.
• Ownership transfers are two-step (Ownable2Step). A multisig owner is recommended.

Engineering

• Built on OpenZeppelin Contracts v5 (ERC20, ERC20Permit, ERC20Burnable, Ownable2Step, ReentrancyGuard, SafeERC20) and the canonical Uniswap V3 deployment on Arbitrum One.
• Solidity 0.8.28, optimizer on. Unit tests run against the official Uniswap V3 bytecode (100% line coverage of the launch contracts); integration tests run against a fork of Arbitrum One with real Uniswap V3, including ETH-, ARB- and XAUt0-paired launches. Slither static analysis reports no high- or medium-severity issue.
• Both token orderings in the pool (token0 or token1) are handled and tested.

Smart contracts

Key functions

// ForgeFactory
launch(LaunchParams p) payable returns (address token, address pool)
updateMetadata(address token, string metadata)            // creator only
getLaunches(uint256 offset, uint256 limit) view            // registry paging
getLaunchesByCreator(address creator) view · getLaunchView(address token) view
launchFee() · protocolFeeBps() · locker() view

// ForgeLocker
collectFees(address token) returns (creatorToken, creatorQuote, protocolToken, protocolQuote)   // anyone
setCreatorRecipient(address token, address recipient)    // current creator recipient only
positionOf(address token) view · earningsOf(address token) view

// ForgeRouter
quote(address tokenIn, uint256 amountIn, Leg[] legs) returns (amountOut)   // call via eth_call
swap(tokenIn, tokenOut, amountIn, minAmountOut, Leg[] legs, recipient, deadline) payable

LaunchParams = name, symbol, metadata, quoteToken (0 = ETH), sqrtPriceX96 (start price as √(quote base units per token base unit) × 296, as if the token were token0), firstBuy (0 = none), minFirstBuyOut. For ETH pairs msg.value = launch fee + firstBuy; otherwise msg.value = launch fee and the first buy is pulled in the quote token.

Token contract

LaunchToken extends OpenZeppelin's ERC20, ERC20Burnable (holders can burn their own tokens) and ERC20Permit (gasless approvals, EIP-2612). It has no owner. On top of that it only adds the anti-sniper window: pool, limitsEndAt, maxWallet (1% of supply) and isLimitExempt, set once by the factory through activate and enforced in the transfer hook only while block.timestamp < limitsEndAt.

Every launch uses identical bytecode. The operator verifies one launched token with npm run verify:token; Arbiscan then recognizes the rest as a “similar match”.

Addresses

Platform contracts on this deployment:

External contracts used (all verified on-chain):

Deploy the platform

Two ways — both deploy ForgeFactory (which creates its ForgeLocker) and ForgeRouter:

A. From the browser (no command line)

1. Host the site (see Hosting) or run it locally with node tools/serve.mjs.
2. Open Operator console, connect the wallet that should pay for deployment, set owner, fee recipient, launch fee and the platform share of trading fees.
3. Click Deploy with my wallet and confirm two transactions.
4. Download deployments.js, replace web/assets/js/deployments.js, and re-upload the site.

B. With Hardhat

cd contracts
npm install
cp .env.example .env        # fill PRIVATE_KEY, LAUNCH_FEE, PROTOCOL_FEE_BPS, FEE_RECIPIENT, OWNER
npm test                    # unit tests
npm run preflight           # read-only: balance, owner, fees, Uniswap V3 wiring, bytecode size
npm run deploy:arbitrum     # preflight → deploy → read-back checks → rewrites web/assets/js/deployments.js

The deploy script refuses to send anything if the preflight finds an error. Use a dedicated deployer wallet and set OWNER to a Safe multisig. After the first launch, run npm run verify:token so every launched token shows verified source on Arbiscan.

Rehearse on a local fork first

cd contracts
npm run node:fork                            # terminal 1: fork of Arbitrum One on :8545
npm run deploy:local                         # terminal 2: deploy to the fork
npm run serve                                # terminal 3: open http://127.0.0.1:8787
# add a network in your wallet: RPC http://127.0.0.1:8545, chain ID 42161,
# and import a Hardhat test account (never use these keys on mainnet)

The fork uses an archive-capable RPC (FORK_RPC_URL, or arbitrum.gateway.tenderly.co by default). Restore deployments.js (or deploy to mainnet) before publishing — the release check blocks a site that still points at localhost.

Moderation

Contracts are permissionless — anyone can launch. This website decides what it lists: add a token address to MODERATION.hidden in web/assets/js/config.js and it disappears from the home page, Explore, the live feed and the token picker; its page still opens with a warning. When BRAND.links.email (or telegram) is set, token pages show a Report button that sends visitors' reports there. Launches whose name or ticker copies a well-known asset (ETH, USDC, ARB, the curated pairs, MODERATION.protectedNames) automatically carry a Look-alike label, and creators see the warning in the wizard.

Emergency actions

The owner (a Safe) can pause new launches, change the fee recipient and transfer ownership. Nobody — owner included — can withdraw liquidity, change an existing token's fee split or stop trading. The step-by-step runbook is in DEPLOY-CHECKLIST.md.

Verify contracts

Get a free Etherscan API key (one key covers Arbiscan), put it in contracts/.env as ETHERSCAN_API_KEY, then:

npm run verify:arbitrum

The script reads contracts/deployments/arbitrumOne.json. After an in-browser deployment, download that file from the Operator console first.

Configuration & branding

Hosting the website

The site is plain HTML, CSS and JavaScript modules — no build step. Upload the web/ folder to any static host:

• Vercel / Netlify / Cloudflare Pages: create a project, set the output/root directory to web, deploy.
• GitHub Pages: publish the web folder (or copy it to docs/).
• IPFS: upload the folder (e.g. with Pinata or Filebase) for a censorship-resistant mirror.
• cPanel / any web server: upload the contents of web/ to public_html.

Pages must be served over HTTP(S) — opening index.html directly from disk won't load the JavaScript modules.

Before every upload

node tools/prepare-release.mjs

It writes social-preview and favicon tags into every page, generates robots.txt, sitemap.xml and the security headers with a Content-Security-Policy (web/_headers for Netlify and Cloudflare Pages, vercel.json for Vercel), then runs a pre-release checklist: contracts deployed, no localhost RPC, domain, social links, WalletConnect project ID, private RPC, fresh whitepaper PDF and token catalog. It exits with an error while anything blocking is left. On hosts that ignore those files (GitHub Pages, cPanel, IPFS) set the headers yourself.

Developer guide

Everything the site shows can be read directly from the contracts — no API key, no backend.

Network

Read the registry

// ethers v6
const factory = new ethers.Contract(FACTORY, ForgeFactoryABI, provider);
const count = await factory.launchCount();
const page  = await factory.getLaunches(0, 25);        // LaunchView[] incl. name, symbol, supply, metadata
const one   = await factory.getLaunchView(tokenAddress); // reverts with UnknownToken for non-ArbiForge tokens
const meta  = JSON.parse(one.metadata || "{}");          // { description, logo, website, x, telegram, category }

Quote and swap

const router = new ethers.Contract(ROUTER, ForgeRouterABI, signer);
// legs: [{ router: UNISWAP_V3_SWAPROUTER02, path: packed(WETH, 500, ARB, 10000, TOKEN) }]   // launch pools use the 1% (10000) tier
const out = await router.quote.staticCall(NATIVE, amountIn, legs);   // eth_call, not a transaction
await router.swap(NATIVE, token, amountIn, out * 995n / 1000n, legs, me, deadline, { value: amountIn });

V3 paths are packed (address, uint24 fee, address, …); V2 paths are packed addresses. NATIVE = 0xEeee…EEeE.

Events

Changelog

• v2.1 — Free launches by default. Portfolio and public creator profiles; share sheet and Report button on token pages; one-tap open-in-wallet links on phones; the Reality catalog lists only rTokens a pool can hold and someone already holds on Arbitrum; keyboard and screen-reader fixes.
• v2.0 — Zero-capital launches on Uniswap V3: the whole supply goes into a single-sided 1% pool locked forever in the new ForgeLocker; creators earn 80% of every trade's fee (claimable from the token page); fixed 1B supply, ownerless token, 30-second anti-sniper window; first buy capped at 10% of supply; free launches (launch fee 0, adjustable up to 0.05 ETH). Token page: on-chain candle chart, holders, your position, creator fees; watchlist; Analytics: daily volume and fees paid. npm run verify:token. The v1 Uniswap-V2 contracts are archived in contracts/legacy-v2.
• v1.2 — Reality tokenized stocks & ETFs as pair assets: 17 curated rTokens plus the full on-chain-verified catalog (3,000+), Stocks tab in the picker, catalog search on the Pairs page, npm run sync:reality. xStocks removed (rebasing balances).
• v1.1 — Creator first buy in the launch transaction · on-chain logo upload · categories · Forge feed (live trades) · heat meter & Forged milestone · Explore with trending/volume sorting, pair filter and list view · token page chart, trades and quick trade box · Analytics page · Terms & privacy · developer guide.
• v1.0 — One-transaction launch with LP lock/burn · RWA & ecosystem pairs · ForgeRouter mixed-venue swaps · explorer, token pages, docs, whitepaper, operator console.

FAQ

Disclaimer

ArbiForge is open-source, non-custodial software. Tokens are created by independent users; listing or launching a token here is not an endorsement. Crypto assets are volatile and may lose all value. Real-world-asset tokens are issued by third parties under their own terms and jurisdictional restrictions. Nothing on this site is financial, legal or tax advice. Make sure launching or trading tokens is legal where you live. ArbiForge is not affiliated with Offchain Labs, the Arbitrum Foundation or any asset issuer listed.