@frontierfun/openclaw-plugin

OpenClaw plugin for Frontier, the coin launchpad on Robinhood Chain. Gives AI agents the ability to launch coins, trade on bonding curves and Uniswap V4 pools, graduate coins, provide liquidity, stake, manage fee recipients and referrals, and run autonomous strategies, all through natural language.

Read-only by default (coin state, quotes, pool state, portfolio, history). Requires FRONTIER_PRIVATE_KEY or FRONTIER_KEYSTORE_PASSWORD (env var or plugin settings) to enable write operations: coin launches, bonding-curve and pool trading, graduation, liquidity, staking, vesting release, copy-trading, and autonomous strategies. With a wallet configured, the plugin can perform real onchain transactions through the agent within the configured TxGate per-transaction and 24-hour spending limits.

This is a thin adapter over @frontierfun/sdk: the SDK owns all tool definitions and execution logic, and this plugin registers them with OpenClaw.

Requirements

• Node.js >= 24
• OpenClaw >= 2026.4.27 (calendar versioning: compatibility.pluginApiRange >=2026.3.22, compatibility.minGatewayVersion >=2026.4.27)

Installation

# From ClawHub (recommended — auto-discovered before npm fallback)
openclaw plugins install clawhub:@frontierfun/openclaw-plugin

# Or directly from npm
openclaw plugins install @frontierfun/openclaw-plugin

# Or link locally for development
openclaw plugins install -l ./packages/openclaw-plugin

# Verify
openclaw plugins list
openclaw plugins doctor

Configuration

The plugin targets Robinhood Chain (4663) out of the box: RPC, contract addresses, the Frontier data API, the explorer and the app URL all come from the SDK's chain registry. Configure your wallet and you are ready to go:

{
  "plugins": {
    "entries": {
      "frontier-launchpad": {
        "enabled": true,
        "config": {
          "chainId": 4663,
          "rpcUrl": "wss://robinhood-rpc.publicnode.com",
          "referrerAddress": "0x...",
          "txGate": {
            "maxPerTxETH": "0.5",
            "dailyBudgetETH": "3.0",
            "cooldownSeconds": 2,
            "confirmAboveETH": "0"
          },
          "agentConfig": {
            "trading": {
              "defaultSlippageBps": 300,
              "maxTradeETH": "0.5",
              "gasReserve": "0.05"
            }
          }
        }
      }
    }
  }
}

Configuration Options

| Option | Type | Description | |--------|------|-------------| | chainId | 4663 \| 421614 | Frontier chain: Robinhood Chain (default) or Arbitrum Sepolia (testnet). Selects the default RPC, contract addresses, API and explorer | | rpcUrl | string | JSON-RPC endpoint. wss:// is required by the strategy tools (default: the chain registry's HTTP endpoint) | | apiBaseUrl | string | Frontier data API base URL (coin registry, extension catalog, image upload) | | explorerBaseUrl | string | Block explorer origin for transaction links | | referralBaseUrl | string | App origin for ?ref= referral links | | referrerAddress | string | Default referrer address for referral links and curve trades | | rpcTimeoutMs | number | HTTP RPC request timeout (default 15000) | | orderSplitter | object | Opt-in chunking of large bonding-curve trades | | statePersistDir | string | Directory for cross-restart state (~/.frontier/state) | | agentConfig | object | Trading, risk, copy, strategy and ops settings (see the skill's config reference) | | txGate | object | Spending limits (see below) |

Testnet (Arbitrum Sepolia)

{
  "config": {
    "chainId": 421614,
    "rpcUrl": "wss://arbitrum-sepolia-rpc.publicnode.com"
  }
}

The chain id the RPC reports is verified against chainId before the first write; a mismatch refuses the transaction. FRONTIER_CHAIN_ID=421614 in the environment does the same when the plugin config carries no chainId.

Custom Network / Addresses (Optional)

Override individual contract addresses via the plugin-config object for a custom deployment or a local fork. Contract-address overrides are plugin-config-only (no env-var fallback): env-based contract substitution doubled as a phishing vector.

{
  "config": {
    "rpcUrl": "http://127.0.0.1:8545",
    "factoryAddress": "0x...",
    "bondingCurveAddress": "0x...",
    "curveMathAddress": "0x...",
    "highlightsManagerAddress": "0x...",
    "referralManagerAddress": "0x...",
    "vestingAddress": "0x...",
    "hookAddress": "0x...",
    "liquidityManagerAddress": "0x...",
    "poolManagerAddress": "0x...",
    "universalRouterAddress": "0x...",
    "quoterAddress": "0x...",
    "positionManagerAddress": "0x...",
    "stateViewAddress": "0x...",
    "permit2Address": "0x...",
    "stakingVaultFactoryAddress": "0x...",
    "harvesterAddress": "0x...",
    "polDistributorAddress": "0x...",
    "cloneFactoryAddress": "0x...",
    "wethAddress": "0x...",
    "apiBaseUrl": "https://...",
    "explorerBaseUrl": "https://...",
    "referralBaseUrl": "https://..."
  }
}

Wallet Setup

Three options (in priority order):

Option A: Encrypted keystore (production, recommended)

export FRONTIER_KEYSTORE_PASSWORD="your-strong-password"
# First run auto-generates a wallet and saves the encrypted keystore to ~/.frontier/agent-wallet.enc
# Fund the generated address before using write operations

Option B: Environment variable (dev/testing)

export FRONTIER_PRIVATE_KEY="0x..."

Option C: Plugin config

{
  "config": {
    "privateKey": "0x..."
  }
}

Default Contract Addresses (Robinhood Chain, 4663)

The SDK's chain registry (chains.ts, a verified snapshot of the Frontier API's GET /chains) is the source of truth; the plugin never hardcodes an address of its own. Highlights:

| Contract | Address | |----------|---------| | BCTokenFactory | 0xe3A826C056e578c240D362BF4C2fa53E5c0c17a5 | | BondingCurve | 0xEAAa2Ae7De8B80d7a59ECF08B078EFAC6fCe6659 | | FactoryHook (Uniswap V4 hook) | 0xb31780AAd49D3Cc7Dd6E03E9e462606F0A5A30Cc | | Uniswap V4 PoolManager | 0x8366a39CC670B4001A1121B8F6A443A643e40951 | | Universal Router | 0x8876789976dEcBfCbBbe364623C63652db8C0904 | | Uniswap V4 PositionManager | 0x58daec3116aae6D93017bAAea7749052E8a04fA7 | | StakingVaultFactory | 0xFB443f5c6Ba35334a1AB2Fc12d4b877fc2A8d6A9 | | PolDistributor | 0x9604e6FAD64F0fe7fE84bE6Cd3079e7a8C6265CC | | WETH | 0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73 |

Default RPC: https://rpc.mainnet.chain.robinhood.com (HTTP; wss://robinhood-rpc.publicnode.com for strategies). Explorer: https://robinscan.io. API: https://api.frontier.fun. App: https://frontier.fun.

Environment Variables

The plugin reads six environment variables: two credentials and four operator-tunable knobs. Each has an unprefixed fallback (PRIVATE_KEY, KEYSTORE_PASSWORD, CHAIN_ID, RPC_URL, TOOL_TIMEOUT_MS) honoured with the lowest priority. Everything else (contract addresses, API/explorer/referral URLs, agent config, TxGate) is set via the plugin-config object the host passes through OpenClaw plugin settings. The audit log lives at ~/.frontier/audit.

Sensitive vars are masked in the OpenClaw UI via uiHints[*].sensitive: true.

| Name | Sensitive | Required | Description | |------|-----------|----------|-------------| | FRONTIER_PRIVATE_KEY | Yes | No | Wallet private key for write ops. Plugin runs read-only if unset. Read by the SDK's WalletManager | | FRONTIER_KEYSTORE_PASSWORD | Yes | No | Password for the encrypted keystore at ~/.frontier/agent-wallet.enc. Alternative to FRONTIER_PRIVATE_KEY. Read by the SDK's WalletManager | | FRONTIER_CHAIN_ID | No | No | 4663 (Robinhood Chain, default) or 421614 (Arbitrum Sepolia). The plugin-config chainId wins | | FRONTIER_RPC_URL | No | No | JSON-RPC endpoint (wss:// required for strategies). Falls back to the chain registry default | | FRONTIER_REFERRER_ADDRESS | No | No | Default referrer address for links and curve trades | | FRONTIER_TOOL_TIMEOUT_MS | No | No | Per-tool execution timeout in milliseconds. Defaults to 15000 |

This table mirrors setup.providers[0].envVars and clawhub.envVars in openclaw.plugin.json; keep all three in sync when adding or removing variables.

Skills System

The plugin ships the frontier-launchpad skill for the OpenClaw skills system. See SKILL.md for:

• All 84 tools grouped by category (curve and pool trading, launches, liquidity, staking, fee recipients, referrals, strategies)
• The launch, trading, liquidity, staking and referral workflows
• Safety rules and the TxGate defaults

The references cover the coin/pool state shapes, every configuration value, and the strategies.

Available Tools

Once installed, your OpenClaw agent gets 84 tools, all prefixed with frontier_. For the complete reference with parameters and return types, see API-REFERENCE.md.

Read Tools (free, no gas): 48 tools

| Tool | Description | |------|-------------| | frontier_get_token_state | Full coin state: launch mode, price, supply, TVL, curve params, graduation status, pool id, fees, pool block | | frontier_quote_buy | Coins received for X ETH on the curve (fee-inclusive, would_graduate) | | frontier_quote_sell | ETH received for X coins on the curve | | frontier_calculate_cost | Exact ETH cost for X coins on the curve via CurveMath | | frontier_get_balance | ETH, WETH, or coin balance | | frontier_check_graduation | ETH needed to graduate and the graduation payouts as configured today | | frontier_get_pool_state | Live Uniswap V4 pool: price, tick, liquidity, fee in force, hook config | | frontier_get_pool_key | Pool key and pool id, computed locally | | frontier_preview_pool_fee | Fee a pool swap pays right now (total / LP / non-LP pips) | | frontier_quote_pool_swap | Off-chain pool swap quote (exact-in or exact-out) | | frontier_get_lp_positions | Uniswap V4 positions of an address on Frontier pools | | frontier_check_otc_transfer | Pre-flight check for direct transfers (transfer lock before graduation) | | frontier_get_highlight_status | Promotion cost and availability | | frontier_get_highlight_config | Highlight settings in force today | | frontier_get_referral_reward | Pending referral WETH | | frontier_get_referral_fees | Referral shares of the curve fee in force today | | frontier_get_cooldown_status | Staking vault cooldown | | frontier_get_staking_vault_address | Staking vault of a coin | | frontier_get_staking_position | Shares, assets, max withdraw/redeem, WETH earned | | frontier_get_staking_rewards | WETH stream: earned (claimable) and pending | | frontier_preview_stake | Vault shares for a deposit (no execution) | | frontier_preview_unstake | Coins for redeeming shares (no execution) | | frontier_get_vesting_info | Vesting schedule details (supports index) | | frontier_get_all_vesting_schedules | All vesting schedules for a coin | | frontier_is_protocol_paused | Are launches and curve trades paused? | | frontier_get_creation_fee | ETH fee to launch a coin, read live | | frontier_get_factory_params | Live launch parameters: default curve, bounds, fee config, dev-buy cap | | frontier_get_fee_recipient | Current fee recipient of a coin | | frontier_get_portfolio_summary | Aggregated portfolio: ETH, coins, staking, vesting, referrals | | frontier_resolve_token | Resolve a coin by address, symbol, or name | | frontier_get_recent_deployments | Recently launched coins from the event buffer | | frontier_get_token_list | Filtered, sorted coin list from the registry | | frontier_list_extensions | Hook extension catalog | | frontier_get_coin_extensions | A coin's live pool configuration as the API serves it | | frontier_get_token_distribution | Holder distribution (app-only surface) | | frontier_get_user_holdings | Coins a wallet traded (app-only surface) | | frontier_get_user_creations | Coins a wallet created (app-only surface) | | frontier_get_current_highlight | Currently highlighted coin | | frontier_get_config | Current agent config + spending stats | | frontier_spending_stats | 24h spend and remaining budget | | frontier_get_wallet_info | Agent wallet address, balance and mode | | frontier_get_wallet_balances | All wallet balances, names, tags, busy status | | frontier_get_failed_txs | Failed transactions: dead-lettered, timeouts, aborted | | frontier_get_tx_history | Rolling confirmed transaction history (filter by type) | | frontier_get_strategy_status | Status of running strategies | | frontier_list_available_strategies | Available strategies, config fields and presets | | frontier_generate_referral_link | https://frontier.fun?ref=<wallet> | | frontier_describe_protocol | Human-readable protocol description with live parameters |

Write Tools (costs gas, gated): 24 tools

| Tool | Description | |------|-------------| | frontier_buy_token | Buy a coin: bonding curve, auto-routed to the pool once it trades there | | frontier_sell_token | Sell a coin: bonding curve, auto-routed to the pool once it trades there | | frontier_pool_swap | Explicit Uniswap V4 pool swap through the Universal Router (exact-in / exact-out) | | frontier_approve_pool_sell | Set up the pool-sell approvals (coin → Permit2 → Universal Router) | | frontier_add_liquidity | Mint or increase a position on the coin's pool (full / narrow / wide or explicit ticks) | | frontier_remove_liquidity | Withdraw liquidity (and fees) from a position; burns it on full removal | | frontier_collect_fees | Collect a position's accrued fees without changing its size | | frontier_collect_pool_fees | Collect the fees of a coin's protocol-locked liquidity (anyone can trigger) | | frontier_upload_image | Pin a coin image to IPFS through the Frontier API | | frontier_deploy_token | Launch a coin: curve or instant, fee model, extensions, staking vault, dev buy, socials | | frontier_trigger_graduation | Final curve buy that graduates the coin into its locked pool | | frontier_set_fee_recipient | Change a coin's fee recipient (creator only) | | frontier_create_fee_recipient | Deploy a lottery / buyback-burn / fee-splitter recipient clone | | frontier_otc_transfer | Direct coin transfer (once on its pool) | | frontier_highlight_token | Promote a coin | | frontier_claim_referral_reward | Claim WETH referral rewards | | frontier_stake_tokens | Deposit into a staking vault | | frontier_request_unstake | Start the unstake cooldown (by coin amount) | | frontier_request_unstake_by_shares | Start the unstake cooldown (by share amount) | | frontier_complete_unstake | Claim after the cooldown | | frontier_claim_staking_rewards | Claim the vault's WETH rewards | | frontier_release_vested_tokens | Release vested coins after the cliff | | frontier_create_vesting_schedule | Create a vesting schedule for beneficiaries | | frontier_send_eth | Send native ETH to any address (TxGate tracked) |

Config Tools: 4 tools

| Tool | Description | |------|-------------| | frontier_update_config | Change slippage, risk limits, gas settings | | frontier_update_tx_gate | Change spending limits, blacklist | | frontier_start_strategy | Start an automated trading strategy (requires wss:// RPC) | | frontier_stop_strategy | Stop a running strategy |

Transaction Gate

All write operations go through a security layer that enforces:

• Per-tx limit: rejects transactions above maxPerTxETH
• 24h budget: tracks rolling spend, blocks when the budget is exhausted
• Cooldown: minimum time between write operations
• Coin blacklist: blocks trades on known-bad coins
• Confirmation: high-value txs trigger a confirmation prompt (Frontier: <tool> — <eth> ETH …) if the OpenClaw channel supports it
• Confirmation timeout: on the strategy path, a confirmation callback that hangs longer than 20 seconds is treated as a decline: the reservation is settled with zero wei and the trade is skipped, so a stuck UI cannot starve the 24h budget
• Chain-id verification: the first write of an agent lifecycle verifies provider.getNetwork() against the configured chainId (Robinhood Chain 4663 by default) and refuses to submit the transaction on a mismatch

Defaults:

Max per tx:      1.0 ETH
24h budget:      5.0 ETH
Cooldown:        2 seconds
Confirm above:   0 ETH (disabled)

The agent can adjust these at runtime via frontier_update_tx_gate, within the ceilings set at startup.

Architecture

OpenClaw Gateway
  |
  +-- loads plugin via definePluginEntry().register(api)
  |     (typed helper from openclaw/plugin-sdk/plugin-entry)
  |
  +-- chain registry (from SDK): chainId -> RPC, addresses, API, explorer
  |
  +-- WalletManager (from SDK)
  |     +-- encrypted keystore (AES-256-GCM) [recommended]
  |     +-- env var (FRONTIER_PRIVATE_KEY)
  |     +-- auto-generate new wallet
  |
  +-- LaunchpadAgent (from SDK)
  |
  +-- ToolExecutor (from SDK, with TxGate + "frontier_" prefix)
  |     +-- TOOL_DEFINITIONS (84 tools)
  |     +-- TxGate (spending limits + confirmation)
  |
  +-- for (def of tools.getTools()) -> api.registerTool(...)
        +-- execute() delegates to ToolExecutor.execute()

The plugin is a thin adapter: it only handles OpenClaw-specific setup (chain selection, wallet resolution, config reading, tool registration loop) and complies with the official OpenClaw spec (activation.onStartup: true, top-level compatibility block, typed definePluginEntry entry point). All tool definitions, execution logic, and TxGate integration live in the SDK.

register() runs the one-shot initialization eagerly (wallet resolution, agent construction: credential and RPC errors surface at load time) and defers the only recurring activities, the 60 s coin-registry poller and the audit JSONL writer at ~/.frontier/audit, to the first tool invocation.

Example Conversations

User: "Check MITTENS and buy 0.2 ETH worth if it looks good"

Agent will:

1. Call frontier_get_token_state to evaluate price, TVL, launch mode, whether it trades on the curve or the pool
2. Call frontier_quote_buy (curve) or frontier_quote_pool_swap (pool) to see the expected coins for 0.2 ETH
3. Call frontier_buy_token to execute the trade (goes through TxGate, routes to the right venue)

User: "Launch a coin called Moon Cat with a Telegram group and a sniper tax for the first 10 minutes"

Agent will:

1. Call frontier_upload_image to pin the coin image
2. Call frontier_list_extensions to read the sniper-tax parameters
3. Call frontier_deploy_token with name, symbol, description, image, telegram, and extensions: [{ "id": "sniper-tax", "params": { "peakFee": 500000, "window": 600 } }]

User: "Add 0.05 ETH of liquidity to MITTENS and collect my fees next week"

Agent will:

1. Call frontier_get_pool_state to confirm the coin trades on its pool and read the price
2. Call frontier_add_liquidity with amount_eth_max, amount_token_max and a tick_preset
3. Later, call frontier_get_lp_positions and frontier_collect_fees

User: "Start the launch sniper strategy with 0.1 ETH"

Agent will:

1. Call frontier_start_strategy with { name: "LaunchSniper", mode: "moderate", config: { ethPerSnipe: "0.1" } } (needs a wss:// RPC)
2. Report status via frontier_get_strategy_status

Changes

See CHANGELOG.md for release notes. Latest: v1.1.0, the eight tools of the official extension set — recipient state, the permissionless calls that drive a lottery / buyback / splitter, and the pool fee schedules (84 tools total). The pre-port history is kept under its own heading in the changelog.

Development

From Monorepo Root

git clone https://github.com/CamelotLabs/frontier-sdk
cd frontier-sdk

pnpm install
pnpm build

# Link for local testing
openclaw plugins install -l ./packages/openclaw-plugin
openclaw plugins doctor

Standalone

cd packages/openclaw-plugin
pnpm install
pnpm build
openclaw plugins install -l .

Tests: pnpm -w run build:sdk && npx vitest run --project openclaw-plugin (unit tests only; no RPC is contacted).

License

MIT