Build on Robin.
Launch and trade onchain.

npm install viem

type TokenMetadata = {
  description: string;
  imageURI: string;
  website: string;
  twitter: string;
  telegram: string;
};

// UTF-8 byte limits
// name:        1-64
// symbol:      1-10
// description: max 500
// imageURI:    max 2048
// website:     max 512
// twitter:     max 512
// telegram:    max 512

createToken(
  string name,
  string symbol,
  TokenMetadata metadata,
  uint8 templateId,
  bytes32 userSalt
) payable returns (
  address token,
  address market
)

createAndBuy(
  string name,
  string symbol,
  TokenMetadata metadata,
  uint8 templateId,
  bytes32 userSalt,
  uint256 minTokensOutRaw,
  address tokenRecipient,
  address refundRecipient,
  uint256 deadline
) payable returns (
  address token,
  address market,
  uint256 tokensOutRaw,
  uint256 grossUsedWei,
  uint256 refundWei
)

marketOfToken(token) -> market
tokenOfMarket(market) -> token

isRobinToken(token) -> bool
isRobinMarket(market) -> bool

launchCount() -> uint256
launchAt(index) -> (token, market)

predictTokenAddress(
  creator,
  userSalt,
  name,
  symbol
) -> token

quoteBuy(uint256 grossInputWei)
  -> BuyQuote

quoteSell(uint256 tokenInRaw)
  -> SellQuote

virtualEthWei()
tokensSoldRaw()
accountedReserveWei()
reserveAt(uint256 qRaw)
maxQRaw()
remainingCurveInventoryRaw()

BuyQuote {
  qBeforeRaw
  qAfterRaw
  tokensOutRaw
  grossInputWei
  grossUsedWei
  curveCostWei
  protocolFeeWei
  creatorFeeWei
  totalFeeWei
  refundWei
}

SellQuote {
  qBeforeRaw
  qAfterRaw
  tokenInRaw
  grossRefundWei
  protocolFeeWei
  creatorFeeWei
  totalFeeWei
  netETHOutWei
}

buy(
  uint256 minTokensOutRaw,
  address tokenRecipient,
  address refundRecipient,
  uint256 deadline
) payable returns (
  uint256 tokensOutRaw,
  uint256 grossUsedWei,
  uint256 refundWei
)

const quote =
  await publicClient.readContract({
    address: market,
    abi: marketAbi,
    functionName: "quoteBuy",
    args: [grossInputWei],
  });

const minTokensOutRaw =
  quote.tokensOutRaw * 9900n / 10000n;

const simulation =
  await publicClient.simulateContract({
    address: market,
    abi: marketAbi,
    functionName: "buy",
    account,
    args: [
      minTokensOutRaw,
      account,
      account,
      deadline,
    ],
    value: grossInputWei,
  });

const hash =
  await walletClient.writeContract(
    simulation.request,
  );

sell(
  uint256 tokenInRaw,
  uint256 minETHOutWei,
  address ethRecipient,
  uint256 deadline
) returns (
  uint256 netETHOutWei
)

const allowance =
  await publicClient.readContract({
    address: token,
    abi: tokenAbi,
    functionName: "allowance",
    args: [
      account,
      market,
    ],
  });

if (allowance < tokenInRaw) {
  const approvalSimulation =
    await publicClient.simulateContract({
      address: token,
      abi: tokenAbi,
      functionName: "approve",
      account,
      args: [
        market,
        (1n << 256n) - 1n,
      ],
    });

  const approvalHash =
    await walletClient.writeContract(
      approvalSimulation.request,
    );

  await publicClient.waitForTransactionReceipt({
    hash: approvalHash,
  });
}

const quote =
  await publicClient.readContract({
    address: market,
    abi: marketAbi,
    functionName: "quoteSell",
    args: [tokenInRaw],
  });

const minETHOutWei =
  quote.netETHOutWei * 9900n / 10000n;

const simulation =
  await publicClient.simulateContract({
    address: market,
    abi: marketAbi,
    functionName: "sell",
    account,
    args: [
      tokenInRaw,
      minETHOutWei,
      account,
      deadline,
    ],
  });

const hash =
  await walletClient.writeContract(
    simulation.request,
  );

TokenCreated(
  indexed token,
  indexed market,
  indexed creator,
  launchId,
  templateId,
  virtualEthWei,
  name,
  symbol,
  metadataHash,
  effectiveSalt
)

Buy(
  indexed buyer,
  indexed tokenRecipient,
  indexed refundRecipient,
  qBeforeRaw,
  qAfterRaw,
  tokenOutRaw,
  grossInputWei,
  grossUsedWei,
  curveCostWei,
  protocolFeeWei,
  creatorFeeWei,
  refundWei
)

Sell(
  indexed seller,
  indexed ethRecipient,
  qBeforeRaw,
  qAfterRaw,
  tokenInRaw,
  grossRefundWei,
  protocolFeeWei,
  creatorFeeWei,
  netETHOutWei
)

Transfer(
  indexed from,
  indexed to,
  value
)

Approval(
  indexed owner,
  indexed spender,
  value
)

createEnabled()
createFeeWei()
protocolFeeBps()
creatorFeeBps()
protocolTreasury()
configChangeDelay()

pendingTradingFees()
pendingCreateFee()
pendingEnableCreation()
pendingProtocolTreasury()

import {
  createPublicClient,
  createWalletClient,
  defineChain,
  http,
} from "viem";

const robinhoodChain =
  defineChain({
    id: 4663,
    name: "Robinhood Chain",
    nativeCurrency: {
      name: "Ether",
      symbol: "ETH",
      decimals: 18,
    },
    rpcUrls: {
      default: {
        http: [
          "https://rpc.mainnet.chain.robinhood.com",
        ],
      },
    },
    blockExplorers: {
      default: {
        name: "Explorer",
        url:
          "https://robinhoodchain.blockscout.com",
      },
    },
  });

const publicClient =
  createPublicClient({
    chain: robinhoodChain,
    transport: http(),
  });

const factory =
  "0x9297877b5E67F7d6A2bE7A3C0AfcdF6c940Cd719";

// Recommended write flow:
//
// 1. Read current protocol state.
// 2. Read a fresh quote.
// 3. Compute slippage protection.
// 4. simulateContract(...).
// 5. writeContract(simulation.request).
// 6. Wait for the receipt.
// 7. Parse confirmed event logs.