@steerprotocol/cli

Operational CLI for Steer Protocol.

steer is built for both terminal users and agents. It exposes live protocol status, chain and protocol discovery, market inspection, liquidity depth analysis, ALM vault and parent-manifest inspection, artifact publication, and narrowly scoped unsigned transaction preparation through a single typed CLI surface. Preparation is unsigned by default; --web opens a loopback browser-wallet handoff for supported prepare commands. The CLI never receives a private key. Strategy and connector uploads plus manifest publication are explicit external writes to Steer's IPFS uploader.

Install

npm install -g @steerprotocol/cli

Or run it without installing:

npx @steerprotocol/cli status

Agent Installation

Install as a Skill (less tokens usage)

Generate and install skill files for agents that use skills:

steer skills add

This lets an agent discover steer from generated skill documentation instead of only from shell help.

Install as MCP

Register steer as an MCP server for your agent:

steer mcp add

Useful variants:

steer mcp add --agent cursor
steer mcp add --agent claude-code
steer mcp add --no-global

Start the CLI directly as an MCP stdio server:

steer --mcp

Discover Command Contracts

For agents and wrappers, steer also exposes:

• steer --llms --format json for the live command manifest
• steer <command> --schema --format json for typed command contracts
• steer <command> --json for machine-readable command output

Quick Start

steer status
steer chains --json
steer protocols --chain base --json
steer subgraphs --chain base --json
steer markets list --chain base --protocol uniswap --limit 5 --json
steer vaults list --chain base --type alm --limit 5 --json

For local development, create a .env from the example file and set your SDK key there:

cp .env.example .env

Commands

status

Show runtime health, environment, profile, and command-domain availability.

steer status --json --verbose

chains

List supported chains discovered from the Steer SDK.

steer chains --json

protocols

List supported protocol aliases, optionally narrowed to a chain.

steer protocols --chain base --json

subgraphs

List Steer chain subgraphs and protocol-specific subgraphs, optionally filtered by chain or protocol.

steer subgraphs --json
steer subgraphs --chain base --json
steer subgraphs --chain base --protocol aerodrome --json

markets list

List markets for a chain and protocol.

steer markets list --chain base --protocol uniswap --limit 10 --json

markets inspect

Inspect a single market or run batch liquidity depth analysis for multiple pools.

steer markets inspect 0xd0b53d9277642d899df5c87a3966a349a798f224 --chain base --protocol uniswap --json
steer markets inspect 0xd0b53d9277642d899df5c87a3966a349a798f224 --chain base --protocol uniswap --depth --json
steer markets inspect --chain base --protocol uniswap --depth --pools 0xpoolA,0xpoolB --json

Depth mode supports:

steer markets inspect <pool> --chain <chain> --protocol <protocol> --depth \
  --subgraph-key your-key \
  --rpc https://base-rpc.publicnode.com \
  --percent 1,2,5,10 \
  --usd-sizes 1000,5000,10000 \
  --prices auto

Override the env-configured key only when needed:

steer markets inspect 0xd0b53d9277642d899df5c87a3966a349a798f224 \
  --chain base \
  --protocol uniswap \
  --subgraph-key your-key \
  --json

markets profile

Load initialized liquidity around the live current tick for a single concentrated-liquidity pool.

steer markets profile 0xd0b53d9277642d899df5c87a3966a349a798f224 --chain base --protocol uniswap
steer markets profile 0xd0b53d9277642d899df5c87a3966a349a798f224 --chain base --protocol uniswap --words 3 --json

Pool lifecycle creation

markets remains read-only. Pool creation lives under the separate pools lifecycle group and currently supports Uniswap V3, SushiSwap V3, Uniswap V4, and Base Aerodrome Slipstream. Aerodrome uses its own verified factory flow.

Resolve write capability from the installed SDK registry before preparing:

steer pools support --chain robinhood --protocol sushi --json
steer pools support --chain robinhood --protocol uniswap --json
steer pools support --chain robinhood --protocol uniswap-v4 --json
steer pools support --chain base --protocol aerodrome --json

Preparation requires a chain-matched STEER_RPC_URL. It reads token decimals onchain, uses SDK 3.5 pool-lifecycle math and calldata, simulates as the exact eventual signer, and writes a new steer.pool-create-plan.v1 file without overwriting an existing path:

STEER_RPC_URL=https://your-robinhood-rpc.example \
steer pools create prepare \
  --chain robinhood \
  --protocol sushi \
  --base 0xBaseToken \
  --quote 0xQuoteToken \
  --price 2500.125 \
  --fee-tier 0.05 \
  --account 0xSigner \
  --out ./robinhood-sushi-pool.plan.json \
  --json

--price is an exact decimal in quote-token units per one base token; it never passes through JavaScript floating point. --fee-tier is an exact percentage, so 0.05 means 0.05% and raw SDK fee 500. Percentage input supports static V4 fees only; dynamic-fee V4 pools are outside the v1 surface. For V3, native resolves to the SDK's wrapped-native ERC-20. V4 represents native currency directly and also requires --tick-spacing and --hooks; use the zero address for a hookless pool.

Aerodrome is Base Slipstream only. Its factory uses token0, token1, and tickSpacing as the pool key and atomically creates and initializes the pool. Use a factory-enabled --tick-spacing; do not pass --fee-tier or --hooks.

The plan records human intent, registry deployment identity and provenance, the serialized SDK action, block-pinned token metadata, signer-aware simulation, a five-minute time-based wallet handoff expiry, and the unsigned transaction. Loading it revalidates and re-derives the SDK action before receipt verification. After a wallet submits the exact transaction, verify against receipt-block state:

STEER_RPC_URL=https://your-robinhood-rpc.example \
steer pools create verify 0xTransactionHash \
  --plan ./robinhood-sushi-pool.plan.json \
  --json

V3 verification returns the canonical pool address. V4 returns the exact PoolKey and PoolId, not a pool address. Add --web to preparation for the existing local browser-wallet handoff; the CLI never handles a private key. New pool plans use a five-minute wall-clock handoff expiry, so fast chains no longer consume the review window by advancing blocks. Legacy v1 plans containing validUntilBlock remain readable and verifiable. Time expiry is a CLI safety guard only; the transaction is not re-simulated if pool state changes and may still revert if another actor creates the pool first.

Strategy bundle publication

Validate, upload, and independently verify one strategy WASM bundle:

steer strategies upload ./artifacts/noop_strategy.wasm --json

The command accepts a regular .wasm file up to 10 MiB, rejects symbolic links, compiles the module locally, records its imports and exports, and hashes the bytes before upload. It posts the production uploader's multipart theFiles field and returns steer.strategy-bundle.v1 only after an IPFS gateway returns identical bytes. The output includes the CID, ipfs:// URI, SHA-256, byte length, and successful verification gateway.

Prepare a separate unsigned strategy registration transaction. The CLI detects the RPC chain and resolves its deployed StrategyRegistry from the installed SDK:

STEER_RPC_URL=https://your-chain-rpc.example \
steer strategies register prepare \
  --account 0xstrategyOwner \
  --bundle-cid Qm... \
  --name "No-op Strategy" \
  --max-gas-cost 900000000000 \
  --max-gas-per-action 3000000 \
  --json

The RPC chain is detected with eth_chainId. Registration is available when the installed SDK provides a valid StrategyRegistry deployment for that chain, including Base and Robinhood Chain. Preparation checks live bytecode and registry state, rejects duplicate bundles or excessive gas limits, and simulates createStrategy. It returns steer.transaction.v1 without signing or broadcasting. Upload and registration are intentionally separate so the uploaded bytes and CID can be reviewed before any onchain action.

Browser-wallet submission

Add --web to a supported preparation command to submit the exact prepared transaction through MetaMask or another injected browser wallet:

STEER_RPC_URL=https://rpc.mainnet.chain.robinhood.com \
steer strategies register prepare \
  --account 0xstrategyOwner \
  --bundle-cid QmTLpvK5Ji8giSEHrvRpxjfUTeJRBQwrBacyAMwnEZNaKo \
  --name "No-op Strategy" \
  --max-gas-cost 900000000000 \
  --max-gas-per-action 3000000 \
  --web --format json

The command starts a temporary 127.0.0.1:4733 server, prints a one-time URL (and opens it when run from an interactive terminal), then waits. If that port is occupied, it tries only 4734 through 4742. Its session token lives in the URL fragment, so the fragment is not included in browser navigation or a wallet request; the page sends it only in a same-origin header to the loopback server. The page checks the selected account and network, requests the exact prepared calldata through the wallet, and returns the transaction hash to the CLI. The CLI independently checks the submitted signer, target, calldata, and value against the preparation before invoking the existing receipt verifier.

Supported commands are pools create prepare, strategies register prepare, connectors register prepare, vaults create prepare, vaults deposit prepare, vaults tend prepare, and vaults withdraw prepare. The successful result is steer.wallet-handoff.v1 with the original preparation, transaction hash, and canonical verification. If confirmation is still pending after two minutes, it returns status: "pending" with the exact recovery command. The local server closes after verification, cancellation, pending completion, or a ten-minute unsigned-session timeout.

Inspect a registered strategy by token ID or execution-bundle CID, then verify a submitted registration without resubmitting it:

STEER_RPC_URL=https://your-rpc.example steer strategies inspect 8 --json
STEER_RPC_URL=https://your-rpc.example steer strategies register verify 0xTransactionHash --json

Inspection returns steer.strategy.v1 only after matching live registry state to the registered CID and exact-byte verifying and compiling the downloaded WASM. It never executes the module.

Data connector publication and registration

A connector release has two immutable artifacts: runtime WASM and registry metadata. Create connector.json beside the build output:

{
  "schemaVersion": "steer.data-connector-info.v1",
  "name": "Robinhood stock token price",
  "description": "Reads a configured stock-token reference price.",
  "version": "1.0.0",
  "source": "RobinhoodStockToken",
  "host": "api.robinhood.com",
  "output": "SingleValue"
}

Validate locally, then explicitly publish both files:

steer connectors validate ./build/release.wasm --info ./connector.json --json
steer connectors upload ./build/release.wasm --info ./connector.json --json

Validation compiles the WASM, checks connector runtime compatibility, and validates metadata without executing connector HTTP requests. Upload performs two IPFS writes and exact-byte verifies both CIDs. It does not write onchain.

Register the reviewed CIDs on the RPC chain:

STEER_RPC_URL=https://your-chain-rpc.example \
steer connectors register prepare \
  --account 0xconnectorAuthor \
  --bundle-cid QmWasmCid \
  --info-cid QmMetadataCid \
  --web --format json

STEER_RPC_URL=https://your-chain-rpc.example steer connectors register verify 0xTransactionHash --json
STEER_RPC_URL=https://your-chain-rpc.example steer connectors inspect 0xRegistryKey --json

The CLI resolves BundleRegistry from the installed SDK, including Base and Robinhood Chain. It derives source, host, and output only from the verified metadata, computes the deterministic key, rejects paused or duplicate registrations, and simulates the exact register call. Connectors are active by default; use --inactive to register one disabled. Registry keys are chain-local bytes32 records, not numeric strategy token IDs. The deployed registries require the runtime bundle identifier to be a 46-character CIDv0; the CLI reports that incompatibility before simulation.

Chain-local curated no-op tokens

The curated no-op is a registry token, not a portable strategy name or CID. Select it by chain: the same WASM CID is registered under different token IDs on Base and Robinhood Chain.

| Chain | Token ID | Registry | Use | | ------------------------ | -------- | -------------------------------------------- | ------------------------------------------------------------- | | Base Mainnet (8453) | 38 | 0x317EEDB54711681056f37e10d5DE0B55455b476f | Base curated vaults | | Robinhood Chain (4663) | 9 | 0xAc7D3A933c44b4D4bad6D5F0685900482E0d995E | Robinhood curated planning and registry verification |

Both tokens are No-op Strategy records for QmTLpvK5Ji8giSEHrvRpxjfUTeJRBQwrBacyAMwnEZNaKo, with maxGasCost 900000000000 and maxGasPerAction 3000000. They are only for direct external management: do not use either one for Steer-managed automation.

Verify the live record before relying on it:

STEER_RPC_URL=https://base-mainnet.g.alchemy.com/public steer strategies inspect 38 --format json
STEER_RPC_URL=https://rpc.mainnet.chain.robinhood.com steer strategies inspect 9 --format json

Any prepared approval, deposit, tend, withdrawal, or strategy registration can be recovered through the generic receipt verifier:

STEER_RPC_URL=https://your-rpc.example steer transactions verify 0xTransactionHash --json
STEER_RPC_URL=https://your-trace-rpc.example steer transactions verify 0xTransactionHash --trace --json

Pending or not-yet-indexed hashes are retryable. Successful results decode the submitted action and require its action-specific events and onchain postconditions before returning steer.transaction-receipt.v1. --trace requires debug_traceTransaction with callTracer support and returns bounded steer.transaction-verification.v3 diagnostics for successful or reverted supported actions, including internal calls, gas, decoded errors, and postcondition verification status.

vaults list

List ALM vaults for a chain, optionally filtered by protocol or active status.

steer vaults list --chain base --type alm --active --limit 10 --json

vaults inspect

Inspect a vault, including its underlying pool, fees, holdings, valuation, a nested gas summary, tick range, positions, and live in-range status derived from the current pool tick.

steer vaults inspect 0x62e9efb617dc886c4d31633371ede096aaecc2f8 --chain base --type alm --json

Vault parent manifests

Inspect the complete selected strategy configuration, vault payload, and data connector configuration by vault address or CID:

STEER_RPC_URL=https://your-base-rpc.example \
steer vaults manifest inspect 0x666805942995ff8494294720a1dadb7cd2348750 --json

steer vaults manifest inspect QmR75qiqjs55dhSnyyYGyvtsUgjToCrzwuwEJmYWMaenb1 --json

Address inspection also resolves the vault share name/symbol and registered strategy. CID inspection is RPC-free. Both return the exact verified parent manifest as steer.vault-manifest.v1; downloaded WASM is never executed.

Publish a complete edited JSON file against its live target context:

STEER_RPC_URL=https://your-rpc.example \
steer vaults manifest publish ./manifest.json \
  --pool 0xPoolAddress --protocol uniswap-v3 --management steer --json

Publication accepts a regular non-symbolic-link file up to 1 MiB, validates a single in-memory snapshot against fresh chain facts, posts those exact bytes, and returns only after an IPFS gateway confirms their byte length and SHA-256.

Manifest-only vault creation

manifest.json is the only local lifecycle artifact. init creates it, validate rechecks fresh chain facts, publish uploads those exact bytes, and create prepare fetches the CID, revalidates, TEVM-simulates, and returns an unsigned transaction. No project directory, lockfile, or clone descriptor is created.

The enabled creation matrix is explicit:

| Chain | Protocol | Curated | Steer | Curated no-op token | | --- | --- | --- | --- | --- | | Base (8453) | Aerodrome Slipstream | Yes | Yes | 38 | | Base (8453) | Uniswap V3 | Yes | Yes | 38 | | Base (8453) | Sushi V3 | Yes | Yes | 38 | | Robinhood (4663) | Uniswap V3 | Yes | Yes | 9 | | Robinhood (4663) | Sushi V3 | Yes | Yes | 9 | | Robinhood (4663) | Uniswap V4 | Yes | Yes | 9 |

For a curated V3 vault, use a V3 pool address and direct manager:

steer vaults init --pool 0xPoolAddress --protocol uniswap-v3 \
  --management curated --out ./manifest.json --json
steer vaults manifest publish ./manifest.json --pool 0xPoolAddress --protocol uniswap-v3 \
  --management curated --json
steer vaults create prepare --manifest-cid <cid> --pool 0xPoolAddress --protocol uniswap-v3 \
  --management curated --account 0xManager --json

For Base Aerodrome Slipstream, use --protocol aerodrome with an initialized Slipstream pool address. The initializer identifies the pool by its factory-enabled tick spacing; vaultPayload.fee is the corresponding factory fee and is retained for strategy context.

steer vaults init --pool 0xAerodromePool --protocol aerodrome \
  --management curated --out ./manifest.json --json
steer vaults manifest publish ./manifest.json --pool 0xAerodromePool --protocol aerodrome \
  --management curated --json
steer vaults create prepare --manifest-cid <cid> --pool 0xAerodromePool --protocol aerodrome \
  --management curated --account 0xManager --json

For a curated Robinhood Uniswap V4 vault, pass the bytes32 Pool ID. The CLI recovers and verifies the complete PoolKey, derives the manifest payload, pins the Robinhood no-op strategy token 9, and assigns --account as the direct manager with zero GasVault funding:

steer vaults init --pool 0xV4PoolId --protocol uniswap-v4 \
  --management curated --out ./manifest.json --json
steer vaults manifest publish ./manifest.json --pool 0xV4PoolId --protocol uniswap-v4 \
  --management curated --json
steer vaults create prepare --manifest-cid <cid> --pool 0xV4PoolId --protocol uniswap-v4 \
  --management curated --account 0xManager --json

For a Steer-managed V3 or Robinhood Uniswap V4 vault, pass a strategy-template vault to init only. init executes the candidate against that template, then writes the template's chain, StrategyRegistry token ID, and execution-bundle CID into the manifest. The template address is not written to the manifest and is not accepted by later lifecycle commands. Every Steer-managed creation requires an explicit nonzero GasVault reserve:

steer vaults init --pool 0xPoolAddress --protocol uniswap-v3 --vault 0xTemplateVault \
  --management steer --out ./manifest.json --json
steer vaults manifest publish ./manifest.json --pool 0xPoolAddress --protocol uniswap-v3 \
  --management steer --json
steer vaults create prepare --manifest-cid <cid> --pool 0xPoolAddress --protocol uniswap-v3 \
  --management steer --account 0xSigner --gas-deposit-wei <nonzero-wei> --json

Use --protocol sushi-v3 for an approved Sushi V3 pool. Use --protocol uniswap-v4 with the Robinhood bytes32 Pool ID for the V4 variant. Aerodrome vault creation is Base only. The configured RPC selects Base or Robinhood; there is no separate chain flag.

Run steer vaults create verify <transaction-hash> --json after submission. Simulation requires an RPC with eth_getProof at its pinned block; init and validation only require ordinary RPC reads. Every newly prepared transaction uses a five-minute wall-clock handoff expiry. The simulation block remains for auditability, but fast chains do not consume the wallet review window.

vaults gas inspect

Inspect the live gas-vault balance snapshot for a vault.

steer vaults gas inspect 0x62e9efb617dc886c4d31633371ede096aaecc2f8 --chain base --type alm --json

vaults gas history

Inspect recent gas usage history for a vault, including spend totals, tend cadence, and runway estimates.

steer vaults gas history 0x62e9efb617dc886c4d31633371ede096aaecc2f8 --chain base --type alm --window 7d --json

vaults fees history

Inspect historical accrued fee deltas for a vault in raw token units.

steer vaults fees history 0x62e9efb617dc886c4d31633371ede096aaecc2f8 --chain base --type alm --window 7d --json

Vault transaction preparation (preview)

Prepare one exact approval or protected deposit action at a time:

steer vaults deposit prepare 0xvault \
  --account 0xsigner \
  --amount0-desired 1000000 \
  --amount0-min 990000 \
  --amount1-desired 1000000000000000 \
  --amount1-min 990000000000000 \
  --chain base \
  --json

Quote a complete multi-position replacement on any rebalance-enabled network. The chain is detected from the RPC. Repeat --position for every range; relative weights are positive uint16 values and do not need to sum to 10,000:

For a vault backed by a registered strategy, first run its complete parent manifest, data connectors, and strategy WASM against one SDK-resolved context:

STEER_RPC_URL=https://your-rpc.example \
steer vaults tend plan 0xvault --json

To preview an editable Steer-managed manifest before publishing it, run its connector and strategy bundles against the target pool:

STEER_RPC_URL=https://your-rpc.example \
steer vaults manifest preview ./manifest.json --pool 0xtargetPool --protocol uniswap-v3 --json

This reads the pool at one block and runs with zero balances and no existing positions. It does not publish the manifest, prepare a transaction, or change onchain state.

The default epoch is derived from strategyConfigData.epochStart and epochLength at the pinned block. Use --block and --epoch-timestamp for an exact replay. The returned positions are a plan only; review them and pass the approved complete set to tend quote before preparing a transaction.

STEER_RPC_URL=https://your-proof-capable-rpc.example \
steer vaults tend quote 0xvault \
  --account 0xmanager \
  --position=-600:0:2 \
  --position=0:600:1 \
  --slippage-bps 100 \
  --total-weight 10000 \
  --json

Prepare the same replacement from a newly pinned head:

steer vaults tend prepare 0xvault \
  --account 0xmanager \
  --position=-600:0:2 \
  --position=0:600:1 \
  --slippage-bps 100 \
  --total-weight 10000 \
  --json

Both commands remove the vault's own liquidity on an isolated TEVM fork before quoting, then execute the complete proposed tend on a second clean fork. They fail closed on quote or final-simulation errors. --skip-swap is the only path that explicitly encodes (0,0). Uniswap v4 also requires --pool-key=<currency0>:<currency1>:<fee>:<tickSpacing>:<hooks>.

If a wallet simulation rejects an already prepared tend, replay its exact unsigned calldata without broadcasting it:

STEER_RPC_URL=https://your-rpc.example \
steer vaults tend diagnose 0xvault \
  --account 0xmanager \
  --data 0xpreparedCalldata \
  --prepared-block <prepare-simulation-block> \
  --json

The diagnostic is steer.vault-tend-diagnosis.v1. It reports the replay block, decoded tend, vault and pool evidence, implementation runtime hash, verified source profile, raw revert data, confidence, and remediation. Semantic classification is enabled only when the live implementation hash matches a checked-in verified profile. Base Aerodrome Slipstream profiles cover the deployed aerodrome, aerodrome-v2, and aerodrome-v3 managers. They identify only direct verified manager errors: authorization, pause, invalid total weight or swap amount, ordered positions, and post-tend residual guards. Pool, helper, token, unknown, and unmatched-runtime reverts remain TEND_REVERT_UNKNOWN; the CLI never applies Uniswap V3 revert semantics to Aerodrome. All other implementations, including V4, retain raw evidence without an invented semantic explanation.

SPL receives special treatment. When the call succeeds at --prepared-block but fails at the target block, the result is a likely stale directional price limit and recommends running tend prepare again immediately before wallet submission.

Prepare a protected direct withdrawal:

steer vaults withdraw prepare 0xvault \
  --account 0xshareOwner \
  --amount0-min 990000 \
  --amount1-min 990000000000000 \
  --chain base \
  --shares 1000000000000000000 \
  --json

Each command reads current on-chain state, simulates from the expected signer, and returns one Bankr-compatible unsigned request with a five-minute wall-clock expiry. Transaction submission is not included.

Useful built-ins:

• --json for machine-readable command output
• --schema for command contracts
• --llms for the live command manifest
• --mcp for MCP server mode
• completions for shell completions

Environment

The public read surface uses a small runtime env surface:

| Variable | Purpose | | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | STEER_PROFILE | Active profile name | | STEER_ENVIRONMENT | Runtime environment, defaults to development | | STEER_SUBGRAPH_STUDIO_KEY | Primary The Graph Studio key for SDK-backed reads | | STEER_RPC_URL | Chain-detected RPC for pool lifecycle preparation/verification, strategy execution context, registration preparation, receipt verification, proof-capable creation simulation, and rebalance quoting |

Notes:

• set STEER_SUBGRAPH_STUDIO_KEY in your shell or .env for normal local and CI usage
• --subgraph-key is available as a one-off override for agents and debugging
• vaults commands do not require a vault-specific env var
• markets inspect --depth uses a vendored public RPC by default
• --rpc overrides the depth RPC per invocation
• STEER_RPC_URL must support eth_getProof; quote errors redact the URL and mark rate limits retryable
• transactions verify --trace additionally requires debug_traceTransaction with the callTracer tracer; it fails explicitly when tracing is unavailable
• vaults tend plan requires ordinary historical contract reads; its onchain context is block-pinned, while connector HTTP and subgraph responses are external data
• strategy and connector registration preparation require a chain RPC with the corresponding SDK-configured registry; neither requires eth_getProof
• registered-strategy inspection and submitted-receipt verification require an RPC for the transaction's chain; neither command writes onchain
• vault-address manifest inspection, manifest publication, and creation receipt verification require an RPC for the relevant chain; vaults create prepare additionally requires eth_getProof support for its TEVM simulation; direct CID inspection does not
• rebalance quoting accepts Ethereum (1), Optimism (10), Flare (14), BSC (56), Polygon (137), Robinhood Chain (4663), Base (8453), and Arbitrum (42161) RPCs
• the SDK-backed protocol matrix is: Ethereum (Uniswap, Sushi, Cypher, Uniswap v4); Optimism (Uniswap, Sushi); Flare (Spark Integral); BSC (Uniswap, Sushi, Uniswap v4); Polygon (Uniswap, Sushi, QuickSwap Integral); Robinhood Chain (Uniswap); Base (the existing twelve aliases); and Arbitrum (Uniswap, Sushi, Camelot, Uniswap v4)
• Robinhood Chain discovery also exposes SDK-backed Sushi and Uniswap v4 metadata, but those rebalance adapters remain unavailable until pinned fixtures pass
• market fee history is intentionally deferred because the current SDK/subgraph surface does not expose exact historical market fee snapshots

Output Model

The CLI returns structured envelopes rather than ad hoc terminal text. Most commands are read-only; strategy and connector uploads plus manifest publication are explicit offchain writes. Transaction preparation returns simulated unsigned requests by default; adding --web uses a user-controlled browser wallet and waits for canonical receipt verification.

Notable behavior:

• markets inspect --depth adds a depth block for single-pool inspection
• batch depth returns { markets, failures }
• vaults inspect includes nested holdings, valuation, and gas blocks, plus positions
• vaults inspect computes inRange from the live pool tick
• vaults inspect exposes vault-level valuation.totalValueLockedUsd, while pool.totalValueLockedUsd remains pool-level metadata from the underlying pool
• vaults gas inspect returns the gas-vault state for a single vault
• vaults gas history combines the live gas-vault balance with up to 1000 recent gas events from the Steer subgraph for the selected window
• vaults list stays summary-oriented and does not include positions
• vaults deposit|tend|withdraw prepare return one simulated action at a time with the expected signer and postconditions
• vaults tend quote returns steer.rebalance-quote.v1; vaults tend prepare embeds that diagnostic in steer.transaction.v1
• vaults tend plan returns steer.vault-tend-plan.v1 with the pinned strategy context, verified artifacts, connector outputs, validated proposed positions, and a bounded redacted trace from the isolated strategy runtime
• vaults manifest preview returns steer.vault-manifest-preview.v1 for a local Steer-managed manifest, including its connector outputs and proposed positions against a block-pinned target pool with zero balances and no existing positions
• vaults manifest inspect|upload return byte-verified steer.vault-manifest.v1
• vaults create prepare returns steer.vault-manifest-preparation.v1; vaults create verify returns steer.vault-create-receipt.v1
• strategies upload returns a byte-verified steer.strategy-bundle.v1
• strategies inspect returns a registry-matched, byte-verified steer.strategy.v1
• strategies register prepare returns a simulated steer.transaction.v1 for StrategyRegistry.createStrategy
• connectors validate returns steer.data-connector-validation.v1 without external writes or connector execution
• connectors upload returns steer.data-connector-publication.v1 after exact-byte verification of both artifacts
• connectors inspect returns a registry-matched, byte-verified steer.data-connector.v1
• connectors register prepare returns a simulated steer.transaction.v1 for BundleRegistry.register
• every supported prepare --web command returns steer.wallet-handoff.v1 only after verification, or a retryable pending result with a recovery command
• strategies register verify and default transactions verify return steer.transaction-receipt.v1 only after receipt postconditions pass; transactions verify --trace returns bounded onchain execution diagnostics as steer.transaction-verification.v3

Local Development

pnpm install
pnpm dev -- --help
pnpm build
pnpm test
pnpm coverage

Development entrypoints are split intentionally:

• src/index.ts is the executable bin wrapper used by pnpm dev, the published package bin, and shell-level smoke tests
• src/cli.ts exports the import-safe command graph used by programmatic tests and future incur tooling

Pinned rebalance forks

The rebalance suite has a TEVM gate and a guarded TEVM-versus-Anvil integration test. Base remains pinned to block 49251269 and vault 0x666805942995ff8494294720a1dadb7cd2348750; Polygon is pinned to block 91065333 and QuickSwap Integral vault 0x0a0359405fea59e8d4562c6c17b9b2d823457196; Ethereum is pinned to block 25637892 and Uniswap vault 0x5f7d3acba0f6f48a175dd8ebb90c3f846b54e719; Robinhood Chain is pinned to block 24495447 and Uniswap vault 0x1cdb7f5f3bd739c1062b414d26e1dd3bf411f9f9. For Base parity, start Anvil in one terminal:

anvil \
  --fork-url "$STEER_RPC_URL" \
  --fork-block-number 49251269 \
  --chain-id 8453

Then run the lifecycle test in another:

STEER_RPC_URL=https://your-proof-capable-base-rpc.example pnpm test:tevm

STEER_RPC_URL=https://your-proof-capable-polygon-rpc.example pnpm test:tevm

STEER_RPC_URL=https://your-proof-capable-ethereum-rpc.example pnpm test:tevm

STEER_RPC_URL=https://your-proof-capable-robinhood-rpc.example pnpm test:tevm

# This uses a local TEVM fork and prepares an unsigned V4 creation only.
STEER_RPC_URL=https://your-proof-capable-robinhood-rpc.example \
  pnpm test:vaults:robinhood:tevm

STEER_RPC_URL=http://127.0.0.1:8545 pnpm test:parity

The parity test refuses non-local Anvil URLs. Together, these suites verify chain ID, starting block, successful TEVM empty/final tends, self-liquidity removal, exact replacement positions, encoded swap diagnostics, Snapshot and pool Swap events, token deltas and residual balances, and unchanged GasVault balances. The TEVM matrix pins representatives for the eleven currently discoverable deployed Base aliases plus Polygon QuickSwap Integral and executes each representative in an isolated process. Ten Base fixtures pass at block 49251269. Kinetix remains fail-closed and release-gated because its only deployed Base pool has zero active liquidity at every proof-backed block tested. Polygon support is limited to Uniswap, Sushi, and QuickSwap Integral. Ethereum, Optimism, Flare, BSC, Robinhood Chain, and Arbitrum now resolve through the installed SDK and built-in TEVM chain configurations without changing the quote kernel. The Ethereum Uniswap fixture passes both pinned TEVM suites and exercises a non-zero one-for-zero automatic swap. Robinhood uses a custom TEVM common because viem and TEVM do not yet ship a built-in chain definition. Its pinned Uniswap fixture is configured but remains release-gated until a proof-capable archive RPC completes the suite. Optimism, Flare, BSC, Arbitrum, and the other newly configured protocol aliases remain gated on pinned proof-backed vault fixtures. Uniswap v4 remains a separate release gate on every configured network until a deployed vault and its authoritative complete pool key can be pinned without guessing.

Docs for the CLI live in docs/README.md.

The full bundled distribution and its measured 512 MiB install proof are documented in docs/content/docs/cli/packaging.mdx. Run pnpm test:packaging to recreate the quota-backed packed-install and command-help smoke test on Linux. macOS intentionally exits non-zero because the quota-backed APFS fixture is not supported.

For Maintainers

The CLI implementation is intentionally thin:

• commands own UX, examples, and schemas
• middleware owns runtime setup
• services own SDK integrations and live reads

If you need to update behavior, check these first:

• src/cli.ts
• src/index.ts
• src/commands
• src/runtime.ts
• src/services/contracts.ts

CLI tests intentionally isolate STEER_* environment variables instead of inheriting your shell state. When reproducing a test case locally, set the runtime env explicitly.

Bittensor EVM (chain 964) operations, verified Tensora replacement examples, RPC simulation requirements and remaining deployment inputs are documented in the Bittensor support runbook.