How It Works & Protocol Reference LOCKEY

0xad827b8769af2ee1f1daabe1d3632fbd92475a236001baf1b0fc541ae488facf

0x0e6586f818d103e43bbea35a671f1b7e6d8454866f959af81988f61e452b4a73

0xbea68ab0c22ead8d2f0d2a03d8854ec4ea4d7cccddc1bb3c61bf3c8c6624a56e

import { createPublicClient, http, parseAbiItem } from "viem";

const client = createPublicClient({
  chain: {
    id: 4663,
    name: "Robinhood Chain",
    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
    rpcUrls: { default: { http: ["https://rpc.mainnet.chain.robinhood.com"] } },
  },
  transport: http(),
});

// Query all token creation logs from the Factory
const launches = await client.getLogs({
  address: "0x7eD598BcEf8bd9Edd8C97A195C6d13f40801EC7e",
  event: parseAbiItem(
    "event TokenLaunched(address indexed token, address indexed curve, address indexed deployer, address pairToken, uint256 launchConfigId, uint256 graduationThreshold)"
  ),
  fromBlock: "earliest",
  toBlock: "latest",
});

// Determine trade direction from emitted event
const side = event.eventName === "CurveBuy" ? "buy" : "sell";
const trader = side === "buy" ? args.buyer : args.seller;
const volumeEth = Number(args.quoteIn || args.quoteOut) / 1e18;

import { parseAbi } from "viem";

// Every launched ERC-20 token is self-describing onchain
const tokenAbi = parseAbi([
  "function name() view returns (string)",
  "function symbol() view returns (string)",
  "function decimals() view returns (uint8)",
  "function totalSupply() view returns (uint256)",
  "function metadataURI() view returns (string)",
]);

const [name, symbol, decimals, totalSupply] = await Promise.all([
  client.readContract({ address: tokenAddress, abi: tokenAbi, functionName: "name" }),
  client.readContract({ address: tokenAddress, abi: tokenAbi, functionName: "symbol" }),
  client.readContract({ address: tokenAddress, abi: tokenAbi, functionName: "decimals" }),
  client.readContract({ address: tokenAddress, abi: tokenAbi, functionName: "totalSupply" }),
]);

// Resolve the Bonding Curve address from the Factory
const curveAddress = await client.readContract({
  address: "0x7eD598BcEf8bd9Edd8C97A195C6d13f40801EC7e",
  abi: parseAbi(["function getCurve(address token) view returns (address)"]),
  functionName: "getCurve",
  args: [tokenAddress],
});

const factoryAbi = parseAbi([
  "function tokenRecords(address token) view returns (address token, address curve, address creator, address quoteToken, uint256 createdAt)",
]);

const record = await client.readContract({
  address: "0x7eD598BcEf8bd9Edd8C97A195C6d13f40801EC7e",
  abi: factoryAbi,
  functionName: "tokenRecords",
  args: [tokenAddress],
});

const curveAbi = parseAbi([
  "function getCurrentPrice() view returns (uint256)",
  "function getMarketCap() view returns (uint256)",
  "function getProgress() view returns (uint256)",
  "function getReserves() view returns ((uint256 virtualQuoteReserve, uint256 virtualTokenReserve, uint256 realQuoteReserve, uint256 realTokenReserve))",
]);

const [priceScaled, marketCapInQuote, progressBps, reserves] = await Promise.all([
  client.readContract({ address: curveAddress, abi: curveAbi, functionName: "getCurrentPrice" }),
  client.readContract({ address: curveAddress, abi: curveAbi, functionName: "getMarketCap" }),
  client.readContract({ address: curveAddress, abi: curveAbi, functionName: "getProgress" }),
  client.readContract({ address: curveAddress, abi: curveAbi, functionName: "getReserves" }),
]);

// Price in USDC per token (divided by 1e18)
const priceUsdc = Number(priceScaled) / 1e18;

// Market Cap in USDC dollars (divided by 1e6)
const marketCapUsd = Number(marketCapInQuote) / 1e6;

// Graduation progress percentage (0 to 100%)
const progressPercent = Number(progressBps) / 100;

const status = await client.readContract({
  address: curveAddress,
  abi: parseAbi(["function status() view returns (uint8)"]),
  functionName: "status",
});

// 0: BONDING (Trading active on the bonding curve)
// 1: GRADUATED (Curve closed, liquidity migrated to Uniswap V4)
const isGraduated = status === 1;

import { parseUnits } from "viem";

// 1. Fetch quote for buy amount
const buyQuote = await client.readContract({
  address: curveAddress,
  abi: parseAbi([
    "function quoteBuy(uint256 quoteAmountIn) view returns ((uint256 tokensOut, uint256 feeAmount, uint256 priceImpactBps, uint256 newMarketCap))",
  ]),
  functionName: "quoteBuy",
  args: [parseUnits("50", 6)], // 50 USDC
});

// 2. Approve USDC transfer
await walletClient.writeContract({
  address: "0x0000000000000000000000000000000000000000",
  abi: parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]),
  functionName: "approve",
  args: [curveAddress, parseUnits("50", 6)],
});

// 3. Execute Buy with 1% slippage tolerance
const minTokensOut = (buyQuote.tokensOut * 99n) / 100n;
const deadline = BigInt(Math.floor(Date.now() / 1000) + 1200); // 20 Minutes

await walletClient.writeContract({
  address: curveAddress,
  abi: parseAbi([
    "function buy(uint256 quoteAmountIn, uint256 minTokensOut, uint256 deadline) returns (uint256)",
  ]),
  functionName: "buy",
  args: [parseUnits("50", 6), minTokensOut, deadline],
});

// 1. Approve launch token
await walletClient.writeContract({
  address: tokenAddress,
  abi: parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]),
  functionName: "approve",
  args: [curveAddress, tokenAmountToSell],
});

// 2. Execute Sell
await walletClient.writeContract({
  address: curveAddress,
  abi: parseAbi([
    "function sell(uint256 tokenAmountIn, uint256 minQuoteOut, uint256 deadline) returns (uint256)",
  ]),
  functionName: "sell",
  args: [tokenAmountToSell, minQuoteOut, deadline],
});

const feeManagerAbi = parseAbi([
  "function getClaimableCreatorFees(address token, address creator) view returns (uint256)",
  "function claimCreatorFees(address token)",
]);

// Read unclaimed creator royalties
const claimable = await client.readContract({
  address: "0xd3AFEB2a57f70eF218Aa82451c51B2fb0416Ac9e",
  abi: feeManagerAbi,
  functionName: "getClaimableCreatorFees",
  args: [tokenAddress, creatorAddress],
});

// Claim USDC directly to wallet
if (claimable > 0n) {
  await walletClient.writeContract({
    address: "0xd3AFEB2a57f70eF218Aa82451c51B2fb0416Ac9e",
    abi: feeManagerAbi,
    functionName: "claimCreatorFees",
    args: [tokenAddress],
  });
}