Skip to content

Developer Security Infrastructure

Agent Transaction Firewall

Protect every transaction, learn from execution history, and continuously improve how capital is deployed. Policy-enforced execution with built-in intelligence for bot developers and AI agents on Solana.

atf trade

When you run this: ATF evaluates a trade, shows the decision, and generates a receipt. No real transaction is submitted.

Start Here

Four commands. From first trade to verified receipt.

Install globally with npm install -g @trucore/atf@1.5.1, or on macOS/Linux run without installing with npx @trucore/atf@1.5.1. Installation details →

1. Try a protected trade

atf trade

When you run this: ATF evaluates a trade, shows the decision, and generates a receipt. No real transaction is submitted.

2. Connect your API key

atf setup

Interactive setup. No manual .env editing needed.

3. Diagnose your environment

atf doctor

Checks config, RPC, wallet, and environment in one pass.

4. Verify and share a receipt

atf verify <receipt-id>

Verify integrity. Share with human-readable text or bot-friendly output.

Demo mode

  • No wallet required
  • No on-chain execution
  • Simulated protected trade

Real mode

  • Requires setup (atf setup)
  • Executes on Solana mainnet
  • Enforced by ATF policy

Each command produces dual-surface output: clear terminal messages for operators and structured JSON for automation.

Run This First

One command tells you everything about your environment.

Run directly with npx.

Doctor

npx @trucore/atf@1.5.1 doctor --pretty

What it checks

  • Active profile and configuration
  • RPC provider connectivity and latency
  • Signer/wallet presence and type
  • Network selection (devnet/mainnet)
  • Environment variables and paths
  • CLI and Node.js versions

Example output

{
  "ok": true,
  "profile": "devnet-burner",
  "network": "devnet",
  "rpc": { "provider": "helius", "latency_ms": 87 },
  "wallet": { "present": true, "type": "burner", "pubkey": "9x…kP" },
  "receipts": { "verify_ready": true },
  "versions": { "cli": "1.5.1", "node": "20.x" }
}

No secrets leaked. Private keys, API tokens, and RPC credentials are redacted from all output by default.

Doctor runs locally. Secrets are never uploaded.

Devnet Burner Quickstart

Go from zero to a verified devnet setup in five commands. Burner mode switches your active profile to devnet so you never risk real keys.

First time

Run directly with npx. No install needed.

1. Create a devnet burner profile

npx @trucore/atf@1.5.1 profile create devnet-burner --network devnet

2. Select the profile

npx @trucore/atf@1.5.1 profile select devnet-burner

3. Enable burner mode

npx @trucore/atf@1.5.1 burner enable

4. Verify setup

npx @trucore/atf@1.5.1 doctor --pretty

Use again later

1. Select the profile

npx @trucore/atf@1.5.1 profile select devnet-burner

2. Enable burner mode

npx @trucore/atf@1.5.1 burner enable

3. Verify if needed

npx @trucore/atf@1.5.1 doctor --pretty

Already created this profile?

If you see Profile "devnet-burner" already exists., skip profile creation and jump to Use again later above.

Next: try a transaction

Once burner mode is active, simulate and send a devnet transaction.

1. Sign and send a small transaction

npx @trucore/atf@1.5.1 tx sign --preset swap_small | npx @trucore/atf@1.5.1 tx send

2. Verify the receipt

npx @trucore/atf@1.5.1 receipts verify --last

Helius Setup: Profiles + Secrets + RPC Ping

ATF is Helius-first. Set your RPC endpoint through a named profile and secrets are never echoed to stdout.

Run directly with npx.

1. Create a production profile

npx @trucore/atf@1.5.1 profile create prod --network mainnet-beta

2. Set your Helius RPC URL (stored securely, never printed)

npx @trucore/atf@1.5.1 profile config prod --rpc-url <YOUR_HELIUS_URL>

3. Sanity check: ping the RPC

npx @trucore/atf@1.5.1 rpc ping --profile prod

Secrets set via profile config are stored in your local profile directory and redacted from all CLI output. ATF never transmits private keys or API tokens over the network.

Simulate, Verify, Execute

Every transaction passes through a deterministic pipeline. Nothing touches the chain until local verification succeeds.

The simulate step evaluates your transaction against active policy constraints and produces a receipt with a deterministic content_hash. Your client re-hashes the payload locally. If the digests match, the transaction is signed and submitted. If they diverge, execution is blocked before any funds move. This verify-then-send model means you never rely on server trust alone.

Verify receipts locally before signing.

Optimized for Real Execution Environments

ATF enforces policy inline with execution - not in batch, not offline. Every claim below is based on observed behavior from mainnet test matrices.

  • Measured across mainnet routing scenarios with real RPC simulation
  • Classification occurs before execution to avoid wasted compute
  • Designed to operate within typical Solana RPC latency constraints
  • Deterministic policy evaluation avoids unnecessary RPC calls
  • Graceful fallback to demo mode when API is unavailable

Typical SAFE routes observed under ~170k compute units across mainnet test matrices. Multi-hop routes increase compute and latency. RPC response time dominates total execution time.

Measured on Mainnet

Routes were evaluated across real conditions using RPC simulation on Solana mainnet-beta. The following characteristics were observed across 6 matrix runs and 55+ scout samples.

Observed Characteristics

  • SAFE - under 170,000 compute units (most single-hop routes)
  • BORDERLINE - 170,000–200,000 CU (observed in multi-hop route variance)
  • Multi-hop routes - increase compute and latency; CU driven by route composition, not trade amount
  • RPC latency - dominates total execution time in typical conditions

Based on internal test matrices. Route composition is non-deterministic - actual CU may vary between calls.

Toolbox

Start with trade, setup, doctor, and verify. Advanced bot and operator commands are available when you need them.

Golden Path

  • tradeRun a protected trade (demo mode by default, no wallet needed)
  • setupInteractive API key and config setup
  • doctorFull environment health check
  • verifyVerify and share a receipt

Environment

  • whoamiShow active profile and pubkey
  • lsList all configured profiles
  • completionGenerate shell completions (bash/zsh/fish)

Profiles & Config

  • profile createCreate a named profile for an environment
  • profile selectSwitch active profile
  • profile configSet RPC URL, secrets, and network
  • config initInitialize ATF global configuration

Network

  • rpc pingVerify RPC connectivity and latency
  • burner enableSwitch active profile to devnet

Transactions

  • tx signSign a transaction payload
  • tx sendSubmit a signed transaction to the network
  • tx statusCheck confirmation status of a transaction

Policy & Simulation

  • policy validateValidate a policy YAML offline
  • bot protectWrap a bot transaction with ATF enforcement
  • bot initScaffold a new bot config from a template

Verification & Receipts

  • receipts verifyVerify deterministic receipt integrity locally
  • report savingsGenerate receipt-backed savings report

Perps (feature-gated)

  • perps protectEnforce perps policy before order submission
  • perps explainShow human-readable perps intent analysis
  • perps fixturesPrint canonical venue-specific test fixtures

Agent & Discovery

  • bootstrapSelf-integrate using a bootstrap recipe
  • integration-doctorDiagnose integration health and configuration

Great UX for Humans, Stable Contracts for Bots

Dual-surface outputs: readable in terminal, reliable in automation. Built for production bots, AI agents, and custodians.

Human-Facing

  • Guided protected trade UX with clear mode/status messaging
  • Actionable next steps after every command
  • Share snippets and replay commands for receipts

Bot-Facing

  • Machine-readable JSON with machine_summary
  • suggested_action and suggested_command fields
  • Replay, share, and bot-friendly output hooks

Non-Custodial

ATF never holds your private keys. Signing happens on your machine, in your environment. The platform enforces policy, not custody.

Deterministic Receipts

Every decision produces a content_hash computed from stable JSON serialization. Shareable, verifiable, and reproducible. Full auditability, zero ambiguity.

What Comes Next

A hosted API key model is planned for v2 to support managed workflows and team-level access control. No dates. We ship only when security and verification guarantees are preserved.

Get Started

Run a protected trade, connect your key, and verify your first receipt. Everything you need ships in the CLI.

Try a protected trade

npx @trucore/atf@1.5.1 trade

Run a protected trade in one command

Try atf trade to see the full product loop: protect, receipt, verify. Demo mode works instantly. On macOS/Linux you can also use npx @trucore/atf@1.5.1 trade.

Get Updates

Get release notes and security updates. CLI versions are pinned and the changelog announces every upgrade.