Solana mainnet · live x402 · SVM stealth · sRFC draft

Private rails for the agentic economy.

ProwlFi is the privacy layer for AI agents on Solana. Stealth addresses make every payment unlinkable, and x402 lets agents pay each other over plain HTTP — so who paid whom, and how much, never reaches the public ledger.

Open the dapp → Read the docs

Built on Solana · SVM · SPL · x402

agent-runtime.ts

// pay an agent without leaking who, or how much
import { createProwl } from "@prowlfi/sdk"

const agent = createProwl({ chain: "solana" })

// resolve recipient to a one-time stealth address
const to = await agent.stealth("agent:vendor-7")

const { receipt } = await agent.payX402({
  url:    "https://api.vendor.xyz/infer",
  to,                          // unlinkable on-chain
  amount: 0.02, token: "USDC"
})
// settles in ~400ms · only the recipient can spend

Threat model

The public ledger is a strategy leak. ProwlFi closes it.

Every agent transaction on Solana publishes who paid whom, how much, and when. Competitors reconstruct the entire strategy straight from the graph. ProwlFi breaks the link at the address layer — every payment lands at a fresh, single-use destination only the recipient can spend from.

Public ledger

Every payment links back to one wallet.

1 linked identity

With ProwlFi

A fresh, single-use address every time.

unlinkable

Without ProwlFi — public SPL transfers

✕Every agent payment links back to one wallet
✕Position sizes & counterparties in the clear
✕Strategy reconstructable from the graph
✕Agent-to-agent payment routes fully mappable

With ProwlFi — stealth + x402

✓Every payment lands at a fresh, unlinkable address
✓No on-chain link between agent identity and tx
✓Transaction graph yields no strategy signal
✓Operator keeps a viewing key for full audit

Agentic economy

What agents do — privately, on Solana.

The agent economy is being built in public on the wrong rails. ProwlFi gives every autonomous workflow the same off-the-record privacy a human treasury already takes for granted.

◧

Trading & market-making

Strategy is alpha. Address reuse turns every fill, rebalance, and hedge into a public signal. Stealth addresses keep the entire position private without leaving Solana.

⇄

Agent-to-agent commerce

Pay another agent for a signal, an inference call, or a data feed over plain HTTP via x402 — every payment unlinkable, no shared on-chain identity between buyer and seller.

⊞

Agentic services & APIs

Sell agent-callable SPL endpoints with x402. Each customer pays into a fresh stealth address; revenue accrues to the operator without exposing the customer graph.

◰

Treasury & payroll

Disburse SOL or SPL to contributors without publishing a payroll graph. Sweep gaslessly — no SOL needs to be pre-funded at any destination.

◔

Subscription & metering

Charge per call instead of per month. x402 turns any endpoint into a metered surface; stealth settlement keeps the customer identity private by default.

◇

Compliance-ready

Stealth is not untraceable. The operator holds a viewing key for selective disclosure. The agent stays private from the public ledger — not from the operator, accountant, or regulator.

Universal agent surface

One privacy layer. Three ways to call it.

Whatever your agent runs on, ProwlFi meets it there. TypeScript-native? Drop in the SDK. Claude Code, Cursor, or any MCP host? Add the MCP server. Python, Go, Rust, or a remote agent? Hit the REST API.

SDK

TypeScript SDK

@prowlfi/sdk runtime + components. Three calls inside any agent loop. Fully typed: ESM + CJS.

await agent.stealth(id)
await agent.payX402(req)
await agent.scan(viewKey)

MCP

MCP server

Exposes six tools to Claude Code, Cursor, Windsurf, or any MCP host — stealth, pay, scan, sweep.

prowl.stealth_resolve
prowl.x402_pay
prowl.scan_incoming

REST

HTTP / REST API

Call from any agent, any language. OpenAPI 3.1 + typed clients for Python & Rust. Language-agnostic.

POST /v1/stealth
POST /v1/x402/pay
GET /v1/scan

Quickstart

Three lines to a private payment.

Install the SDK, create an agent, pay anyone over x402 — the payment lands at a one-time stealth address with no on-chain link to you.

Install

Add the TypeScript SDK to your agent.

Create an agent

One call. Your seed stays client-side — non-custodial by construction.

Pay, unlinkably

Resolve a recipient to a fresh stealth address and settle over x402.

terminal

# 01 · install
npm i @prowlfi/sdk

agent.ts

import { createProwl } from "@prowlfi/sdk"

// 02 · create — seed never leaves the process
const agent = createProwl({ chain: "solana" })

// 03 · pay — lands at a one-time stealth address
const { receipt } = await agent.payX402({
  url: "https://api.vendor.xyz/infer",
  to: "prowl:vendor-7",
  amount: 0.02, token: "USDC"
})

Live playground

Watch a payment disappear.

Run the full x402 stealth flow right here — no wallet, no keys, no chain. ProwlFi derives a one-time stealth address, signs the payment envelope, and settles, all in the browser.

Endpoint

Amount

Token

Pay to (meta-address)

Console · stealth-x402

// configure a request and run the flow →

Stealth addresscopy

—

Ephemeral keycopy

—

View tagcopy

—

Tx signaturecopy

—

Capabilities

Everything an agent needs to transact privately.

◬

Stealth addresses (ed25519)

Single-use addresses derived per payment. Recipients publish one meta-address; senders compute unlinkable destinations entirely client-side. Proposed as an sRFC.

⌁

x402 stealth payments

HTTP 402 — but the payment lands at a fresh stealth address. Any agent can charge for an endpoint and any agent can pay it without leaking the buyer–vendor link.

◉

View-tag scanning

One-byte view tags discard ~99.6% of announcements before any derivation. Fast recipient detection without indexers or a full-chain scan.

⊘

Gasless sweeps — SOL + SPL

Fee-sponsored relaying via a Kora-style facilitator. Agents never need SOL pre-funded at a stealth destination to receive or sweep.

⊜

Viewing keys

Export a deterministic audit trail without revealing live strategy. Share a viewing key with an auditor; spend authority stays with the agent.

⬡

Deterministic identity

One master seed, the same stealth meta-address across every agent and host. No drift, no re-onboarding per surface.

Architecture

On-chain program → pure-TS engine → any surface.

A minimal on-chain program announces payments. Everything cryptographic happens client-side, inside your agent. Three surfaces — SDK, MCP, REST — wrap the same engine.

On-chain program

A lightweight Anchor program emits a stealth announcement plus an encrypted ephemeral key per payment. Deployed on Solana mainnet.

Privacy engine

Key derivation, view-tag scanning, x402 payment planning — pure client TypeScript. Your seed never leaves the agent. No server required.

Three surfaces

SDK for TS-native agents, MCP server for AI-host tooling, REST for everything else. Same engine, same guarantees.

Roadmap

Shipping in the open.

Phase 01 · shipped

Stealth scheme + on-chain programlive

ed25519 stealth derivation, view-tag announcements, and the Anchor program deployed and source-verified on Solana mainnet.

Phase 02 · shipped

SDK · MCP · REST surfaceslive

@prowlfi/sdk on npm, the MCP server for Claude Code / Cursor / Windsurf, and the REST API with typed Python & Rust clients.

Phase 03 · in progress

Independent audit + sRFC submissionbuilding

Third-party audit of the stealth scheme and program, alongside formal submission of the stealth-address standard as a Solana sRFC.

Phase 04 · planned

Confidential amounts + network privacynext

BN-254 confidential transfers to hide payment values, plus optional relay routing so RPC calls stop leaking IP metadata.

Future

Cross-SVM coverageexploring

Extend the same stealth + x402 guarantees across SVM networks so agents stay private wherever they settle.

How it compares

Privacy without the trade-offs.

Every other route to payment privacy gives something up — custody, your chain, auditability, or compliance. ProwlFi keeps all four.

	Public SPL transfer	Mixer / tumbler	L2 / privacy chain	ProwlFi
Unlinkable payments	✕	✓	✓	✓
Non-custodial	✓	✕	~	✓
Auditable via viewing key	✓	✕	~	✓
Stays on Solana mainnet	✓	~	✕	✓
No new wallet or chain	✓	✕	✕	✓
Pays over HTTP (x402)	✕	✕	✕	✓
Compliance-friendly	✓	✕	~	✓

FAQ

Questions, answered.

Is ProwlFi a mixer?

No. Funds are never pooled or commingled. Every payment is a direct, one-to-one transfer to a one-time stealth address, and each one stays individually attributable to its sender via the recipient's viewing key. It's closer to a fresh P.O. box per payment than to a tumbler.

Is this legal / compliant?

ProwlFi is built for the regulated end of the agent economy. The viewing key gives the operator — and any auditor they choose to share it with — a complete, attributable record of incoming payments, without exposing that activity to the public ledger. Privacy from competitors, not from your accountant.

Are payment amounts hidden too?

Not yet. Today ProwlFi cuts the link at the address layer — who paid whom is unlinkable, but transfer values are still visible on Solana. Confidential amounts (BN-254 transfers) are a scoped roadmap item, not a shipped claim. We'd rather be precise about the boundary than overstate it.

Do I need a new wallet or a new chain?

No. ProwlFi runs on standard Solana with standard SPL tokens and ordinary wallets. There's no bridge, no L2, no metalayer — the stealth derivation happens client-side and settlement is a normal Solana transaction to a one-time address.

Does ProwlFi ever hold my funds?

Never. It's fully non-custodial. Spending keys are derived from your seed and stay inside your agent's process — they never touch a ProwlFi server, which doesn't sit in the payment path at all.

What does it cost?

The protocol is open and non-custodial — you pay only Solana network fees, around $0.0002 per payment. Fee-sponsored sweeps let an agent receive at a stealth address with no SOL pre-funded there.

Which agents and frameworks are supported?

Anything that speaks HTTP. Drop in the TypeScript SDK, add the MCP server to Claude Code, Cursor, or Windsurf, or call the REST API from Python, Rust, ElizaOS, LangChain — or any HTTP client. Same engine, same guarantees. See the docs.