@furlpay/gateway 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FurlPay
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,246 @@
+# @furlpay/gateway
+
+**Paywall any API, MCP tool, dataset, or model endpoint with stablecoin pay-per-call.**
+
+An x402 monetization gateway you host yourself. Point it at an endpoint, set a
+price, and AI agents pay per request in USDC — no account, no API key, no
+subscription, no invoice.
+
+**Speaks x402 v1 and v2**, negotiated per request. Framework-agnostic. Zero
+runtime dependencies. MIT.
+
+```sh
+npm install @furlpay/gateway
+```
+
+---
+
+## Why this exists
+
+Cloudflare and AWS both shipped x402 monetization at the edge in 2026, and both
+route settlement through Coinbase's facilitator. That's fine if you're happy
+being a tenant. This package is for everyone who wants the paywall to be *theirs*:
+self-hosted, portable across clouds, with a facilitator you choose.
+
+## v1 and v2, at the same time
+
+x402 v2 (Dec 2025) is not a header rename. The shapes changed:
+
+| | v1 | v2 |
+| --- | --- | --- |
+| request header | `X-PAYMENT` | `PAYMENT-SIGNATURE` |
+| response header | `X-PAYMENT-RESPONSE` | `PAYMENT-RESPONSE` |
+| 402 payload | in the **body** | in the **`PAYMENT-REQUIRED` header** |
+| price field | `maxAmountRequired` | `amount` |
+| resource metadata | per-requirement | hoisted to `ResourceInfo` |
+| client echo | `extra` | full `accepted` requirements |
+
+A 402 from this gateway **advertises both at once** — v2 in the `PAYMENT-REQUIRED`
+header, v1 in the body. A v2 agent reads the header, a v1 agent reads the body,
+and neither needs to know the other exists. (v2 moving payment data out of the
+body is exactly what makes this possible.) The gateway then answers in whatever
+dialect the client spoke, and calls the facilitator in that dialect too.
+
+You don't configure any of this. It just works for both.
+
+## Quickstart
+
+### 1. Any fetch-based framework (Next.js, Hono, Workers, Bun, Deno)
+
+```ts
+// app/api/weather/route.ts
+import { paywall } from "@furlpay/gateway";
+
+const pay = paywall({
+  price: 0.01,                            // USD per call
+  payTo: process.env.MERCHANT_WALLET!,    // your wallet
+  quoteSecret: process.env.QUOTE_SECRET!, // see "Configuration"
+  network: "base",
+});
+
+export const GET = pay(async (req, ctx, receipt) => {
+  // Only runs after payment has settled on-chain.
+  return Response.json({ tempC: 17, paidBy: receipt.payer });
+});
+```
+
+### 2. Express
+
+```ts
+import express from "express";
+import { expressPaywall, captureRawBody } from "@furlpay/gateway/express";
+
+const app = express();
+app.use(express.json({ verify: captureRawBody })); // needed for body binding
+
+app.get("/api/weather", expressPaywall({ price: 0.01, payTo, quoteSecret }), (req, res) => {
+  res.json({ tempC: 17, paidBy: req.payment.payer });
+});
+```
+
+### 3. Reverse proxy — monetize something you can't modify
+
+```sh
+npx @furlpay/gateway secret          # → generates a quote secret
+export QUOTE_SECRET=<that value>
+
+npx @furlpay/gateway expose http://localhost:8000 \
+  --price 0.01 \
+  --pay-to 0xYourWallet \
+  --network base \
+  --free /health,/openapi.json
+```
+
+Your origin stays untouched and never learns it's being monetized. **The origin
+must not be publicly reachable**, or agents will simply route around the paywall.
+
+---
+
+## How a payment actually works
+
+```
+agent                          gateway                      facilitator      chain
+  │  GET /weather                 │                              │             │
+  ├──────────────────────────────►│                              │             │
+  │  402 + PaymentRequirements    │                              │             │
+  │◄──────────────────────────────┤                              │             │
+  │                               │                              │             │
+  │  signs EIP-3009 authorization │                              │             │
+  │  (OFF-CHAIN — no gas, no tx)  │                              │             │
+  │                               │                              │             │
+  │  GET /weather                 │                              │             │
+  │  X-PAYMENT: base64(auth)      │                              │             │
+  ├──────────────────────────────►│  verify + settle             │             │
+  │                               ├─────────────────────────────►│  submits,   │
+  │                               │                              │  pays gas   │
+  │                               │                              ├────────────►│
+  │                               │  settled @ N confirmations   │             │
+  │                               │◄─────────────────────────────┤             │
+  │  200 + X-PAYMENT-RESPONSE     │                              │             │
+  │◄──────────────────────────────┤                              │             │
+```
+
+**The agent never submits a transaction and never holds gas.** It signs an
+authorization; the facilitator submits it and pays the gas. If you read a guide
+that tells you to "verify the transaction hash the client sends you via RPC" —
+that guide is not describing x402. It's describing a protocol that forces every
+agent to hold native gas on every chain it might want to buy from, which is
+exactly the problem x402 exists to remove.
+
+## Configuration
+
+| Option | Default | Notes |
+| --- | --- | --- |
+| `price` | — | USD per call. A function `(ctx) => number` prices per-route or per-caller. |
+| `payTo` | — | Wallet that receives payment. |
+| `quoteSecret` | — | HMAC secret binding quotes to resources. **No default, by design.** |
+| `network` | `base` | `arbitrum`, `base`, `polygon`, `solana`, + testnets. |
+| `asset` | canonical USDC | Override for a non-USDC token. |
+| `facilitator` | FurlPay | URL or a `FacilitatorClient`. Any x402 facilitator works. |
+| `facilitatorVersion` | mirrors client | Pin to `1` for a v1-only facilitator; v2 payments get downconverted. |
+| `claimStore` | in-memory | **Must be shared in multi-instance deploys — see below.** |
+| `serviceName` / `tags` / `iconUrl` | — | v2 discovery metadata. See below. |
+| `bindBody` | `true` | Bind the quote to a hash of the request body. |
+| `settle` | `true` | `false` verifies but does not collect. Rarely what you want. |
+| `onSettled` | — | Fires on confirmed settlement — ledger, webhooks, metering. |
+
+### Discovery is in the protocol — don't build an index
+
+v2's `ResourceInfo` carries `description`, `serviceName`, `tags` and `iconUrl`,
+and facilitators **crawl those fields**. Filling them in is how your resource
+becomes discoverable to agents. You do not need a proprietary directory, and
+building one would mean maintaining a walled garden that nobody's crawler visits.
+
+```ts
+paywall({
+  price: 0.01,
+  payTo,
+  quoteSecret,
+  serviceName: "Acme Weather",
+  tags: ["weather", "forecast"],
+  iconUrl: "https://acme.dev/icon.png",
+});
+```
+
+`quoteSecret` has no default because a default would be a *published* default,
+and a published default is a forgeable quote for every deployment that didn't
+override it. Generate one:
+
+```sh
+npx @furlpay/gateway secret
+```
+
+## Running more than one instance
+
+Replay protection is a single-use claim on the EIP-3009 nonce and the quote ID.
+That claim must be **atomic and shared**, or it isn't protection.
+
+The classic bug: a `Set` in module scope looks like replay protection and passes
+every local test, because in dev there's one process. In production there are N
+instances, each with its own empty `Set`, so the same `X-PAYMENT` replayed N
+times clears N different Sets and delivers the resource N times — **one payment,
+N deliveries.**
+
+The default `MemoryClaimStore` is correct on exactly one instance and reports
+`isDurable === false`. On more than one, use the built-in Upstash store — it's a
+single `SET NX EX` over the REST API, so it adds no dependency:
+
+```ts
+import { paywall, upstashClaimStore } from "@furlpay/gateway";
+
+const pay = paywall({
+  price: 0.01,
+  payTo,
+  quoteSecret,
+  claimStore: upstashClaimStore(), // UPSTASH_REDIS_REST_URL + _TOKEN
+});
+```
+
+It throws rather than start without credentials, because silently degrading to
+in-memory would *look* durable and not be — the worst possible failure mode for
+replay protection. Any other backend works via `claimStoreFrom(setNx)`.
+
+Assert it at boot so you find out at deploy time, not during an incident:
+
+```ts
+if (process.env.NODE_ENV === "production" && !pay.gateway.replayProtectionDurable) {
+  throw new Error("multi-instance deploy with in-memory replay protection");
+}
+```
+
+## What this defends against
+
+Every one of these is covered by a test in `test/gateway.test.js`.
+
+| Attack | Defence |
+| --- | --- |
+| **Cross-resource substitution** — pay $0.001 for `/weather`, present it at `/gpt-5-inference` | Quotes carry an HMAC over `(method, resource, amount, quoteId, expiry[, bodyHash])`. A payment minted for one resource fails the binding check at any other — *even at the same price*. |
+| **Body substitution** — pay for `{"model":"small"}`, retry with `{"model":"large"}` | The quote is bound to a hash of the exact body it was issued for. |
+| **Replay / duplicate settlement** — send one `X-PAYMENT` N times | The nonce and quote ID are burned via an atomic single-use claim, before settlement. Concurrent replays of one payment yield exactly one grant. |
+| **Revert-grant** — resource delivered on a settlement that later reorgs | Confirmation depth scales with value: 3 under $1, 6 under $10, 12 above. Shallower than required → no delivery. |
+| **Cache leakage** — a CDN caches the paid 200 and serves it free | `Cache-Control: no-store` + `Vary: X-PAYMENT` on paid responses *and* on 402 quotes. In proxy mode the origin's own cache headers are overridden. |
+| **Underpayment** — pay `9000` against a `10000` quote | Amounts compare as integers. (`"9000" > "10000"` lexicographically — a string compare here is a real vulnerability.) |
+| **Quote forgery / tampering** | Constant-time HMAC compare. Amount, recipient, network, and expiry are all re-derived server-side; the client's echo is a lookup key, never an assertion. |
+| **Cross-dialect double-spend** — pay a quote as v1, re-present the same quote as v2 with a fresh nonce | The quoteId claim is dialect-blind. One quote buys exactly one delivery, in any version. |
+| **Facilitator outage** | Fails closed. A facilitator you can't reach costs you a sale, not the resource. |
+| **Settlement error** | The nonce stays burned — a failed settle may still land on-chain, so freeing it would reopen replay against a payment that does confirm. Honest retries sign a fresh nonce, so this never blocks a real payer. |
+| **`upto` over-reporting** | v2's `upto` scheme can settle *less* than authorized. The receipt reports what was actually taken, not what was authorized. |
+
+For facilitator-side hardening (allowance overdraft, denial-of-settlement,
+hidden-compute pricing), see [`@furlpay/x402-guard`](../x402-guard).
+
+## Choosing a facilitator
+
+The facilitator is the only party that touches a chain. The gateway never needs a
+private key, an RPC endpoint, or a gas balance — which is what makes it safe to
+self-host.
+
+```ts
+paywall({ facilitator: "https://furlpay.com/api/x402/facilitator" }) // default
+paywall({ facilitator: "https://x402.org/facilitator" })             // or anyone else
+paywall({ facilitator: myCustomClient })                             // or your own
+```
+
+## License
+
+MIT

package/SECURITY.md

@@ -0,0 +1,65 @@
+# Security Policy
+
+## Reporting a vulnerability
+
+Email **security@furlpay.com**. Please do not open a public issue for a
+vulnerability.
+
+Include what you can: affected version, a description, and ideally a
+reproduction. We aim to acknowledge within 72 hours.
+
+## What this package is, and is not
+
+`@furlpay/gateway` gates a resource behind an x402 payment. It **never holds a
+private key, an RPC endpoint, or a gas balance** — a facilitator does the
+on-chain work. That boundary is deliberate: it is what makes the gateway safe to
+self-host, and it means a compromise of the gateway cannot move funds.
+
+**This package has not been independently audited.** The defences below are
+tested (`npm test`), not certified. If you are gating something valuable, read
+the code — that is why `src/` ships in the tarball.
+
+## Defences, and their limits
+
+| Property | Enforced by | Limit |
+| --- | --- | --- |
+| Quote is bound to one resource, method, price | HMAC over `(method, resource, amount, quoteId, expiry[, bodyHash])`, constant-time compare | Only as strong as `quoteSecret`. There is **no default secret** — a published default would be a forgeable quote for every deployment that did not override it. |
+| Quote is bound to one request body | `bodyHash` in the MAC (`POST`/`PUT`/`PATCH`) | Off if you set `bindBody: false`, or on Express without `captureRawBody`. The Express adapter **fails closed** rather than silently degrade. |
+| One payment buys one delivery | Atomic single-use claim on the EIP-3009 nonce **and** the quoteId, burned before settlement | **The default `MemoryClaimStore` is single-instance only.** On N instances it is not replay protection at all — see below. |
+| Cross-dialect double-spend | The quoteId claim is version-blind, so a quote spent as v1 cannot be re-spent as v2 | — |
+| Settlement finality | Confirmation depth scaled to value (3 / 6 / 12) | The facilitator must report depth honestly. A dishonest facilitator can lie; choose one you trust. |
+| Paid content is not cached | `Cache-Control: no-store` + `Vary` on both dialects' headers, on paid responses *and* 402s | In proxy mode the origin's own cache headers are overridden. Behind your own CDN, verify it honours `no-store`. |
+| Facilitator outage | Fails closed | An unreachable facilitator costs you a sale, not the resource. |
+
+## The one that bites people
+
+Replay protection is a single-use claim. That claim must be **atomic and shared**,
+or it is not protection.
+
+A `Set` in module scope looks like replay protection and passes every local test,
+because in dev there is one process. In production there are N instances, each
+with its own empty `Set` — so the same payment replayed N times clears N
+different sets and delivers the resource N times. **One payment, N deliveries.**
+
+The default `MemoryClaimStore` reports `isDurable === false`. Assert on it:
+
+```ts
+if (process.env.NODE_ENV === "production" && !pay.gateway.replayProtectionDurable) {
+  throw new Error("multi-instance deploy with in-memory replay protection");
+}
+```
+
+Use `upstashClaimStore()` (or any `claimStoreFrom(setNx)`) in multi-instance
+deployments. `upstashClaimStore()` throws rather than start without credentials,
+because silently degrading to in-memory would *look* durable and not be.
+
+## Reverse-proxy mode
+
+The origin behind `startProxy()` **must not be publicly reachable**, or agents
+will route around the paywall entirely. Bind it to loopback, or firewall it to
+the gateway process.
+
+## Related
+
+Facilitator-side hardening (allowance overdraft, denial-of-settlement,
+hidden-compute pricing) lives in [`@furlpay/x402-guard`](https://github.com/FurlPay/x402-guard).

package/dist/adapters/express.d.ts

@@ -0,0 +1,43 @@
+import { type GatewayOptions } from "../gateway.js";
+import type { SettlementReceipt } from "../protocol.js";
+interface ExpressLikeRequest {
+    method: string;
+    originalUrl?: string;
+    url: string;
+    headers: Record<string, string | string[] | undefined>;
+    protocol?: string;
+    secure?: boolean;
+    get?(name: string): string | undefined;
+    /** Raw body bytes — see `captureRawBody`. */
+    rawBody?: Buffer | string;
+    /** Set by this middleware once payment is confirmed. */
+    payment?: SettlementReceipt;
+}
+interface ExpressLikeResponse {
+    status(code: number): ExpressLikeResponse;
+    set(field: string, value: string): ExpressLikeResponse;
+    json(body: unknown): unknown;
+}
+type Next = (err?: unknown) => void;
+/**
+ * `express.json()` discards the raw bytes, but body binding needs to hash
+ * exactly what the client sent — a re-serialized `req.body` is a different byte
+ * string (key order, whitespace) and would hash differently every time.
+ *
+ * @example
+ *   app.use(express.json({ verify: captureRawBody }));
+ */
+export declare function captureRawBody(req: ExpressLikeRequest, _res: unknown, buf: Buffer): void;
+/**
+ * Express middleware that paywalls everything mounted after it.
+ *
+ * On success `req.payment` holds the settlement receipt, so the route handler
+ * can meter, log, or attribute the call to the paying agent.
+ *
+ * @example
+ *   app.get("/api/weather", expressPaywall({ ... }), (req, res) => {
+ *     res.json({ tempC: 17, paidBy: req.payment.payer });
+ *   });
+ */
+export declare function expressPaywall(opts: GatewayOptions): (req: ExpressLikeRequest, res: ExpressLikeResponse, next: Next) => Promise<void>;
+export {};

package/dist/adapters/express.js

@@ -0,0 +1,81 @@
+import { Gateway } from "../gateway.js";
+/**
+ * `express.json()` discards the raw bytes, but body binding needs to hash
+ * exactly what the client sent — a re-serialized `req.body` is a different byte
+ * string (key order, whitespace) and would hash differently every time.
+ *
+ * @example
+ *   app.use(express.json({ verify: captureRawBody }));
+ */
+export function captureRawBody(req, _res, buf) {
+    req.rawBody = buf;
+}
+function absoluteUrl(req) {
+    const headerHost = req.get?.("host") ?? req.headers.host;
+    const host = headerHost ?? "localhost";
+    const proto = req.secure ? "https" : (req.protocol ?? "http");
+    return `${proto}://${host}${req.originalUrl ?? req.url}`;
+}
+function flatHeaders(req) {
+    const out = {};
+    for (const [k, v] of Object.entries(req.headers)) {
+        if (typeof v === "string")
+            out[k.toLowerCase()] = v;
+        else if (Array.isArray(v))
+            out[k.toLowerCase()] = v[0] ?? "";
+    }
+    return out;
+}
+const BODY_METHODS = new Set(["POST", "PUT", "PATCH"]);
+/**
+ * Express middleware that paywalls everything mounted after it.
+ *
+ * On success `req.payment` holds the settlement receipt, so the route handler
+ * can meter, log, or attribute the call to the paying agent.
+ *
+ * @example
+ *   app.get("/api/weather", expressPaywall({ ... }), (req, res) => {
+ *     res.json({ tempC: 17, paidBy: req.payment.payer });
+ *   });
+ */
+export function expressPaywall(opts) {
+    const gateway = new Gateway(opts);
+    const bindBody = opts.bindBody !== false;
+    return async function middleware(req, res, next) {
+        try {
+            const method = req.method.toUpperCase();
+            // Fail closed rather than silently downgrade: if body binding is on and we
+            // cannot see the raw bytes, a payment for one body would unlock any other.
+            if (bindBody && BODY_METHODS.has(method) && req.rawBody === undefined) {
+                res
+                    .status(500)
+                    .set("Cache-Control", "no-store")
+                    .json({
+                    error: "gateway_misconfigured: body binding is enabled but req.rawBody is unset. " +
+                        "Add `app.use(express.json({ verify: captureRawBody }))`, or pass `bindBody: false` " +
+                        "to accept that a payment for one body unlocks any other.",
+                });
+                return;
+            }
+            const decision = await gateway.authorize({
+                method,
+                url: absoluteUrl(req),
+                headers: flatHeaders(req),
+                body: req.rawBody,
+            });
+            if (decision.kind !== "allow") {
+                for (const [k, v] of Object.entries(decision.headers))
+                    res.set(k, v);
+                res.status(decision.status).json(decision.body);
+                return;
+            }
+            for (const [k, v] of Object.entries(decision.headers))
+                res.set(k, v);
+            req.payment = decision.receipt;
+            next();
+        }
+        catch (err) {
+            next(err);
+        }
+    };
+}

package/dist/adapters/fetch.d.ts

@@ -0,0 +1,27 @@
+import { Gateway, type GatewayOptions } from "../gateway.js";
+import type { SettlementReceipt } from "../protocol.js";
+export type FetchHandler<Ctx = unknown> = (req: Request, ctx: Ctx) => Response | Promise<Response>;
+/** A handler that also receives the settlement receipt for the request. */
+export type PaidHandler<Ctx = unknown> = (req: Request, ctx: Ctx, receipt: SettlementReceipt) => Response | Promise<Response>;
+/**
+ * Wrap a fetch-style handler so it only runs after payment.
+ *
+ * @example
+ *   // app/api/weather/route.ts
+ *   import { paywall } from "@furlpay/gateway";
+ *
+ *   const pay = paywall({
+ *     price: 0.01,
+ *     payTo: process.env.MERCHANT_WALLET!,
+ *     quoteSecret: process.env.QUOTE_SECRET!,
+ *     network: "base",
+ *   });
+ *
+ *   export const GET = pay(async () => Response.json({ tempC: 17 }));
+ */
+export declare function paywall(opts: GatewayOptions): {
+    <Ctx = unknown>(handler: PaidHandler<Ctx>): FetchHandler<Ctx>;
+    gateway: Gateway;
+};
+/** Escape hatch for hand-rolled routing: get the decision, do what you like. */
+export declare function createGateway(opts: GatewayOptions): Gateway;

package/dist/adapters/fetch.js

@@ -0,0 +1,63 @@
+import { Gateway } from "../gateway.js";
+function toResponse(decision) {
+    return new Response(JSON.stringify(decision.body), {
+        status: decision.status,
+        headers: decision.headers,
+    });
+}
+/** Read the body without consuming it for the wrapped handler. */
+async function readBody(req) {
+    if (!req.body)
+        return undefined;
+    try {
+        return await req.clone().text();
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Wrap a fetch-style handler so it only runs after payment.
+ *
+ * @example
+ *   // app/api/weather/route.ts
+ *   import { paywall } from "@furlpay/gateway";
+ *
+ *   const pay = paywall({
+ *     price: 0.01,
+ *     payTo: process.env.MERCHANT_WALLET!,
+ *     quoteSecret: process.env.QUOTE_SECRET!,
+ *     network: "base",
+ *   });
+ *
+ *   export const GET = pay(async () => Response.json({ tempC: 17 }));
+ */
+export function paywall(opts) {
+    const gateway = new Gateway(opts);
+    function wrap(handler) {
+        return async (req, ctx) => {
+            const decision = await gateway.authorize({
+                method: req.method,
+                url: req.url,
+                headers: req.headers,
+                body: await readBody(req),
+            });
+            if (decision.kind !== "allow")
+                return toResponse(decision);
+            const res = await handler(req, ctx, decision.receipt);
+            // Stamp the receipt and no-store onto whatever the handler returned. A
+            // paid 200 that a CDN caches is a paid resource served free to the next
+            // unpaid caller, so this is not optional.
+            const out = new Response(res.body, res);
+            for (const [k, v] of Object.entries(decision.headers))
+                out.headers.set(k, v);
+            return out;
+        };
+    }
+    wrap.gateway = gateway;
+    return wrap;
+}
+/** Escape hatch for hand-rolled routing: get the decision, do what you like. */
+export function createGateway(opts) {
+    return new Gateway(opts);
+}

package/dist/adapters/proxy.d.ts

@@ -0,0 +1,26 @@
+import http from "node:http";
+import { type GatewayOptions } from "../gateway.js";
+export interface ProxyOptions extends GatewayOptions {
+    /** Origin to forward paid requests to, e.g. "http://localhost:8000". */
+    origin: string;
+    port?: number;
+    hostname?: string;
+    /** Paths served free (health checks, docs, openapi.json). Exact or prefix*. */
+    freePaths?: string[];
+    /** Public base URL, when behind a TLS terminator. Resource identity — and so
+     *  the quote binding — is derived from this, and it must match what the agent
+     *  actually requested or every binding check fails. */
+    publicUrl?: string;
+}
+/**
+ * Build (but do not start) the paywalling reverse proxy.
+ * Returns a standard `http.Server` — call `.listen()` yourself, or use
+ * `startProxy` which does it for you.
+ */
+export declare function createProxy(opts: ProxyOptions): http.Server;
+export interface RunningProxy {
+    server: http.Server;
+    port: number;
+    close(): Promise<void>;
+}
+export declare function startProxy(opts: ProxyOptions): Promise<RunningProxy>;