mpp-test-sdk 1.0.0 → 1.1.2

package/README.md

@@ -4,9 +4,9 @@
 [![Node.js](https://img.shields.io/node/v/mpp-test-sdk)](https://nodejs.org)
 [![License: MIT](https://img.shields.io/badge/License-MIT-zinc.svg)](LICENSE)
 
-Test pay-per-request APIs on Tempo testnet. Auto-creates wallets, funds from faucet, handles 402 payments — zero setup required.
+Test pay-per-request APIs on **Solana** - devnet, testnet, or mainnet. Auto-creates wallets, airdrops SOL, handles HTTP 402 MPP payments. Zero setup required.
 
-**[mpptestkit.com](https://mpptestkit.com)** · [GitHub](https://github.com/mpptestkit/mpp-test-sdk) · [X](https://x.com/mpptestkit)
+**[mpptestkit.com](https://mpptestkit.com)** · [Playground](https://mpptestkit.com/playground) · [Docs](https://mpptestkit.com/docs) · [GitHub](https://github.com/mpptestkit/mpp-test-sdk) · [X](https://x.com/mpptestkit)
 
 ---
 
@@ -16,7 +16,7 @@ Test pay-per-request APIs on Tempo testnet. Auto-creates wallets, funds from fau
 npm i mpp-test-sdk
 ```
 
-Requires Node.js 22+.
+Requires Node.js 18+.
 
 ---
 
@@ -25,8 +25,16 @@ Requires Node.js 22+.
 ```ts
 import { mppFetch } from "mpp-test-sdk";
 
+// One line. No wallet setup. No config.
 const res = await mppFetch("https://your-api.com/api/data");
 const data = await res.json();
+
+// What happened automatically:
+// 1. SDK generated a Solana keypair
+// 2. Airdropped 2 SOL from the devnet faucet
+// 3. Server returned 402 Payment Required
+// 4. SDK sent 0.001 SOL on Solana (~800ms finality)
+// 5. Retried with Payment-Receipt header → 200 OK
 ```
 
 Or with a dedicated client instance:
@@ -35,13 +43,14 @@ Or with a dedicated client instance:
 import { createTestClient } from "mpp-test-sdk";
 
 const client = await createTestClient({
+  network: "devnet",
   onStep: (step) => console.log(step.type, step.message),
 });
 
 const res = await client.fetch("https://your-api.com/api/data");
 ```
 
-The SDK handles the full flow: wallet generation, testnet faucet funding, 402 detection, on-chain payment, and automatic retry with payment proof.
+Call `mppFetch.reset()` to discard the shared client and generate a fresh wallet on the next request.
 
 ---
 
@@ -52,17 +61,19 @@ import express from "express";
 import { createTestServer } from "mpp-test-sdk";
 
 const app = express();
-const mpp = createTestServer({ secretKey: process.env.MPP_SECRET_KEY });
+const mpp = createTestServer(); // auto-generates server wallet
 
-// Free — no middleware
+// Free - no middleware
 app.get("/api/ping", (req, res) => res.json({ ok: true }));
 
-// Paid — one line
-app.get("/api/data", mpp.charge({ amount: "0.01" }), (req, res) => {
-  res.json({ data: "premium content" });
-});
+// Paid - one line (0.001 SOL)
+app.get("/api/data",
+  mpp.charge({ amount: "0.001" }),
+  (req, res) => res.json({ data: "premium content" })
+);
 
 app.listen(3001);
+console.log("Payments go to:", mpp.recipientAddress);
 ```
 
 ---
@@ -71,47 +82,66 @@ app.listen(3001);
 
 ### `mppFetch(url, init?)`
 
-Drop-in replacement for `fetch`. Uses a shared client lazily created on first call.
-
-Call `mppFetch.reset()` to discard the shared client and generate a new wallet on the next request.
+Drop-in replacement for `fetch`. Lazily creates a shared client on first call and reuses it across requests.
 
 ### `createTestClient(config?)`
 
-Creates a client with its own isolated wallet.
+Creates a client with its own isolated Solana wallet.
 
 | Option | Type | Default | Description |
 |---|---|---|---|
-| `privateKey` | `` `0x${string}` `` | auto-generated | Reuse a pre-funded wallet |
-| `onStep` | `(step: PaymentStep) => void` | — | Lifecycle event callback |
+| `network` | `"devnet" \| "testnet" \| "mainnet"` | `"devnet"` | Solana network to use |
+| `secretKey` | `Uint8Array \| number[]` | auto-generated | Reuse a pre-funded keypair (required on mainnet) |
+| `onStep` | `(step: PaymentStep) => void` | - | Lifecycle event callback |
 | `timeout` | `number` | `30000` | Full flow timeout in ms |
-| `maxRetries` | `number` | `1` | Max retry attempts |
 
-Returns `Promise<TestClient>` with `{ address, method, fetch }`.
+Returns `Promise<TestClient>`:
+
+```ts
+interface TestClient {
+  address: string;        // Solana public key (base58)
+  network: SolanaNetwork;
+  fetch: (url: string, init?: RequestInit) => Promise<Response>;
+}
+```
 
-**Throws:** `MppFaucetError` if the testnet faucet is unreachable.
+**Throws:**
+- `MppFaucetError` - devnet/testnet airdrop failed
+- `MppNetworkError` - mainnet used without a `secretKey`
 
-### `createTestServer(config)`
+### `createTestServer(config?)`
 
 Creates Express middleware that enforces payment on any route.
 
 | Option | Type | Default | Description |
 |---|---|---|---|
-| `secretKey` | `string` | **required** | MPP secret key for payment verification |
-| `privateKey` | `` `0x${string}` `` | auto-generated | Server wallet private key |
-| `currency` | `` `0x${string}` `` | PathUSD | ERC-20 token address to accept |
+| `network` | `"devnet" \| "testnet" \| "mainnet"` | `"devnet"` | Solana network to verify payments on |
+| `secretKey` | `Uint8Array \| number[]` | auto-generated | Server wallet keypair |
 
-Returns `MppServer` with `.charge({ amount })` middleware.
+**Properties:**
 
-**Throws:** `Error` synchronously if `secretKey` is missing.
+| Property | Description |
+|---|---|
+| `mpp.recipientAddress` | Server wallet public key - payments land here |
+| `mpp.network` | Active network |
+
+### `mpp.charge(opts)`
+
+Express `RequestHandler`. Place before your route handler.
+
+| Option | Type | Description |
+|---|---|---|
+| `amount` | `string` | Amount in SOL, e.g. `"0.001"` |
 
 ### `PaymentStep` events
 
 | `step.type` | When |
 |---|---|
-| `"wallet-created"` | New ephemeral wallet generated |
-| `"funded"` | Faucet funding confirmed |
-| `"request"` | Outgoing HTTP request |
-| `"payment"` | On-chain payment submitted |
+| `"wallet-created"` | Solana keypair generated |
+| `"funded"` | Faucet airdrop confirmed (devnet/testnet) |
+| `"request"` | Outgoing HTTP request fired |
+| `"payment"` | SOL transaction submitted and confirmed |
+| `"retry"` | Request retried with Payment-Receipt header |
 | `"success"` | Final 200 response received |
 | `"error"` | Flow failed |
 
@@ -120,46 +150,79 @@ Returns `MppServer` with `.charge({ amount })` middleware.
 ## Error Handling
 
 ```ts
-import { MppFaucetError, MppPaymentError, MppTimeoutError } from "mpp-test-sdk";
+import {
+  MppError,
+  MppFaucetError,
+  MppPaymentError,
+  MppTimeoutError,
+  MppNetworkError,
+} from "mpp-test-sdk";
 
 try {
-  const res = await client.fetch("https://api.example.com/data");
+  const res = await mppFetch("https://api.example.com/data");
 } catch (err) {
-  if (err instanceof MppFaucetError) {
-    // Testnet faucet unreachable — err.address
+  if (err instanceof MppNetworkError) {
+    // Mainnet used without secretKey
+  } else if (err instanceof MppFaucetError) {
+    // Devnet/testnet airdrop failed - err.address
   } else if (err instanceof MppPaymentError) {
-    // Payment rejected — err.status, err.url
+    // Server rejected payment - err.status, err.url
   } else if (err instanceof MppTimeoutError) {
-    // Flow timed out — err.url, err.timeoutMs
+    // Flow timed out - err.url, err.timeoutMs
   }
 }
 ```
 
-**Tip:** Pass a pre-funded `privateKey` to `createTestClient` during development to skip faucet calls.
+**Tip:** Pass a pre-funded `secretKey` to skip faucet calls entirely - useful in CI or when devnet is rate-limiting.
 
 ---
 
-## Network
+## Protocol
 
-All payments use **PathUSD** test tokens on **Tempo Moderato Testnet** (chain ID 42431). Real on-chain transactions, zero financial risk.
+The SDK implements **MPP (Machine Payments Protocol)** on Solana. Plain HTTP headers, no custom transport:
 
-| | Value |
-|---|---|
-| Chain ID | `42431` |
-| RPC | `https://rpc.testnet.tempo.xyz` |
-| Explorer | `https://explorer.testnet.tempo.xyz` |
-| PathUSD | `0x20c0000000000000000000000000000000000000` |
-| Faucet | Automatic via SDK |
+```
+# Server → Client (402 Payment Required)
+Payment-Request: solana; amount="0.001"; recipient="9WzDX..."; network="devnet"
+
+# Client → Server (retry with proof)
+Payment-Receipt: solana; signature="3xKm7..."; network="devnet"
+```
+
+On-chain verification confirms: transaction exists, recipient matches, SOL delta ≥ required amount.
+
+---
+
+## Networks
+
+| | devnet | testnet | mainnet |
+|---|---|---|---|
+| Faucet | Auto (2 SOL) | Auto (2 SOL) | Bring your own |
+| Cost | Free | Free | Real SOL |
+| Use for | Local dev, CI | Pre-production | Production |
+
+```ts
+// Devnet (default)
+const client = await createTestClient({ network: "devnet" });
+
+// Mainnet - bring your own funded keypair
+const client = await createTestClient({
+  network: "mainnet",
+  secretKey: Uint8Array.from(JSON.parse(process.env.SOLANA_SECRET_KEY!)),
+});
+```
 
 ---
 
 ## Troubleshooting
 
-**`MppFaucetError`** — Faucet has rate limits. Wait a few seconds and retry, or pass a pre-funded `privateKey` to skip faucet calls.
+**`MppFaucetError`** - Devnet airdrop is rate-limited. Wait 30–60 seconds and retry, or pass a pre-funded `secretKey` to skip the faucet.
+
+**`MppNetworkError`** - You passed `network: "mainnet"` without a `secretKey`. Mainnet has no faucet - provide a funded keypair.
 
-**`MppTimeoutError`** — Increase `timeout` in `createTestClient`. On-chain confirmations typically take 2–5 seconds.
+**`MppTimeoutError`** - Increase `timeout` in `createTestClient`. Solana devnet confirmations typically take 1–3 seconds.
 
-**402 not handled** — Ensure `createTestServer` is called with a valid `secretKey` and the middleware is placed before the route handler.
+**402 not handled** - Ensure `mpp.charge()` middleware is placed before the route handler on the server.
 
 ---
 

package/dist/index.d.mts

@@ -1,62 +1,86 @@
 import { RequestHandler } from 'express';
 
+/** Solana network to connect to. */
+type SolanaNetwork = "devnet" | "testnet" | "mainnet";
 interface PaymentStep {
-    type: "wallet-created" | "funded" | "request" | "payment" | "success" | "error";
+    type: "wallet-created" | "funded" | "request" | "payment" | "retry" | "success" | "error";
     message: string;
     data?: Record<string, unknown>;
 }
 interface TestClientConfig {
-    /** Use a specific wallet. If omitted, a new wallet is auto-generated. */
-    privateKey?: `0x${string}`;
+    /**
+     * Solana network to connect to.
+     * - `"devnet"` (default) - Free SOL airdrop, fast confirmation.
+     * - `"testnet"` - Solana's testnet. Also has free airdrop.
+     * - `"mainnet"` - Real SOL. Requires a pre-funded `secretKey`.
+     */
+    network?: SolanaNetwork;
+    /**
+     * Pre-funded Solana keypair secret key (32 or 64 bytes).
+     * - On `devnet`/`testnet`: optional - wallet is auto-funded via airdrop.
+     * - On `mainnet`: **required** - no airdrop available.
+     */
+    secretKey?: Uint8Array;
     /** Lifecycle event callback for observing the payment flow. */
     onStep?: (step: PaymentStep) => void;
-    /** Request timeout in milliseconds. Default: 30000 (30s). */
+    /** Full flow timeout in ms (wallet + payment + retry). Default: 30000. */
     timeout?: number;
-    /** Maximum retry attempts for transient failures. Default: 1 (single 402 retry). */
-    maxRetries?: number;
+    /** Override the Solana RPC endpoint. Takes precedence over `network`. */
+    rpcUrl?: string;
 }
 interface TestClient {
-    /** The wallet address. */
+    /** Solana wallet address (base58 public key). */
     address: string;
-    /** The payment method being used. */
-    method: "tempo";
-    /** Fetch a URL with automatic 402 payment handling. */
+    /** Network this client is connected to. */
+    network: SolanaNetwork;
+    /** Payment method. */
+    method: "solana";
+    /** Fetch a URL with automatic 402 MPP payment handling. */
     fetch: (url: string, init?: RequestInit) => Promise<Response>;
 }
 /**
- * Create an MPP test client.
+ * Create a Solana MPP test client.
  *
- * Auto-generates a wallet, funds it from the Tempo testnet faucet,
- * and handles 402 payments automatically.
+ * Automatically creates a Solana wallet, funds it (via airdrop on devnet/testnet),
+ * and handles HTTP 402 MPP payments with automatic retry.
  *
  * @example
  * ```ts
- * import { createTestClient } from "mpp-test-sdk";
- *
+ * // devnet (default) - zero config
  * const client = await createTestClient();
- * const res = await client.fetch("http://localhost:3001/api/ping/paid");
- * const data = await res.json();
+ *
+ * // testnet
+ * const client = await createTestClient({ network: "testnet" });
+ *
+ * // mainnet - must provide pre-funded wallet
+ * const client = await createTestClient({
+ *   network: "mainnet",
+ *   secretKey: loadKeypairFromFile("./wallet.json").secretKey,
+ * });
+ *
+ * const res = await client.fetch("http://localhost:3001/api/data");
  * ```
  *
- * @throws {MppFaucetError} When the testnet faucet is unreachable or returns an error.
+ * @throws {MppNetworkError} When `mainnet` is specified without a `secretKey`.
+ * @throws {MppFaucetError} When the devnet/testnet airdrop fails after retries.
  */
 declare function createTestClient(config?: TestClientConfig): Promise<TestClient>;
 /**
- * One-shot fetch with automatic wallet creation, funding, and 402 payment.
+ * Drop-in replacement for `fetch` with automatic Solana MPP payment.
  *
- * Uses a shared client instance across calls (lazy-initialized on first call).
- * Call `mppFetch.reset()` to discard the shared instance.
+ * Uses a shared client instance lazily created on first call (devnet by default).
+ * Call `mppFetch.reset()` to discard the shared instance and generate a new wallet.
  *
  * @example
  * ```ts
  * import { mppFetch } from "mpp-test-sdk";
  *
- * const res = await mppFetch("http://localhost:3001/api/ping/paid");
+ * const res = await mppFetch("http://localhost:3001/api/data");
  * const data = await res.json();
  * ```
  *
- * @throws {MppFaucetError} When the testnet faucet is unreachable.
- * @throws {MppTimeoutError} When the request times out.
+ * @throws {MppFaucetError} When the devnet airdrop fails after retries.
+ * @throws {MppTimeoutError} When the full flow exceeds the timeout.
  */
 declare function mppFetch(url: string, init?: RequestInit): Promise<Response>;
 declare namespace mppFetch {
@@ -64,23 +88,46 @@ declare namespace mppFetch {
 }
 
 interface ChargeOptions {
-    /** Amount to charge in PathUSD (e.g. "0.01"). */
+    /** Amount to charge in SOL (e.g. "0.001"). */
     amount: string;
 }
 interface MppServer {
-    /** Express middleware that charges the specified amount before passing through. */
+    /**
+     * Express middleware that requires SOL payment before passing to the route handler.
+     *
+     * - No receipt → 402 with `Payment-Request` header.
+     * - Valid receipt + on-chain confirmation → calls `next()`.
+     * - Invalid or insufficient payment → 403.
+     */
     charge: (opts: ChargeOptions) => RequestHandler;
+    /** The Solana address where payments are sent. */
+    recipientAddress: string;
+    /** Network this server is configured for. */
+    network: SolanaNetwork;
 }
 interface TestServerConfig {
-    /** Your MPP secret key. Required. */
-    secretKey: string;
-    /** Optional private key for the server wallet. Auto-generated if omitted. */
-    privateKey?: `0x${string}`;
-    /** Optional currency token address. Defaults to PathUSD on Tempo testnet. */
-    currency?: `0x${string}`;
+    /**
+     * Solana network to connect to.
+     * - `"devnet"` (default) - Solana devnet.
+     * - `"testnet"` - Solana testnet.
+     * - `"mainnet"` - Solana mainnet (real SOL).
+     */
+    network?: SolanaNetwork;
+    /** Server wallet keypair secret key. Auto-generated if omitted. */
+    secretKey?: Uint8Array;
+    /**
+     * Override the recipient Solana address (base58).
+     * Defaults to the server keypair's public key.
+     */
+    recipientAddress?: string;
+    /** Override the Solana RPC endpoint. Takes precedence over `network`. */
+    rpcUrl?: string;
 }
 /**
- * Create an MPP-enabled Express middleware.
+ * Create a Solana MPP-enabled Express server.
+ *
+ * Handles the HTTP 402 payment flow and verifies SOL transfers on-chain.
+ * No config needed - auto-generates a server wallet.
  *
  * @example
  * ```ts
@@ -88,11 +135,15 @@ interface TestServerConfig {
  * import { createTestServer } from "mpp-test-sdk";
  *
  * const app = express();
- * const mpp = createTestServer({ secretKey: "sk_test_..." });
- * app.get("/api/paid", mpp.charge({ amount: "0.01" }), (req, res) => res.json({ ok: true }));
+ * const mpp = createTestServer();  // or createTestServer({ network: "mainnet" })
+ *
+ * // Charge 0.001 SOL per request
+ * app.get("/api/data", mpp.charge({ amount: "0.001" }), (req, res) => {
+ *   res.json({ data: "premium content" });
+ * });
  * ```
  */
-declare function createTestServer(config: TestServerConfig): MppServer;
+declare function createTestServer(config?: TestServerConfig): MppServer;
 
 declare class MppError extends Error {
     constructor(message: string);
@@ -111,5 +162,9 @@ declare class MppTimeoutError extends MppError {
     readonly timeoutMs: number;
     constructor(url: string, timeoutMs: number);
 }
+declare class MppNetworkError extends MppError {
+    readonly network: string;
+    constructor(network: string, message?: string);
+}
 
-export { type ChargeOptions, MppError, MppFaucetError, MppPaymentError, type MppServer, MppTimeoutError, type PaymentStep, type TestClient, type TestClientConfig, type TestServerConfig, createTestClient, createTestServer, mppFetch };
+export { type ChargeOptions, MppError, MppFaucetError, MppNetworkError, MppPaymentError, type MppServer, MppTimeoutError, type PaymentStep, type SolanaNetwork, type TestClient, type TestClientConfig, type TestServerConfig, createTestClient, createTestServer, mppFetch };

package/dist/index.d.ts

@@ -1,62 +1,86 @@
 import { RequestHandler } from 'express';
 
+/** Solana network to connect to. */
+type SolanaNetwork = "devnet" | "testnet" | "mainnet";
 interface PaymentStep {
-    type: "wallet-created" | "funded" | "request" | "payment" | "success" | "error";
+    type: "wallet-created" | "funded" | "request" | "payment" | "retry" | "success" | "error";
     message: string;
     data?: Record<string, unknown>;
 }
 interface TestClientConfig {
-    /** Use a specific wallet. If omitted, a new wallet is auto-generated. */
-    privateKey?: `0x${string}`;
+    /**
+     * Solana network to connect to.
+     * - `"devnet"` (default) - Free SOL airdrop, fast confirmation.
+     * - `"testnet"` - Solana's testnet. Also has free airdrop.
+     * - `"mainnet"` - Real SOL. Requires a pre-funded `secretKey`.
+     */
+    network?: SolanaNetwork;
+    /**
+     * Pre-funded Solana keypair secret key (32 or 64 bytes).
+     * - On `devnet`/`testnet`: optional - wallet is auto-funded via airdrop.
+     * - On `mainnet`: **required** - no airdrop available.
+     */
+    secretKey?: Uint8Array;
     /** Lifecycle event callback for observing the payment flow. */
     onStep?: (step: PaymentStep) => void;
-    /** Request timeout in milliseconds. Default: 30000 (30s). */
+    /** Full flow timeout in ms (wallet + payment + retry). Default: 30000. */
     timeout?: number;
-    /** Maximum retry attempts for transient failures. Default: 1 (single 402 retry). */
-    maxRetries?: number;
+    /** Override the Solana RPC endpoint. Takes precedence over `network`. */
+    rpcUrl?: string;
 }
 interface TestClient {
-    /** The wallet address. */
+    /** Solana wallet address (base58 public key). */
     address: string;
-    /** The payment method being used. */
-    method: "tempo";
-    /** Fetch a URL with automatic 402 payment handling. */
+    /** Network this client is connected to. */
+    network: SolanaNetwork;
+    /** Payment method. */
+    method: "solana";
+    /** Fetch a URL with automatic 402 MPP payment handling. */
     fetch: (url: string, init?: RequestInit) => Promise<Response>;
 }
 /**
- * Create an MPP test client.
+ * Create a Solana MPP test client.
  *
- * Auto-generates a wallet, funds it from the Tempo testnet faucet,
- * and handles 402 payments automatically.
+ * Automatically creates a Solana wallet, funds it (via airdrop on devnet/testnet),
+ * and handles HTTP 402 MPP payments with automatic retry.
  *
  * @example
  * ```ts
- * import { createTestClient } from "mpp-test-sdk";
- *
+ * // devnet (default) - zero config
  * const client = await createTestClient();
- * const res = await client.fetch("http://localhost:3001/api/ping/paid");
- * const data = await res.json();
+ *
+ * // testnet
+ * const client = await createTestClient({ network: "testnet" });
+ *
+ * // mainnet - must provide pre-funded wallet
+ * const client = await createTestClient({
+ *   network: "mainnet",
+ *   secretKey: loadKeypairFromFile("./wallet.json").secretKey,
+ * });
+ *
+ * const res = await client.fetch("http://localhost:3001/api/data");
  * ```
  *
- * @throws {MppFaucetError} When the testnet faucet is unreachable or returns an error.
+ * @throws {MppNetworkError} When `mainnet` is specified without a `secretKey`.
+ * @throws {MppFaucetError} When the devnet/testnet airdrop fails after retries.
  */
 declare function createTestClient(config?: TestClientConfig): Promise<TestClient>;
 /**
- * One-shot fetch with automatic wallet creation, funding, and 402 payment.
+ * Drop-in replacement for `fetch` with automatic Solana MPP payment.
  *
- * Uses a shared client instance across calls (lazy-initialized on first call).
- * Call `mppFetch.reset()` to discard the shared instance.
+ * Uses a shared client instance lazily created on first call (devnet by default).
+ * Call `mppFetch.reset()` to discard the shared instance and generate a new wallet.
  *
  * @example
  * ```ts
  * import { mppFetch } from "mpp-test-sdk";
  *
- * const res = await mppFetch("http://localhost:3001/api/ping/paid");
+ * const res = await mppFetch("http://localhost:3001/api/data");
  * const data = await res.json();
  * ```
  *
- * @throws {MppFaucetError} When the testnet faucet is unreachable.
- * @throws {MppTimeoutError} When the request times out.
+ * @throws {MppFaucetError} When the devnet airdrop fails after retries.
+ * @throws {MppTimeoutError} When the full flow exceeds the timeout.
  */
 declare function mppFetch(url: string, init?: RequestInit): Promise<Response>;
 declare namespace mppFetch {
@@ -64,23 +88,46 @@ declare namespace mppFetch {
 }
 
 interface ChargeOptions {
-    /** Amount to charge in PathUSD (e.g. "0.01"). */
+    /** Amount to charge in SOL (e.g. "0.001"). */
     amount: string;
 }
 interface MppServer {
-    /** Express middleware that charges the specified amount before passing through. */
+    /**
+     * Express middleware that requires SOL payment before passing to the route handler.
+     *
+     * - No receipt → 402 with `Payment-Request` header.
+     * - Valid receipt + on-chain confirmation → calls `next()`.
+     * - Invalid or insufficient payment → 403.
+     */
     charge: (opts: ChargeOptions) => RequestHandler;
+    /** The Solana address where payments are sent. */
+    recipientAddress: string;
+    /** Network this server is configured for. */
+    network: SolanaNetwork;
 }
 interface TestServerConfig {
-    /** Your MPP secret key. Required. */
-    secretKey: string;
-    /** Optional private key for the server wallet. Auto-generated if omitted. */
-    privateKey?: `0x${string}`;
-    /** Optional currency token address. Defaults to PathUSD on Tempo testnet. */
-    currency?: `0x${string}`;
+    /**
+     * Solana network to connect to.
+     * - `"devnet"` (default) - Solana devnet.
+     * - `"testnet"` - Solana testnet.
+     * - `"mainnet"` - Solana mainnet (real SOL).
+     */
+    network?: SolanaNetwork;
+    /** Server wallet keypair secret key. Auto-generated if omitted. */
+    secretKey?: Uint8Array;
+    /**
+     * Override the recipient Solana address (base58).
+     * Defaults to the server keypair's public key.
+     */
+    recipientAddress?: string;
+    /** Override the Solana RPC endpoint. Takes precedence over `network`. */
+    rpcUrl?: string;
 }
 /**
- * Create an MPP-enabled Express middleware.
+ * Create a Solana MPP-enabled Express server.
+ *
+ * Handles the HTTP 402 payment flow and verifies SOL transfers on-chain.
+ * No config needed - auto-generates a server wallet.
  *
  * @example
  * ```ts
@@ -88,11 +135,15 @@ interface TestServerConfig {
  * import { createTestServer } from "mpp-test-sdk";
  *
  * const app = express();
- * const mpp = createTestServer({ secretKey: "sk_test_..." });
- * app.get("/api/paid", mpp.charge({ amount: "0.01" }), (req, res) => res.json({ ok: true }));
+ * const mpp = createTestServer();  // or createTestServer({ network: "mainnet" })
+ *
+ * // Charge 0.001 SOL per request
+ * app.get("/api/data", mpp.charge({ amount: "0.001" }), (req, res) => {
+ *   res.json({ data: "premium content" });
+ * });
  * ```
  */
-declare function createTestServer(config: TestServerConfig): MppServer;
+declare function createTestServer(config?: TestServerConfig): MppServer;
 
 declare class MppError extends Error {
     constructor(message: string);
@@ -111,5 +162,9 @@ declare class MppTimeoutError extends MppError {
     readonly timeoutMs: number;
     constructor(url: string, timeoutMs: number);
 }
+declare class MppNetworkError extends MppError {
+    readonly network: string;
+    constructor(network: string, message?: string);
+}
 
-export { type ChargeOptions, MppError, MppFaucetError, MppPaymentError, type MppServer, MppTimeoutError, type PaymentStep, type TestClient, type TestClientConfig, type TestServerConfig, createTestClient, createTestServer, mppFetch };
+export { type ChargeOptions, MppError, MppFaucetError, MppNetworkError, MppPaymentError, type MppServer, MppTimeoutError, type PaymentStep, type SolanaNetwork, type TestClient, type TestClientConfig, type TestServerConfig, createTestClient, createTestServer, mppFetch };