Skip to content
Robinhood Chain 4663
famdotfun · SDK

Build on famdotfun in TypeScript.

You write a few lines, you launch, trade, boost and read coins from your own app, bot or agent. The SDK wraps the contracts on Robinhood Chain with typed calls, quotes before every trade and refuses a swap without a floor.

Reading only? The read API needs no code at all. Driving it from an AI agent? See the MCP server.

Install

coming soon
Package@famdotfun/sdk 0.1.0, TypeScript, ESM, built on viem
StatusBuilt and tested in the famdotfun repo. Not on npm yet: install comes soon.
ChainRobinhood Chain, chain id 4663. Every write is a transaction you sign.
Source of truthThe contracts. The SDK's ABIs are generated from the same build that is deployed, so it cannot drift from them.

The package is not published yet. When it is, this is the line, and this page will say so:

npm install @famdotfun/sdk viem

Set up a client

viem

You pass a viem public client to read and a wallet client to write. The addresses come from the environment, the same ones the site and the keeper use.

import { createPublicClient, createWalletClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { robinhood, createHoodClient, createDirectClient, MAINNET_V8, MAINNET_V8_DIRECT } from "@famdotfun/sdk";

const publicClient = createPublicClient({ chain: robinhood, transport: http() });
const walletClient = createWalletClient({
  chain: robinhood, transport: http(),
  account: privateKeyToAccount(process.env.MY_KEY as `0x${string}`),
});

const hood = createHoodClient({ publicClient, walletClient, addresses: MAINNET_V8 });
const direct = createDirectClient({ publicClient, walletClient, addresses: MAINNET_V8_DIRECT });

Keep the key in your own secret store. The SDK never sends it anywhere; it only signs.

Launch straight to a pool

the default

You name the coin and two valuations, you get a coin trading in its own locked Uniswap v4 pool in the same block. Pick what the coin is for with the split, or make it a cashback coin.

// a cashback coin: traders pay 0.21% to the platform and 0.3% to the pool, nothing to the creator
const { hash } = await direct.launch({
  name: "Hood Fam", symbol: "FAM",
  tickStart: -207200, tickBond: -184200,   // from directTicks({ openFdv, bondFdv, ... })
  cashback: true,                          // both taxes must be 0 on a cashback coin
});

// a creator coin: 0.49% of every trade plus your tax, all to you
await direct.launch({
  name: "Mine", symbol: "MINE", tickStart: -207200, tickBond: -184200,
  buyTaxBps: 100, sellTaxBps: 100,
  allocations: { creatorBps: 10_000, buybackBps: 0, dividendsBps: 0, liquidityBps: 0, lpRewardsBps: 0 },
});

directTicks turns valuations into ticks for the side the coin sorts into. The opening tax of the first three seconds runs on every launch.

Launch on a curve

graduates

You pick a preset and a split, the coin sells on a bonding curve and moves into a locked pool when it sells out. Half the graduation fee buys the coin back out of its new pool and burns it, half buys $FAM and burns it.

const { hash } = await hood.launch({
  name: "Curve Coin", symbol: "CURVE", configId: 0,
  feeSplit: { stakersBps: 0, buybackBps: 2_000, liquidityBps: 0, creatorBps: 8_000 },
});
const { token, curve } = await hood.launchResult(hash);

Buy and sell

floored
// on a curve: quote first, then buy with a floor under the quote
const { tokensOut } = await hood.quoteBuy(curve, 10n ** 17n);
await hood.buy(curve, 10n ** 17n, { minTokensOut: (tokensOut * 99n) / 100n });

// in a direct pool: the client quotes and sends the floor itself
await direct.swap({ token, side: "buy", amountIn: 10n ** 17n, slippageBps: 100 });

Boost battles

hourly

You buy boosts for a coin, it climbs the hour's battle. Boosts stack with everyone else's, and the three coins with the most sit on top of the board until the hour ends. Half of every boost buys $FAM and burns it, half pays that hour's traders.

const { price, hour } = await hood.boostTerms();      // wei per boost, the contract's hour
await hood.boost(token, 10);                          // ten boosts for this hour
await hood.boost(token, 5, { nextHour: true });       // or line up the next one

const top = await hood.boostTop();                    // [{ rank, token, boosts }, ...]
const mine = await hood.boostsOf(token);

Read a coin

no wallet
const launch = await hood.getLaunch(token);            // curve, creator, pair, fee split
const state = await hood.getCurveState(launch.curve);  // sold, reserve, phase

const row = await direct.getLaunch(token);              // a direct coin: hook, splitter, locker
const taxes = await direct.taxes(row.hook);             // { buyBps, sellBps, snipeBps, cashback, ... }

Reference

0.1.0
CallWhat it does
createHoodClientThe curve machine, the Vault, boosts and the bridge: launch, buy, sell, finalize, stake, claim, boost, read.
createDirectClientThe direct machine: plan and launch a coin straight into its pool, buy and sell on it, read its taxes and its five roads.
MAINNET_V8, MAINNET_V8_DIRECTThe version 8 contracts famdotfun.com runs on, built in: an install needs no environment.
addressesFromEnvThe same set from the HOOD_* environment variables, for the testnet or a fork.
boost(token, count, { nextHour })Buys boosts for a coin at count times the boost price. Half burns $FAM, half pays that hour's traders.
boostTop(hour?)The hour's top three, most boosted first, as the contract keeps them.
boostsOf(token, hour?)One coin's boosts in an hour.
launch({ ..., cashback })On the direct client: a cashback coin is never charged the creator's 0.49% and carries no tax.
taxes(hook)What a direct coin's trade pays right now, the opening tax left, and whether it is a cashback coin.

Questions? hello@famdotfun.com. updated 23 October 2026