Robinhood Chain trading tools for Pons. TypeScript SDK for token launches, a historical indexer, and research for a Robinhood copy trading bot. A Robinhood sniper bot and Robinhood bundler are on the roadmap and are not live.

Typed access to Pons factory contracts, token launches, and TokenLaunched events with viem queries.

Site: casatrickdev.github.io/pons-sdk

Write-up: Pons SDK on Robinhood Chain

This package is read-only. It does not sign transactions, hold keys, or execute trades.

This is a client for Pons on Robinhood Chain. It is not Pons Network (@pons-network/pons.js) or the Pons microkernel SDK.

• Robinhood Chain support
• Pons contract interaction
• Launch discovery
• TokenLaunched event decoding
• typed blockchain data
• safe block-range querying
• read-only integration
• historical launch indexer
• Robinhood copy trading bot research (no execution)

pnpm add pons-sdk

Peer runtime: Node.js 20+ and viem.

import { PonsClient } from "pons-sdk";

const pons = new PonsClient();

const launches = await pons.getLaunches({
  fromBlock: 8_991_118n,
  toBlock: "latest",
});

for (const launch of launches.slice(0, 10)) {
  console.log(launch);
}

The public Robinhood Chain RPC times out on wide eth_getLogs ranges. The SDK splits requests into bounded chunks (2,000 blocks by default). A full backfill from the V1 start block still takes time against the public endpoint; prefer a tighter toBlock while developing.

Override the RPC when you have a dedicated provider:

const pons = new PonsClient({
  rpcUrl: "https://your-robinhood-rpc.example",
});

import { PONS_REFERENCE, PonsClient } from "pons-sdk";

const pons = new PonsClient();

const launch = await pons.getLaunch(PONS_REFERENCE.token, {
  version: "v1",
  includeLegacy: true,
});

const graduation = await pons.getGraduationStatus(PONS_REFERENCE.token, {
  includeLegacy: true,
});

V1 and V2 factories have different TokenLaunched ABIs and different getLaunchedToken records. The SDK models them as separate types instead of collapsing incompatible fields.

const v2Launches = await pons.getLaunches({
  fromBlock: 55_400_000n,
  toBlock: "latest",
  version: "v2",
});

const canLaunch = await pons.canLaunch("0x...");

token and deployer are indexed on both factory generations and can be passed through to eth_getLogs:

const launches = await pons.getLaunches({
  fromBlock: 8_991_118n,
  toBlock: 8_993_118n,
  token: "0x39dBED3a2bd333467115dE45665cC57F813C4571",
});

pool is not an indexed TokenLaunched argument on V1, and V2 has no pool field on that event. The SDK does not pretend those filters exist at the RPC layer.

Robinhood Chain
      ↓
Pons Contracts
      ↓
Events
      ↓
Pons SDK
      ↓
Historical Indexer / SQLite
      ↓
Future Analytics / Scanner

Contract addresses and event signatures come from the official Pons documentation and the ponsdotdev/ponsfamily repository. They are not invented and are not taken from a third-party SDK.

The official PONS reference token (0x39dBED3a2bd333467115dE45665cC57F813C4571) was launched through the V1 legacy factory. Use includeLegacy: true when you need that history.

Milestone 1 is the read-only data layer: connect to Robinhood Chain, talk to the official Pons V1 and V2 factories, and turn real TokenLaunched logs into typed objects.

Robinhood Chain
      ↓
Pons Contracts
      ↓
Onchain Events
      ↓
Typed SDK

Shipped in this milestone:

• Robinhood Chain client and public RPC
• Pons V1 / V2 factory addresses and ABI fragments
• Live contract reads (getLaunchedToken, canLaunch, graduation status)
• TokenLaunched decoding against real onchain logs
• Chunked getLogs with merge, dedupe, and sort
• Launch queries (getLaunches, getLaunch)
• 30 unit tests and 3 live RPC integration tests

The next milestone after this read layer is persistent historical state. Milestone 2 (the SQLite indexer) is included in this package.

Full write-up: Building a Pons SDK on Robinhood Chain.

Milestone 2 turns decoded TokenLaunched events into local, queryable history.

Pons contracts
      ↓
TokenLaunched events
      ↓
Pons SDK
      ↓
Historical indexer
      ↓
SQLite
      ↓
Queryable launches

The indexer uses the SDK's getLaunches() and splitBlockRange() helpers. It does not send transactions. Blockchain integers are stored as decimal strings.

Re-processing the same block range does not create duplicate events. Identity is transactionHash + logIndex, enforced by a SQLite unique constraint. The indexer can safely replay a range. It does not unwind chain reorganizations.

import { PonsClient, PonsDatabase, PonsIndexer } from "pons-sdk";

const indexer = new PonsIndexer({
  client: new PonsClient(),
  database: new PonsDatabase("pons-indexer.sqlite"),
});

await indexer.sync({
  fromBlock: 8_963_000n,
  toBlock: 8_965_000n,
});

const launches = indexer.getLatestLaunches(20);

Resume after a stop by omitting fromBlock. The cursor only advances after the chunk is committed.

pnpm indexer:sync --from 8963000 --to 8965000
pnpm indexer:latest

This module is a research-only decision engine. It detects and evaluates wallet activity but does not execute trades.

Real Pons V1 wallet activity is ingested from Uniswap V3 Swap logs on pools emitted by TokenLaunched (official Pons integration path). The trader wallet is the transaction signer (tx.from), not the pool sender/recipient (often a router).

Pons TokenLaunched
     ↓
Pool registry
     ↓
Uniswap V3 Swap logs
     ↓
Wallet Activity ingestion
     ↓
Wallet Intelligence
     ↓
Trade Detection
     ↓
Filtering
     ↓
Risk
     ↓
Copy-Trade Signal
     ↓
Execution Adapter
        X
   Disabled

Research-only: mode is research. Constructing live throws. Signals use a deterministic id (transactionHash + logIndex). Filtering and risk are separate deterministic layers. No private keys. No live execution. engine.execute() throws Live execution is disabled in research mode. NoopExecutionAdapter returns not_executed.

import {
  CopyTradeEngine,
  PonsClient,
  PonsDatabase,
  PonsEventStream,
  SwapActivityIndexer,
  WalletActivityIngester,
  WalletIntelligence,
  WalletRepository,
  PONS_REFERENCE,
  PONS_WETH,
} from "pons-sdk";

const pons = new PonsClient();
const database = new PonsDatabase("pons-research.sqlite");
const wallets = new WalletRepository(database);

const pools = [
  {
    pool: PONS_REFERENCE.pool,
    token: PONS_REFERENCE.token,
    pairToken: PONS_WETH,
  },
];

const indexer = new SwapActivityIndexer({
  client: pons,
  database,
  walletRepository: wallets,
  pools,
});

await indexer.sync({ fromBlock: /* recent block */, toBlock: "latest" });

const intelligence = new WalletIntelligence(wallets);
const profile = intelligence.getProfile("0x...");

const engine = new CopyTradeEngine({
  mode: "research",
  policy: {
    allowedWallets: ["0x..."],
    minTradeSize: 1n,
  },
});

const stream = new PonsEventStream({
  client: pons,
  pools,
  ingest: new WalletActivityIngester(wallets),
  onActivity: async (activities) => {
    for (const activity of activities) {
      console.log(engine.explain(engine.process(activity)));
    }
  },
});

await stream.start(); // HTTP block-poll — not a WebSocket subscription

Wallet Activity (from real Swap logs)
→ Trade Detection
→ Filtering
→ Risk
→ Copy Signal
→ Noop Execution

• no live trading
• no private-key management
• no real transaction execution
• no WebSocket subscription (HTTP block-poll only)
• V2 curve/pool swap ingestion is not complete (V1 pools with known pool addresses)

Current:
Pons SDK
TokenLaunched indexer
V1 pool Swap → wallet activity ingestion
HTTP block-poll event stream
Wallet intelligence profiles
Copy-trade research signals

Future:
Paper execution
Live copy trading
Scanner
Bundler
Sniper
Additional Robinhood Chain launchpads
V2 swap coverage

Copy-trade signals remain research-only. Sniper, bundler, and live copy trading are not products in this repository yet.

This repo is the open-source foundation for Robinhood Chain trading tools:

Live copy-trading, sniping, bundling, and fund execution are disabled. There is no environment flag that turns them on.

Real trading is not implemented. If it is added later, do not use the public Robinhood Chain RPC (https://rpc.mainnet.chain.robinhood.com). Live reads and execution need a dedicated paid RPC such as Alchemy or QuickNode, passed as rpcUrl on PonsClient.

[x] Robinhood Chain client
[x] Pons V1/V2 contracts
[x] Contract reads
[x] TokenLaunched decoding
[x] Launch queries
[x] SDK tests
[x] Live RPC tests

[x] Historical indexer
[x] Persistent indexed state
[x] Copy-trading research architecture
[x] Read-only signal pipeline
[x] V1 pool Swap decoding
[x] Wallet activity ingestion
[x] HTTP block-poll event stream
[x] Real wallet intelligence (from Swap activity)

[ ] Scanner
[ ] Bundler
[ ] Sniper
[ ] Additional Robinhood Chain launchpads
[ ] V2 swap / curve activity coverage

pnpm install
pnpm lint
pnpm typecheck
pnpm test
pnpm build

Read-only integration tests hit the public Robinhood Chain RPC and never require a wallet:

pnpm test:integration

Run the example:

pnpm example:launches
pnpm indexer:sync --from 8963000 --to 8965000
pnpm indexer:latest

This package is data infrastructure and copy-trading research only.

• No private-key handling
• No transaction signing
• No live copy-trading, sniping, or execution
• No wallet custody
• The execution adapter is a no-op and cannot be armed with an environment flag
• Real trading, if ever enabled, requires a paid RPC (Alchemy or QuickNode), not the public endpoint

On-chain values stay as bigint / addresses. The SDK does not convert token amounts to floating-point numbers.

MIT