`@baseline-markets/cli` is the Baseline command-line interface for launching
Baseline tokens, inspecting deployments, and installing agent skills.

It exposes two Baseline commands:

* `baseline launch` builds wallet-compatible launch calls for a new Baseline
  token.
* `baseline info` inspects a deployed Baseline token.

It also exposes `baseline skills add`, which installs packaged Baseline agent
skills for agents that can run shell commands.

Use the CLI when you want an unsigned launch artifact before approving anything.
Use the [SDK](/docs/contracts/sdk) when you are building launch, swap, stake,
borrow, or leverage flows directly into an app with viem clients.

<Callout type="info">
  By default, the CLI prepares unsigned calls. You can hand those calls to a
  wallet, an agent flow, or another execution layer before anything is signed.
</Callout>

## Install Agent Skills

If your agent supports skills, install the Baseline skills into its environment:

```bash
npx @baseline-markets/cli@latest skills add
```

This installs the packaged Baseline skills, including general CLI workflow
guidance, generated `launch` and `info` command references, and a Base MCP
launch flow for agents that use Base Account approval.

After installing the skills, you can ask your agent to use the Baseline CLI to
prepare a launch, inspect a token, or follow the Base MCP flow when Base MCP is
available.

For Base MCP specifically, the `base-mcp-baseline` skill tells the agent how to
prepare unsigned calls, validate the artifact, submit the calls through
`send_calls`, show the Base Account approval link, and poll request status after
approval.

## Build Launch Calls

`baseline launch` builds a launch artifact with `chain`, `account`, `bToken`,
and ordered `calls`.

```bash
npx @baseline-markets/cli@latest launch \
  --mode zrp \
  --chain-id 84532 \
  --account 0x0000000000000000000000000000000000000001 \
  --name "Example Baseline Token" \
  --symbol EBT \
  --reserve 0xB85885897D297000A74eA2e4711C3Ca729461ABC \
  --total-supply 1000000000 \
  --output .context/launches/example-launch.json
```

The output artifact is a superset of the Base MCP `send_calls` payload:

```json
{
  "chainId": 84532,
  "chain": "base-sepolia",
  "account": "0x0000000000000000000000000000000000000001",
  "bToken": "0xBToken",
  "calls": [
    { "to": "0xTarget", "data": "0xCalldata", "value": "0x0" }
  ]
}
```

For external executors, submit `artifact.chain` and `artifact.calls` exactly as
emitted. Keep `chainId`, `account`, and `bToken` for validation and reporting.

For Base MCP, this maps directly to `send_calls`.

## Launch Modes

### ZRP

`zrp` is the default zero-reserve pool launch mode. It mints the full BToken
supply straight into the pool and starts without an initial reserve seed, so
the deployer needs no balance or approvals.

The artifact contains a single call: Relay `launch`.

Use `--initial-fdv` to set the launch valuation — the fully diluted valuation
in reserve units, quoted when circulating supply first exits the frozen zone
(5% of supply). It defaults to the protocol minimum.

### Standard

`standard` launches with reserve liquidity. It requires both initial pool
BTokens and initial pool reserves:

```bash
npx @baseline-markets/cli@latest launch \
  --mode standard \
  --chain-id 84532 \
  --account 0x0000000000000000000000000000000000000001 \
  --name "Example Baseline Token" \
  --symbol EBT \
  --reserve 0xB85885897D297000A74eA2e4711C3Ca729461ABC \
  --total-supply 1000000000 \
  --initial-pool-btokens 900000000 \
  --initial-pool-reserves 1 \
  --output .context/launches/example-launch.json
```

The call order is:

1. Relay `createBToken`
2. BToken approval to the Relay
3. Reserve token approval to the Relay
4. Relay `createPool`

## Launch Flags

| Flag                      | Description                                                                                                                 |
| ------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| `--mode`                  | Launch mode: `zrp` or `standard`. Defaults to `zrp`.                                                                        |
| `--chain-id`              | Chain ID for the launch calls. Defaults to Base Sepolia `84532`.                                                            |
| `--rpc-url`               | Optional RPC URL for read calls.                                                                                            |
| `--account`               | Deployer address. Required unless using `--execute`.                                                                        |
| `--name`                  | BToken name.                                                                                                                |
| `--symbol`                | BToken symbol.                                                                                                              |
| `--reserve`               | Reserve token address.                                                                                                      |
| `--total-supply`          | Total BToken supply in token units.                                                                                         |
| `--initial-pool-btokens`  | Initial BTokens deposited into the pool for `standard` launches.                                                            |
| `--initial-pool-reserves` | Initial reserve amount for `standard` launches.                                                                             |
| `--initial-fdv`           | Launch FDV for `zrp` launches, in reserve units at the frozen-zone exit (5% circulating). Defaults to the protocol minimum. |
| `--creator`               | Creator address. Defaults to `--account`.                                                                                   |
| `--fee-recipient`         | Address receiving the creator share of swap fees. Defaults to creator.                                                      |
| `--creator-fee-pct`       | Creator share of swap fees, from `0` to `100`. Defaults to `50`; the remaining share goes to stakers.                       |
| `--swap-fee-pct`          | Swap fee charged by the pool. Defaults to `1`.                                                                              |
| `--salt`                  | Optional bytes32 salt.                                                                                                      |
| `--reserve-decimals`      | Reserve token decimals. Defaults to `18`.                                                                                   |
| `--execute`               | Execute the launch calls with a private key signer.                                                                         |
| `--private-key`           | Private key for `--execute`. Falls back to `BASELINE_PRIVATE_KEY`.                                                          |
| `--output`                | Optional path to write the JSON artifact.                                                                                   |

## Supported Chains

Use the chain ID and reserve token for the selected network:

| Network          | `--chain-id` | Artifact `chain` | Primary reserve                                    |
| ---------------- | ------------ | ---------------- | -------------------------------------------------- |
| Ethereum mainnet | `1`          | `ethereum`       | WETH `0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2`  |
| Base mainnet     | `8453`       | `base`           | WETH `0x4200000000000000000000000000000000000006`  |
| Base Sepolia     | `84532`      | `base-sepolia`   | WETH `0xB85885897D297000A74eA2e4711C3Ca729461ABC`  |
| HyperEVM         | `999`        | `HyperEVM`       | WHYPE `0x5555555555555555555555555555555555555555` |
| Robinhood Chain  | `4663`       | `robinhood`      | WETH `0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73`  |

Robinhood also supports USDG (`0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168`) as a reserve token.

Treat Ethereum mainnet, Base mainnet, HyperEVM, and Robinhood Chain as production. Confirm the chain, token
name, symbol, supply, reserve, fees, creator, and fee recipient before
submitting calls.

## Base MCP Handoff

When using Base MCP, keep the CLI in unsigned mode and submit only the artifact
fields Base MCP needs:

```json
{
  "chain": "base-sepolia",
  "calls": [
    { "to": "0xTarget", "data": "0xCalldata", "value": "0x0" }
  ]
}
```

Use `artifact.chain` directly and preserve call order. Do not include
`artifact.account` in the `send_calls` payload; Base MCP uses the connected
Base Account session for approval and execution.

## Execute Locally

By default, `baseline launch` only builds unsigned calls. Execute locally only
when you explicitly want the CLI to submit transactions with a private key:

```bash
BASELINE_PRIVATE_KEY=0x... npx @baseline-markets/cli@latest launch \
  --execute \
  --mode zrp \
  --chain-id 84532 \
  --name "Example Baseline Token" \
  --symbol EBT \
  --reserve 0xB85885897D297000A74eA2e4711C3Ca729461ABC \
  --total-supply 1000000000
```

Do not use `--execute` when another execution layer is responsible for approval
and submission. Base MCP, for example, consumes the unsigned `calls` artifact
and handles user approval through Base Account.

## Inspect A Token

After a launch completes, inspect the bToken:

```bash
npx @baseline-markets/cli@latest info 0xBToken --chain-id 84532
```

Use `--format json` for structured output:

```bash
npx @baseline-markets/cli@latest info 0xBToken --chain-id 84532 --format json
```

## Safety Boundaries

* Prefer unsigned artifacts for agent-assisted or externally executed launches.
* Do not give an agent a private key unless the user explicitly chooses local
  CLI execution and understands the signer boundary.
* Preserve the emitted call order and calldata.
* Validate `account`, `chainId`, `chain`, and `calls` before submission.
* `zrp` artifacts should have one call; `standard` artifacts should have
  four calls.
* Ambiguous failures should be recovered from by reading on-chain state before
  retrying.
