Every idea gets a seat. Here's the whole story.

How seats and fair launches on Argus work, what each fee is, and how to read Keystone straight from the chain.

Overview

Keystone is a place to give ideas a seat. Someone pitches a coin, supporters take equal seats at the same USDC price, and when the last seat fills the coin launches on Argus. The pooled USDC makes the opening buy and the coins are split equally, so the pitcher gets exactly what every supporter gets.

Seat money is held by the Keystone contract on Arc until the pitch launches or you get a refund. No person, including the Keystone team, can take it out. Every seat, refund and launch is a transaction your wallet asks you to approve.

Key facts

No one gets a bigger slice: no team allocation and no early buyers.
Seats are paid in USDC, Arc's own currency, and are refundable until the last one fills.
Names, tickers and pictures can be copied. Always check the coin's contract address.
Coins can be volatile, illiquid, or lose all value.

Words we use

Pitcher: The person who creates the pitch. They hold the first seat and pay the same as everyone.
Supporter: Anyone who takes a seat in someone else’s pitch.
Seat: One equal spot in a pitch. Everyone pays the same USDC price, and everyone gets the same amount of the coin.
Seat holders: The pitcher and all supporters together.
Buy and sell tax: A fee of 1–10% on each trade of the coin, set by the pitcher, along with where it goes.
Launch: When the last seat fills: the coin is created on Argus and shared equally between all seat holders.
Bond: The price point an Argus coin climbs toward after launch. The launched list shows how far each coin has come.

How it works

Every idea on Keystone follows the same three steps.

01
Pitch
The pitcher sets the name, ticker, picture, description, links, one USDC seat price for everyone, how many supporters are needed and the tax. Creating the pitch pays for the pitcher's own seat.
02
Fill
Supporters take seats at the same price, one per wallet. Anyone can leave and get their USDC back until the last seat fills.
03
Launch
The last seat launches the coin on Argus in the same transaction. The pooled USDC makes the opening buy and every seat gets an equal share.

After launch, the coin trades on Argus against USDC in a Uniswap v4 pool. Its liquidity is locked in the pool for good, following Argus' own rules.

Seats and refunds

One seat per wallet: Every seat costs the same. The pitcher holds the first seat.
Leave a seat: Supporters can leave any time before the pitch fills and get their seat price back. The pitcher can't leave; they cancel instead.
Cancel: The pitcher can cancel before it fills. Up to 25 seats are refunded automatically.
Big pitches: In a cancelled pitch with more than 25 seats, each supporter collects their own refund with one click on the pitch page or their profile.
No deadline: Pitches stay open until they fill or are cancelled.
Network fees: Every transaction, including leaving a seat, costs a small Arc network fee, paid in USDC.

The launch

Taking the last seat does everything in one transaction: the coin is created on Argus, the pooled USDC (minus Keystone's fee) makes the opening buy, and the coins are shared equally between the pitcher and every supporter. Because it all happens at once, nobody can buy ahead of the seat holders.

Up to 25 seats: Coins are sent to every seat holder automatically at launch.
More than 25 seats: Each seat holder claims their share with one click on the pitch page or their profile.
Pot size limits: Argus only accepts opening buys within a range. The Keystone contract reads that range live (potLimits()), and the Create pitch page tells pitchers how to adjust if a pot is too small or too big.
Launch setup: Every Argus coin needs a small piece of setup (a "salt") that your browser works out in the background while you fill in the form. If Argus changes, the last seat works it out again before sending.
Before the last seat: Keystone checks that Argus will accept the launch. If not, nothing is sent and the pitch stays refundable.

After launch, seats can no longer be refunded. The coin trades on Argus and anyone can buy or sell it.

Why charts may show seat holders as "dev"

The Keystone contract launches the coin and shares the opening buy equally in the same transaction. Some charts treat whoever launched a coin as the "dev", and the wallets that received coins at launch as dev wallets too. So when seat holders buy or sell, the chart may show "dev bought" or "dev sold". These are supporters who paid the same seat price as everyone, not a team allocation. Keystone has no team allocation.

Creating a pitch

Keystone follows the same rules as creating a coin on Argus, so every pitch can launch there without problems.

Field	Rule
Picture	PNG, JPG or WebP. Shown as a square, like on Argus; other shapes are cropped to a square from the center.
Name	2 to 32 characters.
Ticker	Capital letters and numbers, 2 to 10.
Description	Up to 280 characters.
X, Telegram, website	Optional.
Seat price	At least 1 USDC, with at most 6 decimals.
Supporters	1 to 500, not counting the pitcher.
Buy and sell tax	1% to 10% each.
Where the tax goes	Any split between creator, burn, holders, liquidity and lock, adding up to 100%.

The pooled amount must be within the pot limits (at least about 5.5 USDC today). The Create pitch page checks all of this and shows a live preview of the coin before anything is sent.

Fees

Keystone fee: A flat 1 USDC per launch, taken from the pooled USDC when the coin launches.
Buy and sell tax: 1–10% each way on trades of the coin, split the way the pitcher chose.
Argus fees: Argus' own 1% base fee on trades, and its share of the tax, set by Argus.
Network fees: Arc's network fee on each transaction, paid in USDC.

Everything left after Keystone's fee makes the opening buy. The fee is shown on every pitch page and on the Create pitch form.

Buy and sell tax

The pitcher sets a buy tax and a sell tax of 1% to 10% when creating the pitch. They're fixed once the coin launches. Every trade pays the tax plus Argus' 1% base fee, all in USDC. Argus keeps 30% of that, and the rest is split the way the pitcher chose:

Creator: Paid to the creator wallet (the pitcher's own wallet unless they choose another). Claimed on Argus.
Holders: Paid out in USDC to everyone holding the coin.
Burn, liquidity, lock: Removes coins from supply, adds to the pool, or locks value, following Argus' rules.

Wallets and profile

Keystone works with MetaMask, Rabby, Coinbase Wallet, phone wallets and many more through WalletConnect. Your wallet needs to be on Arc; Keystone offers to add and switch to it for you. You'll need a little USDC on Arc for seats and network fees.

Your profile shows the pitches you created, the seats you hold, the coins you launched together with others, and any refunds or coins waiting to be collected. Anyone's profile can be opened from their address.

Risk disclosures

Coins launched through Keystone are user-created and experimental. Check the pitch, the pitcher and the coin's contract address before taking a seat.

Prices can move quickly and liquidity can be thin.
Similar names and pictures can belong to unrelated coins.
Smart contracts, wallets, RPCs and explorers can fail. The Keystone contract has not been independently audited.
Keystone depends on Argus and Arc, which Keystone doesn't control.

Read the full risk notice and terms of use. Nothing here is financial advice.

Developers

Read Keystone straight from Arc.

Everything on the site comes from the contract. Index its events or call its view functions directly.

Network

Network: Arc
Chain ID: 5042
Native asset: USDC (18 decimals as native value; the ERC-20 view at 0x3600…0000 has 6)
Public RPC: https://rpc.mainnet.arc.io
Explorer: arc-scan.org
Launches on: Argus (Portal #8, Uniswap v4 pools paired with USDC)

Contracts

Deployed addresses on Arc. Keystone's contracts are immutable; new versions ship at new addresses and will be listed here.

Keystone launch contractPitchLaunchStrategyArgus

0xa94DDFF2D2A0DdC97c1a68dc2D4386B04DBDab31

Argus portalused for every launch

0xeed7559B8A6ABf64427dc41Cb5cc6400109C5D93

Uniswap v4 StateViewlive prices of launched coins

0xF3334192D15450CdD385c8B70e03f9A6bD9E673b

The refund escrow (holds refunds a wallet couldn't receive) is readable from the launch contract with feeEscrow().

Onchain events

Index these events from the Keystone launch contract to follow every pitch.

Event	When
`Pitched(uint256 indexed pitchId, address indexed pitcher, uint256 pricePerVote, uint256 votesNeeded)`	A pitch is created
`Validated(uint256 indexed pitchId, address indexed validator, uint256 totalContributors)`	Someone takes a seat
`Withdrawn(uint256 indexed pitchId, address indexed contributor, uint256 amount)`	Someone leaves a seat or collects a refund
`Cancelled(uint256 indexed pitchId, uint256 refundedCount)`	The pitcher cancels
`Launched(uint256 indexed pitchId, address indexed token, address indexed hook, uint256 totalRaised, uint256 buyAmount, uint256 tokensBought)`	The last seat launches the coin
`Claimed(uint256 indexed pitchId, address indexed contributor, uint256 tokenAmount)`	Coins are sent or claimed
`RefundCredited(uint256 indexed pitchId, address indexed contributor, uint256 amount)`	A refund couldn't be sent directly and waits in the escrow
`DividendsCollected(uint256 indexed pitchId, uint256 amount)`	USDC holder payouts for coins still waiting to be claimed are collected
`QuotePaid(uint256 indexed pitchId, address indexed contributor, uint256 amount)`	A seat holder receives those USDC payouts

Topic hashes (topic0)

Pitched             0xed3e443fd4584167bf396a48039a8aeeff4bed641fa571678e0fcc470a2d8ef5
Validated           0x3f5de75f46fea09c0695945ee17c3418151c21fa30d9ebd9a0753234f0abbe03
Withdrawn           0xcf7d23a3cbe4e8b36ff82fd1b05b1b17373dc7804b4ebbd6e2356716ef202372
Cancelled           0xa761582a460180d55522f9f5fdc076390a1f48a7a62a8afbd45c1bb797948edb
Launched            0xcb4e4ddff7fd792ecca275f4deba871a6477ac278910f9b967a62cc1910f7034
Claimed             0x4ec90e965519d92681267467f775ada5bd214aa92c0dc93d90a5e880ce9ed026
RefundCredited      0xe1872a97721553a4eba79b8a15644854ed8617ac50609d0893e90f8197a7213d
DividendsCollected  0x5782ac1ced11b624b62c3489011375132e6a011de7c7b953c96465707d218364
QuotePaid           0x4fcc2e55f3ae48ac70e98b78ecc2452f5d88626216de8dc50b9b8a23be53e008

Backfill history in bounded block ranges; public RPCs time out on wide eth_getLogs queries. Arc's RPC doesn't accept calls from browsers, which is why the site goes through its own relay (/api/rpc/arc).

Reading pitch state

Every pitch can be read directly from the launch contract.

Read a pitch with ethers v6 (Node)

import { JsonRpcProvider, Contract, formatEther } from "ethers";

const provider = new JsonRpcProvider("https://rpc.mainnet.arc.io", 5042);
const keystone = new Contract("0xa94DDFF2D2A0DdC97c1a68dc2D4386B04DBDab31", [
  "function pitchCount() view returns (uint256)",
  "function getPitch(uint256) view returns (address token, string name, string symbol, uint256 pricePerVote, uint256 votesNeeded, uint256 contributorCount, uint256 tokensBought, bool launched, bool cancelled, uint256 creatorTaxBps, address creatorFeeRecipient)",
  "function getPitchMeta(uint256) view returns (string description, string imageUrl, string twitter, string telegram, string website)",
  "function getPitchTaxes(uint256) view returns (uint16 buyTaxBps, uint16 sellTaxBps, uint16[5] alloc)",
  "function getPitchLaunch(uint256) view returns (address token, address hook, address escrow)",
  "function getContributors(uint256) view returns (address[])"
], provider);

const id = 0;
const p = await keystone.getPitch(id);
const t = await keystone.getPitchTaxes(id);
const seats = Number(p.votesNeeded) + 1;            // the pitcher holds one seat
console.log(p.name, p.symbol, formatEther(p.pricePerVote), "USDC per seat");
console.log(Number(p.contributorCount), "of", seats, "seats taken");
console.log("Tax:", Number(t.buyTaxBps) / 100, "% buy,", Number(t.sellTaxBps) / 100, "% sell");
if (p.launched) console.log("Coin:", p.token, "Hook:", (await keystone.getPitchLaunch(id)).hook);

Seats in a pitch: votesNeeded + 1, because the pitcher holds the first seat.
Prices: pricePerVote is native USDC with 18 decimals, so formatEther gives USDC.
Tax split: alloc is in basis points, in Argus' order: creator, burn, holders, liquidity, lock.
creatorTaxBps: On Arc this returns the buy tax; read getPitchTaxes for both legs.

Support

Questions, ideas or something not working? Reach Keystone on X at @Keystonearc. Keystone will never ask for your private key or recovery phrase, or ask you to send funds to fix a problem.

Terms and attribution

Keystone is an independent project built on Arc. It is not operated by, affiliated with, or endorsed by Argus, Arc or Circle. Coins launched through Keystone are created on Argus and follow Argus' own rules, fees and contracts.

Onchain data is public and free to read. Keystone is provided as is, without warranties. See the terms of use and risk notice.