mpp-test-sdk 1.0.0

package/README.md

@@ -0,0 +1,168 @@
+# mpp-test-sdk
+
+[![npm](https://img.shields.io/npm/v/mpp-test-sdk)](https://www.npmjs.com/package/mpp-test-sdk)
+[![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.
+
+**[mpptestkit.com](https://mpptestkit.com)** · [GitHub](https://github.com/mpptestkit/mpp-test-sdk) · [X](https://x.com/mpptestkit)
+
+---
+
+## Install
+
+```bash
+npm i mpp-test-sdk
+```
+
+Requires Node.js 22+.
+
+---
+
+## Client
+
+```ts
+import { mppFetch } from "mpp-test-sdk";
+
+const res = await mppFetch("https://your-api.com/api/data");
+const data = await res.json();
+```
+
+Or with a dedicated client instance:
+
+```ts
+import { createTestClient } from "mpp-test-sdk";
+
+const client = await createTestClient({
+  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.
+
+---
+
+## Server
+
+```ts
+import express from "express";
+import { createTestServer } from "mpp-test-sdk";
+
+const app = express();
+const mpp = createTestServer({ secretKey: process.env.MPP_SECRET_KEY });
+
+// 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" });
+});
+
+app.listen(3001);
+```
+
+---
+
+## API Reference
+
+### `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.
+
+### `createTestClient(config?)`
+
+Creates a client with its own isolated wallet.
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `privateKey` | `` `0x${string}` `` | auto-generated | Reuse a pre-funded wallet |
+| `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 }`.
+
+**Throws:** `MppFaucetError` if the testnet faucet is unreachable.
+
+### `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 |
+
+Returns `MppServer` with `.charge({ amount })` middleware.
+
+**Throws:** `Error` synchronously if `secretKey` is missing.
+
+### `PaymentStep` events
+
+| `step.type` | When |
+|---|---|
+| `"wallet-created"` | New ephemeral wallet generated |
+| `"funded"` | Faucet funding confirmed |
+| `"request"` | Outgoing HTTP request |
+| `"payment"` | On-chain payment submitted |
+| `"success"` | Final 200 response received |
+| `"error"` | Flow failed |
+
+---
+
+## Error Handling
+
+```ts
+import { MppFaucetError, MppPaymentError, MppTimeoutError } from "mpp-test-sdk";
+
+try {
+  const res = await client.fetch("https://api.example.com/data");
+} catch (err) {
+  if (err instanceof MppFaucetError) {
+    // Testnet faucet unreachable — err.address
+  } else if (err instanceof MppPaymentError) {
+    // Payment rejected — err.status, err.url
+  } else if (err instanceof MppTimeoutError) {
+    // Flow timed out — err.url, err.timeoutMs
+  }
+}
+```
+
+**Tip:** Pass a pre-funded `privateKey` to `createTestClient` during development to skip faucet calls.
+
+---
+
+## Network
+
+All payments use **PathUSD** test tokens on **Tempo Moderato Testnet** (chain ID 42431). Real on-chain transactions, zero financial risk.
+
+| | Value |
+|---|---|
+| Chain ID | `42431` |
+| RPC | `https://rpc.testnet.tempo.xyz` |
+| Explorer | `https://explorer.testnet.tempo.xyz` |
+| PathUSD | `0x20c0000000000000000000000000000000000000` |
+| Faucet | Automatic via SDK |
+
+---
+
+## Troubleshooting
+
+**`MppFaucetError`** — Faucet has rate limits. Wait a few seconds and retry, or pass a pre-funded `privateKey` to skip faucet calls.
+
+**`MppTimeoutError`** — Increase `timeout` in `createTestClient`. On-chain confirmations typically take 2–5 seconds.
+
+**402 not handled** — Ensure `createTestServer` is called with a valid `secretKey` and the middleware is placed before the route handler.
+
+---
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,115 @@
+import { RequestHandler } from 'express';
+
+interface PaymentStep {
+    type: "wallet-created" | "funded" | "request" | "payment" | "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}`;
+    /** Lifecycle event callback for observing the payment flow. */
+    onStep?: (step: PaymentStep) => void;
+    /** Request timeout in milliseconds. Default: 30000 (30s). */
+    timeout?: number;
+    /** Maximum retry attempts for transient failures. Default: 1 (single 402 retry). */
+    maxRetries?: number;
+}
+interface TestClient {
+    /** The wallet address. */
+    address: string;
+    /** The payment method being used. */
+    method: "tempo";
+    /** Fetch a URL with automatic 402 payment handling. */
+    fetch: (url: string, init?: RequestInit) => Promise<Response>;
+}
+/**
+ * Create an MPP test client.
+ *
+ * Auto-generates a wallet, funds it from the Tempo testnet faucet,
+ * and handles 402 payments automatically.
+ *
+ * @example
+ * ```ts
+ * import { createTestClient } from "mpp-test-sdk";
+ *
+ * const client = await createTestClient();
+ * const res = await client.fetch("http://localhost:3001/api/ping/paid");
+ * const data = await res.json();
+ * ```
+ *
+ * @throws {MppFaucetError} When the testnet faucet is unreachable or returns an error.
+ */
+declare function createTestClient(config?: TestClientConfig): Promise<TestClient>;
+/**
+ * One-shot fetch with automatic wallet creation, funding, and 402 payment.
+ *
+ * Uses a shared client instance across calls (lazy-initialized on first call).
+ * Call `mppFetch.reset()` to discard the shared instance.
+ *
+ * @example
+ * ```ts
+ * import { mppFetch } from "mpp-test-sdk";
+ *
+ * const res = await mppFetch("http://localhost:3001/api/ping/paid");
+ * const data = await res.json();
+ * ```
+ *
+ * @throws {MppFaucetError} When the testnet faucet is unreachable.
+ * @throws {MppTimeoutError} When the request times out.
+ */
+declare function mppFetch(url: string, init?: RequestInit): Promise<Response>;
+declare namespace mppFetch {
+    var reset: () => void;
+}
+
+interface ChargeOptions {
+    /** Amount to charge in PathUSD (e.g. "0.01"). */
+    amount: string;
+}
+interface MppServer {
+    /** Express middleware that charges the specified amount before passing through. */
+    charge: (opts: ChargeOptions) => RequestHandler;
+}
+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}`;
+}
+/**
+ * Create an MPP-enabled Express middleware.
+ *
+ * @example
+ * ```ts
+ * import express from "express";
+ * 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 }));
+ * ```
+ */
+declare function createTestServer(config: TestServerConfig): MppServer;
+
+declare class MppError extends Error {
+    constructor(message: string);
+}
+declare class MppFaucetError extends MppError {
+    readonly address: string;
+    constructor(address: string, cause?: unknown);
+}
+declare class MppPaymentError extends MppError {
+    readonly status: number;
+    readonly url: string;
+    constructor(url: string, status: number, cause?: unknown);
+}
+declare class MppTimeoutError extends MppError {
+    readonly url: string;
+    readonly timeoutMs: number;
+    constructor(url: string, timeoutMs: number);
+}
+
+export { type ChargeOptions, MppError, MppFaucetError, MppPaymentError, type MppServer, MppTimeoutError, type PaymentStep, type TestClient, type TestClientConfig, type TestServerConfig, createTestClient, createTestServer, mppFetch };

package/dist/index.d.ts

@@ -0,0 +1,115 @@
+import { RequestHandler } from 'express';
+
+interface PaymentStep {
+    type: "wallet-created" | "funded" | "request" | "payment" | "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}`;
+    /** Lifecycle event callback for observing the payment flow. */
+    onStep?: (step: PaymentStep) => void;
+    /** Request timeout in milliseconds. Default: 30000 (30s). */
+    timeout?: number;
+    /** Maximum retry attempts for transient failures. Default: 1 (single 402 retry). */
+    maxRetries?: number;
+}
+interface TestClient {
+    /** The wallet address. */
+    address: string;
+    /** The payment method being used. */
+    method: "tempo";
+    /** Fetch a URL with automatic 402 payment handling. */
+    fetch: (url: string, init?: RequestInit) => Promise<Response>;
+}
+/**
+ * Create an MPP test client.
+ *
+ * Auto-generates a wallet, funds it from the Tempo testnet faucet,
+ * and handles 402 payments automatically.
+ *
+ * @example
+ * ```ts
+ * import { createTestClient } from "mpp-test-sdk";
+ *
+ * const client = await createTestClient();
+ * const res = await client.fetch("http://localhost:3001/api/ping/paid");
+ * const data = await res.json();
+ * ```
+ *
+ * @throws {MppFaucetError} When the testnet faucet is unreachable or returns an error.
+ */
+declare function createTestClient(config?: TestClientConfig): Promise<TestClient>;
+/**
+ * One-shot fetch with automatic wallet creation, funding, and 402 payment.
+ *
+ * Uses a shared client instance across calls (lazy-initialized on first call).
+ * Call `mppFetch.reset()` to discard the shared instance.
+ *
+ * @example
+ * ```ts
+ * import { mppFetch } from "mpp-test-sdk";
+ *
+ * const res = await mppFetch("http://localhost:3001/api/ping/paid");
+ * const data = await res.json();
+ * ```
+ *
+ * @throws {MppFaucetError} When the testnet faucet is unreachable.
+ * @throws {MppTimeoutError} When the request times out.
+ */
+declare function mppFetch(url: string, init?: RequestInit): Promise<Response>;
+declare namespace mppFetch {
+    var reset: () => void;
+}
+
+interface ChargeOptions {
+    /** Amount to charge in PathUSD (e.g. "0.01"). */
+    amount: string;
+}
+interface MppServer {
+    /** Express middleware that charges the specified amount before passing through. */
+    charge: (opts: ChargeOptions) => RequestHandler;
+}
+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}`;
+}
+/**
+ * Create an MPP-enabled Express middleware.
+ *
+ * @example
+ * ```ts
+ * import express from "express";
+ * 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 }));
+ * ```
+ */
+declare function createTestServer(config: TestServerConfig): MppServer;
+
+declare class MppError extends Error {
+    constructor(message: string);
+}
+declare class MppFaucetError extends MppError {
+    readonly address: string;
+    constructor(address: string, cause?: unknown);
+}
+declare class MppPaymentError extends MppError {
+    readonly status: number;
+    readonly url: string;
+    constructor(url: string, status: number, cause?: unknown);
+}
+declare class MppTimeoutError extends MppError {
+    readonly url: string;
+    readonly timeoutMs: number;
+    constructor(url: string, timeoutMs: number);
+}
+
+export { type ChargeOptions, MppError, MppFaucetError, MppPaymentError, type MppServer, MppTimeoutError, type PaymentStep, type TestClient, type TestClientConfig, type TestServerConfig, createTestClient, createTestServer, mppFetch };

package/dist/index.js

@@ -0,0 +1,201 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MppError: () => MppError,
+  MppFaucetError: () => MppFaucetError,
+  MppPaymentError: () => MppPaymentError,
+  MppTimeoutError: () => MppTimeoutError,
+  createTestClient: () => createTestClient,
+  createTestServer: () => createTestServer,
+  mppFetch: () => mppFetch
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_accounts = require("viem/accounts");
+var import_client = require("mppx/client");
+
+// src/errors.ts
+var MppError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MppError";
+  }
+};
+var MppFaucetError = class extends MppError {
+  address;
+  constructor(address, cause) {
+    super(`Failed to fund wallet ${address} from testnet faucet`);
+    this.name = "MppFaucetError";
+    this.address = address;
+    this.cause = cause;
+  }
+};
+var MppPaymentError = class extends MppError {
+  status;
+  url;
+  constructor(url, status, cause) {
+    super(`Payment failed for ${url} (status: ${status})`);
+    this.name = "MppPaymentError";
+    this.status = status;
+    this.url = url;
+    this.cause = cause;
+  }
+};
+var MppTimeoutError = class extends MppError {
+  url;
+  timeoutMs;
+  constructor(url, timeoutMs) {
+    super(`Request to ${url} timed out after ${timeoutMs}ms`);
+    this.name = "MppTimeoutError";
+    this.url = url;
+    this.timeoutMs = timeoutMs;
+  }
+};
+
+// src/client.ts
+var FAUCET_RPC = "https://rpc.testnet.tempo.xyz";
+async function fundWallet(address) {
+  const res = await fetch(FAUCET_RPC, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tempo_fundAddress",
+      params: [address]
+    })
+  });
+  if (!res.ok) {
+    throw new MppFaucetError(address, new Error(`HTTP ${res.status}`));
+  }
+  const json = await res.json();
+  if (json.error) {
+    throw new MppFaucetError(address, new Error(json.error.message ?? "RPC error"));
+  }
+}
+async function createTestClient(config) {
+  const emit = config?.onStep ?? (() => {
+  });
+  const timeout = config?.timeout ?? 3e4;
+  const key = config?.privateKey ?? (0, import_accounts.generatePrivateKey)();
+  const account = (0, import_accounts.privateKeyToAccount)(key);
+  emit({
+    type: "wallet-created",
+    message: `Wallet ${account.address}`,
+    data: { address: account.address }
+  });
+  await fundWallet(account.address);
+  emit({ type: "funded", message: "Wallet funded on testnet" });
+  const mppxClient = import_client.Mppx.create({
+    methods: [(0, import_client.tempo)({ account, testnet: true })]
+  });
+  return {
+    address: account.address,
+    method: "tempo",
+    fetch: async (url, init) => {
+      emit({ type: "request", message: `\u2192 ${url}` });
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeout);
+      const signal = init?.signal ? anySignal([init.signal, controller.signal]) : controller.signal;
+      try {
+        const response = await mppxClient.fetch(url, { ...init, signal });
+        if (!response.ok && response.status !== 402) {
+          emit({
+            type: "error",
+            message: `\u2190 ${response.status}`,
+            data: { status: response.status }
+          });
+          throw new MppPaymentError(url, response.status);
+        }
+        emit({
+          type: response.ok ? "success" : "payment",
+          message: `\u2190 ${response.status}`,
+          data: { status: response.status }
+        });
+        return response;
+      } catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+          throw new MppTimeoutError(url, timeout);
+        }
+        throw err;
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  };
+}
+function anySignal(signals) {
+  const controller = new AbortController();
+  for (const signal of signals) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      return controller.signal;
+    }
+    signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+  }
+  return controller.signal;
+}
+var _sharedClient = null;
+async function mppFetch(url, init) {
+  if (!_sharedClient) {
+    _sharedClient = await createTestClient();
+  }
+  return _sharedClient.fetch(url, init);
+}
+mppFetch.reset = () => {
+  _sharedClient = null;
+};
+
+// src/server.ts
+var import_express = require("mppx/express");
+var import_accounts2 = require("viem/accounts");
+var PATHUSD = "0x20c0000000000000000000000000000000000000";
+function createTestServer(config) {
+  if (!config.secretKey) {
+    throw new Error("createTestServer: secretKey is required");
+  }
+  const serverKey = config.privateKey ?? (0, import_accounts2.generatePrivateKey)();
+  const serverAccount = (0, import_accounts2.privateKeyToAccount)(serverKey);
+  const mppx = import_express.Mppx.create({
+    secretKey: config.secretKey,
+    methods: [
+      (0, import_express.tempo)({
+        testnet: true,
+        currency: config.currency ?? PATHUSD,
+        recipient: serverAccount.address,
+        account: serverAccount
+      })
+    ]
+  });
+  return mppx;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MppError,
+  MppFaucetError,
+  MppPaymentError,
+  MppTimeoutError,
+  createTestClient,
+  createTestServer,
+  mppFetch
+});

package/dist/index.mjs

@@ -0,0 +1,168 @@
+// src/client.ts
+import { privateKeyToAccount, generatePrivateKey } from "viem/accounts";
+import { Mppx, tempo } from "mppx/client";
+
+// src/errors.ts
+var MppError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MppError";
+  }
+};
+var MppFaucetError = class extends MppError {
+  address;
+  constructor(address, cause) {
+    super(`Failed to fund wallet ${address} from testnet faucet`);
+    this.name = "MppFaucetError";
+    this.address = address;
+    this.cause = cause;
+  }
+};
+var MppPaymentError = class extends MppError {
+  status;
+  url;
+  constructor(url, status, cause) {
+    super(`Payment failed for ${url} (status: ${status})`);
+    this.name = "MppPaymentError";
+    this.status = status;
+    this.url = url;
+    this.cause = cause;
+  }
+};
+var MppTimeoutError = class extends MppError {
+  url;
+  timeoutMs;
+  constructor(url, timeoutMs) {
+    super(`Request to ${url} timed out after ${timeoutMs}ms`);
+    this.name = "MppTimeoutError";
+    this.url = url;
+    this.timeoutMs = timeoutMs;
+  }
+};
+
+// src/client.ts
+var FAUCET_RPC = "https://rpc.testnet.tempo.xyz";
+async function fundWallet(address) {
+  const res = await fetch(FAUCET_RPC, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tempo_fundAddress",
+      params: [address]
+    })
+  });
+  if (!res.ok) {
+    throw new MppFaucetError(address, new Error(`HTTP ${res.status}`));
+  }
+  const json = await res.json();
+  if (json.error) {
+    throw new MppFaucetError(address, new Error(json.error.message ?? "RPC error"));
+  }
+}
+async function createTestClient(config) {
+  const emit = config?.onStep ?? (() => {
+  });
+  const timeout = config?.timeout ?? 3e4;
+  const key = config?.privateKey ?? generatePrivateKey();
+  const account = privateKeyToAccount(key);
+  emit({
+    type: "wallet-created",
+    message: `Wallet ${account.address}`,
+    data: { address: account.address }
+  });
+  await fundWallet(account.address);
+  emit({ type: "funded", message: "Wallet funded on testnet" });
+  const mppxClient = Mppx.create({
+    methods: [tempo({ account, testnet: true })]
+  });
+  return {
+    address: account.address,
+    method: "tempo",
+    fetch: async (url, init) => {
+      emit({ type: "request", message: `\u2192 ${url}` });
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeout);
+      const signal = init?.signal ? anySignal([init.signal, controller.signal]) : controller.signal;
+      try {
+        const response = await mppxClient.fetch(url, { ...init, signal });
+        if (!response.ok && response.status !== 402) {
+          emit({
+            type: "error",
+            message: `\u2190 ${response.status}`,
+            data: { status: response.status }
+          });
+          throw new MppPaymentError(url, response.status);
+        }
+        emit({
+          type: response.ok ? "success" : "payment",
+          message: `\u2190 ${response.status}`,
+          data: { status: response.status }
+        });
+        return response;
+      } catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+          throw new MppTimeoutError(url, timeout);
+        }
+        throw err;
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  };
+}
+function anySignal(signals) {
+  const controller = new AbortController();
+  for (const signal of signals) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      return controller.signal;
+    }
+    signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+  }
+  return controller.signal;
+}
+var _sharedClient = null;
+async function mppFetch(url, init) {
+  if (!_sharedClient) {
+    _sharedClient = await createTestClient();
+  }
+  return _sharedClient.fetch(url, init);
+}
+mppFetch.reset = () => {
+  _sharedClient = null;
+};
+
+// src/server.ts
+import { Mppx as Mppx2, tempo as tempo2 } from "mppx/express";
+import { privateKeyToAccount as privateKeyToAccount2, generatePrivateKey as generatePrivateKey2 } from "viem/accounts";
+var PATHUSD = "0x20c0000000000000000000000000000000000000";
+function createTestServer(config) {
+  if (!config.secretKey) {
+    throw new Error("createTestServer: secretKey is required");
+  }
+  const serverKey = config.privateKey ?? generatePrivateKey2();
+  const serverAccount = privateKeyToAccount2(serverKey);
+  const mppx = Mppx2.create({
+    secretKey: config.secretKey,
+    methods: [
+      tempo2({
+        testnet: true,
+        currency: config.currency ?? PATHUSD,
+        recipient: serverAccount.address,
+        account: serverAccount
+      })
+    ]
+  });
+  return mppx;
+}
+export {
+  MppError,
+  MppFaucetError,
+  MppPaymentError,
+  MppTimeoutError,
+  createTestClient,
+  createTestServer,
+  mppFetch
+};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "mpp-test-sdk",
+  "version": "1.0.0",
+  "description": "Test pay-per-request APIs on Tempo testnet. Zero setup - auto-creates wallets and handles 402 payments.",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build && npm run test"
+  },
+  "dependencies": {
+    "mppx": "^0.6.3",
+    "viem": "^2.48.4"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^3.1.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "keywords": [
+    "mpp",
+    "payments",
+    "test",
+    "sdk",
+    "402",
+    "pay-per-request",
+    "tempo",
+    "testnet",
+    "machine-to-machine"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mpptestkit/mpp-test-sdk"
+  },
+  "homepage": "https://mpptestkit.com",
+  "bugs": {
+    "url": "https://github.com/mpptestkit/mpp-test-sdk/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}