Integrate RobinFinite.

RobinFinite uses isolated permanent bonding-curve markets. A market is not a conventional two-token AMM pair. Integrators should use its native quote functions and event semantics.

Find the full deployment address list and ABI reference in Developers. RPC providers may offer different historical log and state coverage; verify both before historical indexing.

Factory discovery:
launchCount()
launchAt(index) -> (token, market)
marketOfToken(token) -> market
tokenOfMarket(market) -> token

Creation source: Factory TokenCreated event
Market identity: token(), factory(), creator()

Public Registry API

GET https://www.robinfinite.com/api/v1/tokens?limit=50
GET https://www.robinfinite.com/api/v1/markets?limit=50
GET /api/v1/tokens?address=0x9844706ce3e2ec0ed9a2ae2959be25c129ad1111

Pagination: use nextCursor as the next request's after parameter.
GET /api/v1/tokens?limit=50&after=<nextCursor>

Response: { schemaVersion: "1", chainId: 4663,
  retrievedAtTimestamp: "...", data: [...], nextCursor: null }

retrievedAtTimestamp is the response retrieval time, not a chain finality watermark. Registries are read from one consistent database snapshot per request. Pagination is not a frozen snapshot across requests; new records sorting before a cursor appear on the next full scan.

Keep the ETH quote asset separate from wrapped-token addresses. Virtual ETH is a curve parameter, not withdrawable liquidity. Report accounted reserve and virtual reserve separately.

Choose and document a price and volume convention. Gross trade value and net trader proceeds are different. Do not count a BUY refund as executed volume, or ERC-20 transfers as BUY / SELL trades.

For OHLCV, define interval boundaries in UTC, the quote currency, fee treatment and empty-candle behavior. Convert raw token amounts using the token decimals; preserve raw integers in storage. Roll back affected records and candles on a reorg.

Public Market Data API

GET /api/v1/trades?token=<tokenAddress>&limit=50
GET /api/v1/trades?token=<tokenAddress>&limit=50&before=<nextCursor>
GET /api/v1/price?token=<tokenAddress>
GET /api/v1/ohlcv?token=<tokenAddress>&interval=1h
GET /api/v1/ohlcv?token=<tokenAddress>&interval=1h&from=<unixSeconds>&to=<unixSeconds>

Base URL: https://www.robinfinite.com
Token example: 0x9844706ce3e2ec0ed9a2ae2959be25c129ad1111
Prices and amounts are decimal strings. Quote currency: ETH.

historyCoverage: complete_hot_history means retained trades match the lifetime summary in this database snapshot. If trades have been archived or totals differ, these endpoints return HISTORY_INCOMPLETE instead of a partial chart. Archive merging is not released in this version. Pagination uses a new snapshot per request.

retrievedAtTimestamp is response retrieval time, not a finality watermark. Price timestamp is the last indexed trade time and may be old. BUY/SELL data remains subject to canonical-chain reorg handling; these endpoints are not the platform block/event adapter. Full event fields are in Events.

GET /api/v1/coverage?token=TOKEN_ADDRESS
GET /api/v1/trades?token=TOKEN_ADDRESS&after=BLOCK:LOG_INDEX&limit=100
GET /api/v1/trades?token=TOKEN_ADDRESS&after=BLOCK:LOG_INDEX&until=SNAPSHOT_BLOCK&limit=100

after is exclusive and orders trades by block number then global log index ascending. before keeps the existing descending history behavior; the two cannot be combined. Integer cursor fields must not be converted to JavaScript numbers. Forward pages return hasMore, nextCursor, resumeCursor and snapshotUntilBlock. When the last page has records, save resumeCursor even when nextCursor is null. An empty page retains the input cursor.

The first forward page sets a ceiling at the committed Indexer block. Pass its snapshotUntilBlock as until on following pages; once caught up, omit until for the next polling cycle. A missing or unhealthy Indexer watermark fails closed. A cursor beyond the current watermark returns 409 and needs investigation rather than silently skipping records.

Coverage reports retained count and range, native lifetime totals, retained totals and Indexer status. complete_hot_history means counts and token/curve/user volumes match the native indexed summary. It is not an independent proof of all historical chain logs, finality or external platform indexing. archiveIncluded is false: an archive integration is not claimed. Incomplete retained history is reported explicitly by coverage; trades, prices and OHLCV continue to return 503 HISTORY_INCOMPLETE rather than silently shorten history.

import { RobinFiniteSDK } from "./robinfinite-sdk-0.4.0.mjs";
const sdk = new RobinFiniteSDK();
const token = "0x9844706ce3e2ec0ed9a2ae2959be25c129ad1111";
const coverage = await sdk.coverage(token);
if (!coverage.canQueryFullIndexedHistory) throw new Error("History incomplete");
// Load your durable checkpoint; 0:0 starts Robin history from the beginning.
let checkpoint = "0:0";
for await (const page of sdk.catchUpTrades({ token, after: checkpoint })) {
  for (const trade of page.data) {
    const id = [4663, trade.transactionHash, trade.logIndex].join(":");
    // Commit trade under this unique id, with blockHash, in your own store.
    // Persist its cursor only after your processing succeeds.
    console.log(id, trade.blockHash, trade.type, trade.tokenAmountRaw);
    checkpoint = trade.blockNumber + ":" + trade.logIndex;
  }
}
// After a delay, run again from your last durably processed checkpoint.

Use a unique key of chain ID, transaction hash and global log index for idempotent ingestion; retain block hash to detect replacements. Cursor progression assumes the committed history is stable: reorg rollback, historical backfills behind your checkpoint and event removals require reconciliation, which this endpoint does not automate. The SDK stops on invalid order, a changing ceiling or a stalled cursor; if its page limit is reached, continue from your last processed checkpoint. HTTP recovery is also used by the SSE event notifications below. WebSocket support is not provided.

GET /api/v1/events
Content-Type: text/event-stream
Events: ready, new-token, new-trade, price-update,
        recovery-required, status

This is Server-Sent Events (SSE), not WebSocket. Each server process shares one read-only database polling cycle across its subscribers, normally every three seconds. The stream never scans RPC or exposes provider credentials. Notifications cover visible registered tokens and committed Indexer blocks after the broadcaster's initial boundary; it is not a historical replay endpoint.

ready supplies the current indexed boundary and replay:false. On every connection or reconnect, restore your watched tokens through REST after queries and rescan the complete token registry from its first page. Last-Event-ID is not used for server replay. new-token includes canonical registry identity and creation identity; obtain metadata from the token APIs. new-trade reuses the public native trade record. price-update contains that trade's fee-exclusive curve execution average in ETH, not a fresh quote or USD price.

// Browser or a bundler with viem; Node must supply a compatible EventSourceImpl.
import { RobinFiniteSDK } from "./robinfinite-sdk-0.4.0.mjs";
const sdk = new RobinFiniteSDK();
const token = "0x9844706ce3e2ec0ed9a2ae2959be25c129ad1111";
let checkpoint = "0:0"; // Replace with your durably processed checkpoint.
let wanted = false, working = false;
async function recover() {
  wanted = true;
  if (working) return;
  working = true;
  try {
    while (wanted) {
      wanted = false;
      for await (const page of sdk.catchUpTrades({ token, after: checkpoint })) {
        for (const trade of page.data) {
          console.log(trade.transactionHash, trade.logIndex, trade.blockHash);
          // Commit idempotently, then durably persist this cursor.
          checkpoint = trade.blockNumber + ":" + trade.logIndex;
        }
      }
    }
  } finally { working = false; }
}
const subscription = sdk.subscribeEvents({
  onEvent({ type, data }) {
    if (type === "new-token") console.log("Rescan registry", data.tokenAddress);
    if (type === "ready" || type === "recovery-required") {
      console.log("Rescan registry from first page");
      recover().catch(console.error);
    }
    if (type === "new-trade" && data.tokenAddress === token)
      recover().catch(console.error);
    if (type === "price-update") console.log(data.tokenAddress, data.price);
  },
  onError(error) { console.warn(error.code); },
});
// On component teardown or when the consumer stops:
// subscription.close();

The example tracks one token; a production consumer must implement durable ingestion, registry resync and bounded retries/backoff. Continue periodic REST reconciliation even without notifications so late backfills, metadata changes or recovered hidden tokens are discovered. On status temporarily-unavailable, retain your checkpoint and retry REST with backoff; a healthy stream tick alone does not certify complete chain history.

Limits per process: 64 connections, 64 KiB queued bytes per connection, and at most 500 token creations plus 500 trades per poll. Heartbeats are emitted approximately every 20 seconds while the polling loop runs. Slow connections are closed and must resync after reconnect. Oversized batches trigger recovery-required instead of a partial event export. A checkpoint regression or same-height hash replacement triggers recovery-required. Detection of every chain reorg and automated event rollback/removal are not provided.

New-token and new-trade notices follow block/log order within each batch; price-update follows its corresponding trade. Each SQL query has a five-second timeout. Failures back off to at most 30 seconds and do not advance the normal notification boundary. Proxy buffering or idle timeouts may affect public SSE; verify your external client path. These are functional safety bounds, not high-concurrency or TPS acceptance results.

BUY:  quoteBuy(grossInputWei) -> BuyQuote
SELL: quoteSell(tokenInRaw)   -> SellQuote

1. Verify chain ID and Factory / Market relationships.
2. Read a fresh quote and apply explicit slippage protection.
3. For SELL, check allowance to the exact RobinMarket.
4. Simulate the intended transaction.
5. Submit the request that passed simulation.
6. Verify receipt status and decode the market trade event.

GET /api/v1/quote?token=0x9844706ce3e2ec0ed9a2ae2959be25c129ad1111&side=BUY&amount=100000000000000
GET /api/v1/quote?token=0x9844706ce3e2ec0ed9a2ae2959be25c129ad1111&side=SELL&amount=1000000
GET /api/v1/sdk  (download robinfinite-sdk-0.4.0.mjs)

A SELL example requires positive tokensSoldRaw on that market; a market with zero sold inventory cannot provide a successful SELL quote. BUY amount is gross ETH input in wei (18 decimals); SELL amount is token input in raw units (6 decimals). All quote amounts and block numbers are integer strings. Fees, unused BUY refund and net SELL output are separate fields. Quotes read the canonical Factory and Market at one RPC block and recheck its hash. This is an execution quote, not the indexed price API.

The JavaScript ES module requires viem in your Node.js project or browser bundler. Download and retain a reviewed local copy; no npm package publication is claimed. The SDK never signs or broadcasts transactions. Your own wallet submits only the request returned by successful simulation, on chain 4663 with the same account.

// npm install viem; download /api/v1/sdk as ./robinfinite-sdk-0.4.0.mjs
import { RobinFiniteSDK } from "./robinfinite-sdk-0.4.0.mjs";
const sdk = new RobinFiniteSDK();
const token = "0x9844706ce3e2ec0ed9a2ae2959be25c129ad1111";
// publicClient and walletClient are your own viem clients on chain 4663.
const [account] = await walletClient.getAddresses();
if (await walletClient.getChainId() !== 4663) throw new Error("Wrong wallet chain");
const preview = await sdk.quote({ token, side: "BUY", amount: 100000000000000n });
const simulation = await sdk.simulateBuy(publicClient, {
  token, account, amount: 100000000000000n,
  slippageBps: 100, ttlSeconds: 120,
});
const hash = await walletClient.writeContract(simulation.request);
const receipt = await publicClient.waitForTransactionReceipt({ hash });
if (receipt.status !== "success") throw new Error("Trade reverted");
// Reconcile the RobinMarket Buy event before recording the actual fill.

const amount = 1000000n; // One token, 6 decimals
// If allowance is insufficient, approve only this amount to the canonical market.
const approval = await sdk.simulateApproval(publicClient, { token, account, amount });
const approvalHash = await walletClient.writeContract(approval.request);
const approved = await publicClient.waitForTransactionReceipt({ hash: approvalHash });
if (approved.status !== "success") throw new Error("Approval reverted");
// Re-quote AFTER approval; SDK checks allowance and uses netETHOutWei for minimum.
const sale = await sdk.simulateSell(publicClient, {
  token, account, amount, slippageBps: 100, ttlSeconds: 120,
});
const saleHash = await walletClient.writeContract(sale.request);
const sold = await publicClient.waitForTransactionReceipt({ hash: saleHash });
if (sold.status !== "success") throw new Error("Sale reverted");
// Reconcile the RobinMarket Sell event and net ETH output.

Bot integrations resolve marketOfToken through the Factory and verify Market.token. SELL approvals target that market, never a registry entry supplied by an untrusted caller. The SDK bounds explicit slippage to 0–500 bps and deadline duration to 1–600 seconds. The quote endpoint admits at most 30 requests per minute and two concurrent requests per server process; this is an RPC protection limit, not a distributed rate limiter. Handle 429 with backoff, 409 by re-quoting, 422 as a non-executable quote, and 503 as unavailable data. Never substitute the historical price API for a failed quote.

Use the documented recipient and deadline arguments. A successful quote is not a guarantee that execution will succeed later. Aggregators need a RobinMarket-compatible execution route; token discovery alone does not enable trading.

These public, read-only endpoints accept an address without a wallet signature. They expose indexed token quantities and trade activity, not private sessions, cost basis, profit/loss or Treasury fees. Existing Portfolio pages and their authentication rules are unchanged.

Holdings preserve the original Portfolio reader and curve calculation. balanceRaw is in token smallest units (6 decimals); currentPriceWeiPerToken is wei per whole token; currentValueWei and totalCurrentValueWei are wei (ETH has 18 decimals). This marginal curve reference is not a SELL quote, net proceeds, USD value or guaranteed liquidity. Use /api/v1/quote to obtain executable amount-specific terms.

Activity preserves native hot-first, verified-archive-second reads, native overlap deduplication and cursor ordering. Archive failure returns 503 instead of incomplete hot-only history. The scope is native BUY / SELL events attributed to the trader, not transfers, approvals, creation records or every wallet transaction. userEthWei keeps the original BUY/SELL semantics; it is not the fee-exclusive chart price.

Indexer health is observed separately after the data read. Its block is not the exact snapshot block of the returned holdings or activity. A healthy Indexer does not prove full lifetime chain completeness. Responses explicitly set chainCompletenessVerified=false. Holdings use the native Portfolio token scope; balance checks require a visible indexed registry token.

The balance endpoint queries one token and one wallet, not all holdings. Indexed and onchain balances are independently observed; differs can reflect Indexer lag or intervening transfers and is not, by itself, proof of database corruption. The onchain result includes block number, hash and timestamp. A detected block replacement returns 409.

SDK 0.4.0 adds holdings(wallet), activity(wallet, {limit, cursor}) and balance(wallet, token). All endpoints reject duplicate or unknown query keys. Errors: 400 invalid input, 404 unavailable registry token, 409 detected balance-block replacement, 429 capacity exceeded, 503 unavailable data. The three endpoints share a per-process cap of two active requests and 60 admitted requests per minute; this is not a global quota. Responses use no-store and public CORS.

Use chain ID and token address as identity. Name, symbol and decimals are native indexed values; optional images, website and social fields come from token metadata. Providing APIs and a Token List does not automatically add prices or logos to external wallets or portfolio trackers.

Reviewed against official documentation on 12 October 2026. Public registries provide discovery data; platform adapters are a separate interface. The event feed must publish only fully processed block ranges. Virtual curve reserves must never be reported as withdrawable liquidity.

The candidate adapter base is /api/integrations/geckoterminal, with /latest-block, /asset?id=, /pair?id= and /events?fromBlock=&toBlock=. Event ranges are inclusive, limited to 1,000 blocks and 100 trades, and must not extend beyond the committed native Indexer cursor. Reduce the range on HTTP 413; retry on HTTP 429. Errors never return a truncated event list.

Token is asset0; native ETH is asset1. The proposed ETH identifier native:4663:eth and dexKey robinfinite require platform agreement before indexing begins. The adapter returns real accounted ETH reserve, excludes virtual ETH, and checks historical market inventory against token balance. Receipt transaction order and event values are checked against chain logs. This is a candidate HTTP adapter, not a WebSocket feed or an SDK.

Public project profile: /api/v1/project. Existing project artwork is exported unchanged as SVG and as a 512 × 512 PNG at /api/v1/project/logo?format=svg or ?format=png. These project images are distinct from each token's own logo.

Token metadata: /api/v1/token-metadata?address=TOKEN_ADDRESS. It exposes native indexed name, symbol and decimals plus native inline JSON metadata. Unsupported remote metadata remains explicitly unresolved; these APIs do not fetch arbitrary websites. Missing token images are not replaced with the project logo.

Wallet Token List: /api/v1/token-list. The whole list uses the Token Lists JSON schema, checksum addresses, native 6-decimal values, per-token logos and semantic version updates. Tokens are registered Robin tokens, not an endorsement or a promise of wallet/aggregator support. The list is limited to 10,000 entries and fails instead of truncating or modifying incompatible names/symbols. Additions increment minor; removals or decimals changes increment major; other entry changes increment patch.

DEX Screener describes its own chain-log indexing; our public APIs are supporting review materials, not an automatic listing mechanism. Its DEX listing guidance includes liquidity/volume, open-source and audited contracts, and community activity. Public source/verification links and any audit report must be supplied and verified separately; ABI documentation alone does not prove an independent audit.

The independent DEXTools candidate uses block-global eventIndex and receipt.from for the transaction maker. The GeckoTerminal receipt-local index mapping remains unchanged. DEXTools creation and swap events are exported without inventing liquidity join/exit events. Swap ETH amounts exclude protocol and creator fees; reserves use actual curve inventory and accounted ETH, excluding virtual ETH.

GeckoTerminal now documents Launchpad Addition. RobinFinite can be described for review as a permanent bonding-curve launchpad with custom EVM markets; this is our protocol classification, not an approval decision. The current candidate adapter remains conditional because the linked integration-standard document could not be reloaded during this review.

Publication of this documentation is not platform approval or listing. A first platform integration will be recorded only after its actual discovery and data display have been verified.

These files are public review materials, not platform approval or a new trading service. They exclude private wallet authentication and fee APIs. The manifest includes SHA-256 of the OpenAPI HTTP JSON response bytes; the formatted source file can have a different hash. The contract and SDK have independent version numbers.

Use distinct cursors for each interface: token-address cursors for registry pages, block:globalLogIndex cursors for trade recovery, and opaque native cursors for Portfolio activity. Integer strings retain raw precision. Registry tradingStatus=not_checked is not a tradability guarantee. Never report virtual curve ETH as actual withdrawable liquidity.

Live Create, BUY, SELL, price and reconnect replay were verified in operator-reported native reconciliation logs on 12 October 2026. The manifest links their public transaction hashes and explicitly scopes this evidence; static documentation does not independently reverify chain state. GeckoTerminal remains a candidate adapter, and external discovery, wallet display and aggregator execution require separate platform acceptance. No submissions have been made.

For integration inquiries, use the official X account. Include your platform, required data format, historical coverage and execution requirements. Do not send wallet keys or provider credentials.

Holder quantity is proposed in raw Token units (6 decimals), represented as a JSON integer only within the exact safe integer range. Market contracts are included as holders and are not external user counts. The adapter reconciles the indexed aggregate with on-chain totalSupply and verifies every returned holder balance at the pinned committed block. Aggregate reconciliation does not independently prove all historical transfers or every unreturned holder address.

Native ETH ID, raw holder quantity units and page numbering require platform agreement. These candidate routes are outside the versioned public API OpenAPI document. HTTP 400 indicates invalid input, 404 an unavailable identity or block, 429 capacity, and 500 failed reconciliation or unavailable export. Errors never return a truncated successful event range. Hot trade history must match native lifetime summary totals; archived or incomplete history fails closed. This adapter is not a promise of full lifetime coverage, high-throughput acceptance or platform listing.

import { createRobinFiniteDatafeed } from 'https://www.robinfinite.com/api/integrations/tradingview/datafeed';

let widget;
const datafeed = createRobinFiniteDatafeed({
  onResetCache: () => widget?.activeChart().resetData(),
  onError: (message) => console.warn(message),
});

// Supply your own authorized TradingView chart library.
widget = new TradingView.widget({
  container: 'chart',
  library_path: '/charting_library/',
  symbol: 'ROBINFINITE:4663:0x9844706ce3e2ec0ed9a2ae2959be25c129ad1111',
  interval: '60',
  datafeed,
});

// When removing the host chart:
// widget.remove();
// datafeed.destroy();

ETH prices reuse the native fee-exclusive curve execution average. Volume is Token volume, not ETH volume or reserve. The bars endpoint uses one read-only snapshot and committed Indexer ceiling, preserves all requested bars and adds older bars to meet countBack when available. Requests exceeding 1,000 returned bars fail explicitly. Incomplete hot history returns an error rather than noData. The original /api/v1/ohlcv endpoint continues to return closed candles only.

Current candles are recomputed as complete OHLCV snapshots from committed trades. One shared SSE connection per datafeed triggers refreshes, with a 10-second polling fallback and per-subscription refresh throttling. Reconnect refreshes bars from the last displayed candle; checkpoint regression or recovery-required invokes the host reset callback. The host must provide onResetCache to reload chart history, typically activeChart().resetData(); the sample demonstrates this hook. Eight subscriptions, two concurrent HTTP requests and a bounded queue are supported per datafeed instance. The server limit is per process, not a distributed capacity guarantee.

Only the browser plotting adapter converts decimal strings to floating-point numbers. Use the native public APIs for exact amounts and executable quotes. Default display pricescale is 10^12; callers may configure a power of ten up to 10^15. This is chart display precision, not native 18-decimal quote precision. No synthetic flat candles, trade signing or transaction broadcast are provided.

The proprietary chart library is not bundled. Browser widget visual acceptance and TradingView.com listing have not been completed. This candidate is a project-side data integration resource; native history completeness, external chart display and platform acceptance have distinct scopes.