Follow the money.

What GO FUND is

GO FUND is a launchpad. You create a token, you name a fundraiser, and the token's creator fees are paid to the GO FUND treasury instead of to you. Trading the token is what generates those fees, so activity on the market becomes funding for the cause.

It is a thin layer. GO FUND does not run a chain, does not hold your keys, and does not take custody of anything. It builds one transaction, points its fee field at a fixed address, and asks your wallet to sign it. Everything after that happens on Pons, a launchpad protocol on Robinhood Chain.

The system, end to end

A launch is a single transaction:

1. You fill in the name, ticker and fundraiser link.
2. The page reads the current launch terms from the factory and pins them into the call.
3. It simulates the transaction against a node. If it would revert, you never sign.
4. Your wallet signs. The factory deploys the token and its curve.
5. From that point, every trade pays a creator fee to the treasury address.

The network

Robinhood Chain is an Ethereum layer 2 built for real-world assets — tokenised equities alongside ordinary tokens. GO FUND runs on its mainnet.

The launchpad adds the network to your wallet for you if it is missing, and switches to it before building the transaction.

Where Zerohash fits

Zerohash is a regulated crypto infrastructure provider. It gives banks, brokerages and payment companies a single integration into several chains, and handles liquidity, compliance, custody and settlement on their behalf. Since July 2026 its clients can reach Robinhood Chain through it.

Contracts and addresses

The treasury is an externally owned account. It is not a contract, so there is no upgrade path and no admin function behind it.

Launch economics

These values are read live from the factory each time the launch page loads.

Pons also applies a decaying anti-snipe tax to buys in the first seconds after a launch. The account that launched the token is exempt from it.

The launch call

With no developer buy the page calls launchToken(params, 0, 0x0). With one it calls launchAndBuy(...) and sends the launch fee plus the buy amount as value. What goes into params:

How the fee lock works

The claim that a creator cannot take the fees back is worth more than a promise, so it was checked against the deployed contracts rather than the documentation.

1. The fee recipient lives on the token's bonding curve, which exposes setCreatorFeeRecipient(address) — selector 0x7b04ea62.
2. Simulating that call on a live curve from the token's own deployer reverts. So does calling it from an unrelated address, and from the current recipient. The curve accepts only the factory.
3. The factory exposes a pass-through, setCreatorFeeRecipient(address,address) — selector 0xe102c9aa. Simulating that as the token's creator also reverts, and so does simulating it as the current recipient.

A second, narrower limit: this holds for tokens launched through this site. Anyone can call the Pons factory directly and name their own wallet. Making that impossible for everyone would require GO FUND to deploy its own factory wrapper.

Wallets and signing

Connection is handled by Privy, restricted to browser wallets — MetaMask or Rabby. There is no email login and no embedded wallet, because a launch needs a wallet that already holds ETH on Robinhood Chain.

Signing is strictly non-custodial. GO FUND is a static site: it holds no keys, runs no signing server, and has no way to move a token or a fee after launch. The only secret involved is your own, and it never leaves your wallet.

How Explore is built

The Explore page has no database behind it. In your browser it reads TokenLaunched logs from the factory, fetches each launch transaction, decodes its input, and keeps only those whose creatorFeeRecipient is the treasury. What you see is derived from chain data every time the page loads.

It scans recent blocks in windows and caps how many transactions it decodes, so a very old fund may not appear. An empty list means no token has yet been launched with the treasury as its fee recipient — not that the page failed.

Verify a fund yourself

1. Open the token on the explorer and find the transaction that created it.
2. Decode that transaction's input against the factory ABI below.
3. Read params.creatorFeeRecipient. For a real GO FUND launch it equals the treasury address.
4. Read params.creatorTaxBps for the trading fee, and params.socials.website for the fundraiser the creator declared.

The fundraiser link is supplied by whoever launched the token. GO FUND does not verify that a fundraiser is genuine, that its owner knows about the token, or that they endorse it.

Errors you may hit

Limits and risk

• Buying a token is not a donation. It is a trade, and it may lose value, including all of it.
• A token is not a share in a fundraiser and carries no claim over any money raised.
• Nothing here is investment, legal or tax advice, and no contribution here is tax deductible.
• The bonding curve, the fee logic and the anti-snipe rules are Pons's, not GO FUND's. They can change on their side.
• Creator fees accrue to the treasury. Moving them onward to a fundraiser is an operational step, not something the contract performs by itself.

ABI reference

struct Socials {
  string twitter; string telegram; string discord;
  string website; string farcaster;
}

struct TokenParams {
  string name; string symbol; string logo; string description;
  Socials socials;
  address creatorFeeRecipient;
  uint16  creatorTaxBps;
  bool    buybackEnabled;
  bytes32 expectedEconomics;
  bytes32 salt;
}

function launchToken(TokenParams params, uint256 launchConfigId, address pairToken)
  payable returns (address token, address curve);

function launchAndBuy(TokenParams params, uint256 launchConfigId, address pairToken,
                      uint256 quoteIn, uint256 minTokensOut, address recipient,
                      address[] snipeTaxExemptions)
  payable returns (address token, address curve, uint256 tokensOut);

function launchFee() view returns (uint256);
function maxCreatorTaxBps() view returns (uint16);
function previewLaunchEconomics(uint256 configId, address pairToken) view returns (bytes32);

event TokenLaunched(address indexed token, address indexed curve, address indexed deployer,
                    address pairToken, uint256 launchConfigId, uint256 graduationThreshold);

Launch a funded token