@reinconsole/gate 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,561 @@
+import { GateReceipt, ReinEvent } from '@reinconsole/core';
+export { GateReceipt, ReinEvent } from '@reinconsole/core';
+import { PaymentRequirement, PaymentRequired, FetchLike } from '@reinconsole/sdk';
+export { PaymentRequired, PaymentRequirement } from '@reinconsole/sdk';
+import { IncomingMessage, ServerResponse } from 'node:http';
+
+/**
+ * Why the gate turned a payment away. Stable strings — clients switch on these.
+ *
+ * Two classes carry no payer fault and MUST NOT feed reputation evidence
+ * (@reinconsole/graph skips them): the throttle codes (`rate_limited`,
+ * `velocity_exceeded` — the vendor's cap, not payer misbehavior) and the rails
+ * codes (`rails_unavailable`, `settle_unknown` — the vendor's infrastructure
+ * failing; a settle_unknown payment may even have gone through).
+ */
+type GateRefusalCode = 'malformed_payment' | 'scheme_mismatch' | 'network_mismatch' | 'amount_mismatch' | 'recipient_mismatch' | 'payer_denied' | 'payer_not_allowed' | 'payment_replayed'
+/** Too many presentations in the velocity window (429; Retry-After set). */
+ | 'rate_limited'
+/** The settled-spend cap would be exceeded (429; Retry-After when a slot frees). */
+ | 'velocity_exceeded' | 'verify_failed' | 'settle_failed'
+/** The rails could not be reached and the payment provably did NOT settle
+ *  (503). The replay slot is released — the same header may be re-presented. */
+ | 'rails_unavailable'
+/** Settlement was attempted but its fate is unknown — the request may have
+ *  reached the rails (503). The slot stays burned; do NOT re-pay blindly:
+ *  reconcile against transaction records (e.g. the on-chain indexer) first. */
+ | 'settle_unknown';
+declare class GateError extends Error {
+    readonly code: GateRefusalCode;
+    /** Seconds until the refused payment could be admitted (throttle codes). */
+    readonly retryAfterSeconds?: number;
+    constructor(code: GateRefusalCode, message: string, options?: {
+        retryAfterSeconds?: number;
+    });
+}
+
+/**
+ * The gate's settlement seam. The gate decides WHETHER a payment is acceptable
+ * (routes, screening, replay, amount cross-checks); the rails decide whether it
+ * is VALID and move the money. Both Rein rails plug in via the structural
+ * adapters below — @reinconsole/gate deliberately imports neither, so vendors install
+ * only what they run.
+ */
+interface GateRails {
+    /** Throw GateError('verify_failed') if the payment does not check out. */
+    verify(paymentHeader: string, requirement: PaymentRequirement): Promise<void>;
+    /** Move the money. Throw GateError('settle_failed') if it cannot. */
+    settle(paymentHeader: string, requirement: PaymentRequirement): Promise<GateSettlement>;
+}
+/**
+ * Error taxonomy at this seam — the gate's retry policy hangs off it:
+ *
+ * - `GateError` — a semantic verdict (bad signature, rejected authorization).
+ *   Final; never retried.
+ * - `RailsUnreachableError` — the request PROVABLY never reached the rails
+ *   (connection refused, DNS failure). Safe to retry, even for settle.
+ * - anything else — ambiguous transport failure (timeout, connection reset,
+ *   gateway error): the request MAY have executed. verify is read-only so the
+ *   gate retries it anyway; an ambiguous settle failure is never retried and
+ *   refuses `settle_unknown`, because re-settling an authorization that
+ *   actually landed would misreport a paid payment as failed.
+ */
+declare class RailsUnreachableError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+interface GateSettlement {
+    /** Ready-made X-PAYMENT-RESPONSE header value. */
+    header: string;
+    /** Settlement transaction hash (mock ledger or on-chain). */
+    transaction: string;
+    network: string;
+    payer?: string;
+}
+/** What the gate needs of @reinconsole/mock-rails' MockFacilitator (structural). */
+interface MockFacilitatorLike {
+    verify(paymentHeader: string, requirement: PaymentRequirement): unknown;
+    settle(paymentHeader: string, requirement: PaymentRequirement): {
+        header: string;
+        response: {
+            transaction: string;
+            network: string;
+            payer?: string;
+        };
+    };
+}
+/** Wire the gate to the mock rails (offline twin; throws map to refusals). */
+declare function mockFacilitatorRails(facilitator: MockFacilitatorLike): GateRails;
+/** What the gate needs of @reinconsole/x402-rails' FacilitatorClient (structural).
+ *  `requirements` is untyped because the DIALECT varies per payment: v1
+ *  payments relay Rein's internal (v1-shaped) requirement, v2 payments the
+ *  converted v2 shape (see facilitatorClientRails). */
+interface FacilitatorClientLike {
+    verify(payload: unknown, requirements: unknown): Promise<{
+        isValid: boolean;
+        invalidReason?: string;
+    }>;
+    settle(payload: unknown, requirements: unknown): Promise<{
+        success: boolean;
+        errorReason?: string;
+        transaction: string;
+        network: string;
+        payer?: string;
+    }>;
+}
+/**
+ * Wire the gate to a real x402 facilitator client. The facilitator wants the
+ * DECODED payment envelope; the gate re-decodes the header it already
+ * inspected and relays the facilitator's settle response verbatim into the
+ * settlement header (tx hash included). Requirements travel in the same
+ * dialect the payment arrived in — a v2 envelope is verified against
+ * v2-shaped (amount/CAIP-2) requirements.
+ */
+declare function facilitatorClientRails(client: FacilitatorClientLike): GateRails;
+
+/**
+ * One priced route. Anything a route doesn't override falls back to the
+ * gate-level payment defaults, so most vendors only write `path` + `price`.
+ */
+interface GateRoute {
+    /** Glob over the request path, e.g. "/api/reports/*". First match wins. */
+    path: string;
+    /** HTTP method (case-insensitive); omit to price every method. */
+    method?: string;
+    /** Human-unit decimal price, e.g. "0.05". */
+    price: string;
+    description?: string;
+    mimeType?: string;
+    payTo?: string;
+    network?: string;
+    asset?: string;
+    /** Atomic decimals of the asset (default 6, all Rein stablecoins). */
+    decimals?: number;
+    maxTimeoutSeconds?: number;
+    /** EIP-712 domain hints etc., merged over the gate-level extra. */
+    extra?: Record<string, unknown>;
+}
+/** Gate-level payment defaults every route inherits. */
+interface PaymentDefaults {
+    payTo: string;
+    network: string;
+    asset: string;
+    decimals?: number;
+    maxTimeoutSeconds?: number;
+    extra?: Record<string, unknown>;
+}
+/** First route whose method and path glob accept the request, or undefined. */
+declare function matchRoute(routes: readonly GateRoute[], method: string, pathname: string): GateRoute | undefined;
+declare function routeDecimals(route: GateRoute, defaults: PaymentDefaults): number;
+/**
+ * Build the v1 payment requirement this route quotes for a concrete resource
+ * URL. Fully populated (description/mimeType/maxTimeoutSeconds, absolute
+ * resource) because hosted facilitators validate requirements strictly.
+ */
+declare function requirementFor(route: GateRoute, defaults: PaymentDefaults, resourceUrl: string): PaymentRequirement;
+
+/** Sync for in-memory stores; durable stores return a promise. */
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * The gate's storage seam. Two consistency classes live here, split the same
+ * way the engine and graph stores are:
+ *
+ * - **Replay slots are security state** — the gate AWAITS `burnReplay`, and a
+ *   durable impl persists the burn BEFORE resolving. A payment settles only
+ *   after its slot is durably burned, so a crash-and-restart cannot let the
+ *   same header settle twice (the mock ledger, unlike the chain, would).
+ * - **Receipts and counters are telemetry** — writes may trail behind
+ *   (cache-then-persist), with `flush()` as the error channel: it drains
+ *   pending writes and throws the first failure since the last flush.
+ *
+ * Reads are synchronous from the working set (`stats()` stays sync).
+ */
+interface GateStorePort {
+    /**
+     * Check-and-burn a replay slot: returns false when this exact payment was
+     * already presented. The check-and-set MUST happen synchronously at call
+     * time so two concurrent copies of one header cannot both see it fresh;
+     * a durable impl then persists the burn before resolving. Slots are never
+     * released — a failed settle after the burn stays burned (deliberate:
+     * the payer must re-quote).
+     */
+    burnReplay(key: string): MaybePromise<boolean>;
+    /**
+     * OPTIONAL: remove a burned slot (memory AND disk). The gate calls this in
+     * exactly one situation — the rails PROVABLY never saw the payment
+     * (`rails_unavailable`), so re-presenting the same header is safe once they
+     * return. Stores that omit it leave the slot burned: conservative, the
+     * payer re-signs instead. Never called after an ambiguous settle.
+     */
+    releaseReplay?(key: string): MaybePromise<void>;
+    /** Record a settled payment's receipt (may trail; see flush). Note: the
+     *  receipt is the ONLY durable record of a settlement — a hard crash with
+     *  the tail unflushed permanently undercounts that payment's revenue. */
+    appendReceipt(receipt: GateReceipt): MaybePromise<void>;
+    /** Count a 402 quote served (may trail; see flush). */
+    recordQuote(): MaybePromise<void>;
+    /** Count a refused payment (may trail; see flush). */
+    recordRefusal(): MaybePromise<void>;
+    receipts(): readonly GateReceipt[];
+    quoted(): number;
+    refused(): number;
+    /** Durable impls: drain trailing writes, throw the first failure. */
+    flush?(): Promise<void>;
+}
+/** In-memory gate store — the default, and the working set durable stores hydrate into. */
+declare class InMemoryGateStore implements GateStorePort {
+    private readonly seenPayments;
+    private readonly receiptLog;
+    private quotedCount;
+    private refusedCount;
+    burnReplay(key: string): boolean;
+    /**
+     * Release a burned slot — on the port (optional) since the rails-unreachable
+     * path, and still what a persist-then-cache impl uses to leave memory
+     * untouched when its own INSERT fails.
+     */
+    releaseReplay(key: string): void;
+    appendReceipt(receipt: GateReceipt): void;
+    recordQuote(): void;
+    recordRefusal(): void;
+    /** Hydration primitive for durable stores: set the resumed counter totals. */
+    loadCounters(quoted: number, refused: number): void;
+    receipts(): readonly GateReceipt[];
+    quoted(): number;
+    refused(): number;
+}
+
+/**
+ * Per-payer velocity limits, all sharing one rolling window. Two evidence
+ * sources, deliberately different in durability:
+ *
+ * - `maxPayments` / `maxAmount` cap SETTLED spend and are derived from the
+ *   gate's receipts at check time — on a durable store they survive restarts
+ *   for free (receipts hydrate), and they never drift from revenue truth.
+ * - `maxAttempts` caps PRESENTATIONS (any outcome) and lives in memory only —
+ *   refused attempts leave no durable row, so this counter resets on restart.
+ *   That is acceptable for what it protects against (hammering), and it keeps
+ *   the port unchanged.
+ *
+ * Limits are gate-wide per payer (no per-route caps in v0.1). A payment
+ * refused for velocity is NOT replay-burned — the same signed header may be
+ * re-presented once the window clears; the refusal carries Retry-After.
+ */
+interface GateVelocity {
+    /** Rolling window in milliseconds. */
+    windowMs: number;
+    /** Max settled payments per payer inside the window (any asset). */
+    maxPayments?: number;
+    /**
+     * Max settled decimal amount per payer inside the window, compared per
+     * asset (only receipts in the incoming payment's asset count toward it).
+     * Also acts as a per-payment ceiling: a single payment above it never
+     * clears, and its refusal carries no Retry-After.
+     */
+    maxAmount?: string;
+    /** Max payment presentations per payer inside the window, any outcome. */
+    maxAttempts?: number;
+}
+/** Fail fast on misconfiguration — a silent zero-cap gate refuses everyone. */
+declare function validateVelocity(velocity: GateVelocity): void;
+
+/** Wallet-address screening. Addresses compare case-insensitively (EVM rule). */
+interface GateScreen {
+    /** If set, ONLY these payers may pay. */
+    allowPayers?: readonly string[];
+    /** These payers are always refused, allowlist or not. */
+    denyPayers?: readonly string[];
+    /**
+     * Dynamic screening hook, consulted after the static lists with the payer
+     * address as presented. Return a refusal reason to turn the payer away
+     * (403, code `payer_denied`); return undefined to let the payment proceed.
+     * Reputation-driven screening (@reinconsole/graph's `payerCheck`) plugs in here.
+     */
+    check?: (payer: string) => string | undefined;
+}
+interface GateOptions {
+    /** Priced routes; first match wins. Unmatched requests pass through free. */
+    routes: readonly GateRoute[];
+    /** Settlement rails: mockFacilitatorRails(...) or facilitatorClientRails(...). */
+    rails: GateRails;
+    /** Default recipient address (a route can override). */
+    payTo: string;
+    /** Default x402 network id, e.g. "base" (mock rails) or "base-sepolia". */
+    network: string;
+    /** Default asset: a symbol (mock rails) or token contract address (real). */
+    asset: string;
+    decimals?: number;
+    maxTimeoutSeconds?: number;
+    /** EIP-712 domain hints etc., quoted on every requirement. */
+    extra?: Record<string, unknown>;
+    screen?: GateScreen;
+    /**
+     * Also advertise quotes on the x402 v2 wire: 402 outcomes gain a
+     * `paymentRequiredHeader` (base64 PaymentRequired, CAIP-2 networks) that the
+     * adapters send as `PAYMENT-REQUIRED`, alongside the unchanged v1 body —
+     * dual-stack, each dialect reads its own channel. Off by default. Note the
+     * gate ACCEPTS v2 payments (PAYMENT-SIGNATURE envelopes) regardless of this
+     * flag; it only controls what quotes advertise.
+     */
+    advertiseV2?: boolean;
+    /** Per-payer velocity limits (see GateVelocity). Off when omitted. */
+    velocity?: GateVelocity;
+    /**
+     * Rails transport-failure retry policy. `attempts` counts EXTRA tries after
+     * the first (default 2), spaced `backoffMs * attemptNumber` apart (default
+     * 250ms; pass 0 in tests). Applies only to transport failures — a GateError
+     * from the rails is a semantic verdict and is never retried. See GateRails
+     * for which settle failures are retry-safe.
+     */
+    retry?: {
+        attempts?: number;
+        backoffMs?: number;
+    };
+    /** Injectable clock (tests). */
+    now?: () => Date;
+    /**
+     * Gate storage. Defaults in-memory; pass @reinconsole/store's gate store and
+     * receipts, revenue stats, and burned replay slots survive restarts.
+     */
+    store?: GateStorePort;
+}
+/** The transport-agnostic request shape every adapter reduces to. */
+interface GateRequest {
+    method: string;
+    /** Absolute request URL (quoted verbatim as the requirement's resource). */
+    url: string;
+    /** Raw X-PAYMENT header value, or null when absent. */
+    payment: string | null;
+}
+type GateOutcome = 
+/** No priced route matched — the vendor serves this request for free. */
+{
+    kind: 'open';
+}
+/** No payment attached: here is what this resource costs. The optional
+ *  `paymentRequiredHeader` (advertiseV2) is the base64 v2 PaymentRequired
+ *  for the PAYMENT-REQUIRED response header. */
+ | {
+    kind: 'quote';
+    status: 402;
+    body: PaymentRequired;
+    paymentRequiredHeader?: string;
+}
+/**
+ * A payment was attached and turned away. 403 = screening, 402 = re-quote,
+ * 429 = throttled (retryAfterSeconds set when a slot will free), 503 = the
+ * rails failed us (`rails_unavailable` = provably unsettled, slot released;
+ * `settle_unknown` = fate unknown, slot stays burned — do not re-pay blindly).
+ */
+ | {
+    kind: 'refused';
+    status: 402 | 403 | 429 | 503;
+    code: GateRefusalCode;
+    reason: string;
+    body: unknown;
+    retryAfterSeconds?: number;
+    /** On 402 re-quotes with advertiseV2: the v2 PAYMENT-REQUIRED value. */
+    paymentRequiredHeader?: string;
+}
+/** Verified and settled — serve, attaching settlementHeader as X-PAYMENT-RESPONSE. */
+ | {
+    kind: 'paid';
+    receipt: GateReceipt;
+    settlementHeader: string;
+};
+interface GateLineStats {
+    settled: number;
+    revenue: string;
+}
+interface GateStats {
+    quoted: number;
+    settled: number;
+    refused: number;
+    /** Decimal revenue grouped by asset. */
+    revenue: Record<string, string>;
+    /** Per route pattern. */
+    routes: Record<string, GateLineStats>;
+    /** Per payer (lowercased address). */
+    payers: Record<string, GateLineStats>;
+}
+/**
+ * Rein Gate — the vendor side of the wire. One gate fronts one vendor API:
+ * it quotes x402 requirements for priced routes, cross-checks and screens
+ * incoming payments, settles them through the configured rails, and keeps
+ * vendor-side receipts so monetization is observable, not anecdotal.
+ *
+ * Check order for a presented payment: envelope decode -> rate limit ->
+ * quote consistency (scheme/network/amount/recipient) -> payer screening ->
+ * velocity caps -> replay burn -> rails verify -> rails settle. The replay
+ * slot is burned BEFORE the async legs so two concurrent copies of the same
+ * payment cannot both settle (the mock ledger, unlike the chain, would
+ * happily double-spend); throttle refusals fire before the burn so a
+ * velocity-refused header can be re-presented once its window clears.
+ */
+declare class Gate {
+    private readonly routes;
+    private readonly rails;
+    private readonly defaults;
+    private readonly allowPayers;
+    private readonly denyPayers;
+    private readonly screenCheck;
+    private readonly advertiseV2;
+    private readonly velocity;
+    private readonly attempts;
+    private readonly retryPolicy;
+    private readonly now;
+    private readonly bus;
+    private readonly store;
+    constructor(options: GateOptions);
+    onEvent(handler: (event: ReinEvent) => void): void;
+    get receipts(): readonly GateReceipt[];
+    /** Drain trailing telemetry writes; throws the first failure (durable stores). */
+    flush(): Promise<void>;
+    /** Telemetry writes may trail (cache-then-persist) — a store failure,
+     *  rejected OR thrown synchronously, must surface through flush() and can
+     *  never alter a payment outcome (a receipt write turning a SETTLED payment
+     *  into a 500 would charge the payer and serve nothing). */
+    private fire;
+    /** The requirement a given request would be quoted (or undefined if free). */
+    quoteFor(method: string, url: string): PaymentRequirement | undefined;
+    handle(request: GateRequest): Promise<GateOutcome>;
+    stats(): GateStats;
+    private emit;
+    private checkConsistency;
+    /**
+     * Presentation rate limit — first check after decode, so a hammering payer
+     * is shed before any further work. Every presentation counts, including
+     * ones that would go on to fail consistency or screening.
+     */
+    private checkRate;
+    /**
+     * Settled-spend velocity caps, derived from receipts at check time (restart
+     * -safe on durable stores). Runs BEFORE the replay burn on purpose: a
+     * velocity refusal is temporal, not a payment defect, so the same signed
+     * header may come back once the window clears.
+     */
+    private checkVelocity;
+    /**
+     * Drive both rails legs under the retry policy (see GateRails for the error
+     * taxonomy). GateErrors are semantic verdicts and pass straight through.
+     * Transport failures:
+     *
+     * - verify (read-only): every transport failure is retried; exhausted ->
+     *   `rails_unavailable`, and the slot is released (settle never ran).
+     * - settle: only RailsUnreachableError (provably never sent) is retried;
+     *   exhausted -> `rails_unavailable` + release (still provably unsettled).
+     *   Anything else is ambiguous — the money MAY have moved — so it refuses
+     *   `settle_unknown` immediately and the slot STAYS burned: on real rails a
+     *   re-present would misreport (nonce already used -> settle_failed), and on
+     *   the mock ledger it would double-spend. Vendors reconcile ambiguous
+     *   settles against transaction records (e.g. the on-chain indexer).
+     */
+    private settleThroughRails;
+    private railsLeg;
+    private screenPayer;
+    /**
+     * Burn the replay slot. The store's check-and-set is sync at call time
+     * (concurrent copies cannot both pass); the await is the durability barrier
+     * — on a durable store the burn is on disk before verify/settle run, so a
+     * crash mid-settle cannot resurrect the slot on restart. A store WRITE
+     * failure is not a GateError: it escapes as a 500, because "we cannot
+     * guarantee replay protection" must never settle a payment.
+     */
+    private burnReplay;
+    private refuse;
+    /** The v2 half of a dual-stack 402 (see advertiseV2), or nothing. */
+    private v2Quote;
+}
+declare function createGate(options: GateOptions): Gate;
+
+/** The CAIP-2 id for a network name, or the lowercased name when unknown. */
+declare function caip2Of(network: string): string;
+/** Do two network ids name the same chain, across the v1/CAIP-2 divide? */
+declare function sameNetwork(a: string, b: string): boolean;
+/** x402 v2 PaymentRequirements (one entry of a 402's `accepts`). */
+interface PaymentRequirementsV2 {
+    scheme: string;
+    /** CAIP-2, e.g. "eip155:84532". */
+    network: string;
+    /** Atomic units — v2's rename of v1's maxAmountRequired. */
+    amount: string;
+    asset: string;
+    payTo: string;
+    maxTimeoutSeconds?: number;
+    extra?: Record<string, unknown>;
+}
+/** v2 PaymentRequired — the decoded PAYMENT-REQUIRED header. */
+interface PaymentRequiredV2 {
+    x402Version: 2;
+    error?: string;
+    resource?: {
+        url: string;
+        description?: string;
+        mimeType?: string;
+    };
+    accepts: PaymentRequirementsV2[];
+    extensions?: Record<string, unknown>;
+}
+/** Convert Rein's internal (v1-shaped) requirement to the v2 wire shape. */
+declare function v2Requirements(requirement: PaymentRequirement): PaymentRequirementsV2;
+/** The full v2 PaymentRequired for one quoted requirement. */
+declare function buildPaymentRequiredV2(requirement: PaymentRequirement, error: string): PaymentRequiredV2;
+/** The one codec every x402 header uses: base64 of compact JSON. */
+declare function encodeBase64Json(value: unknown): string;
+
+interface GateMiddlewareOptions {
+    /**
+     * Origin used to absolutize req.url for quotes, e.g. "https://api.vendor.com".
+     * Defaults to http://<Host header> — set this when serving behind TLS/proxies
+     * so quoted resources match what agents actually requested.
+     */
+    origin?: string;
+    /** Called with every outcome — the vendor's observability hook. */
+    onOutcome?: (outcome: GateOutcome, req: IncomingMessage) => void;
+}
+/**
+ * Drop the gate in front of any Node HTTP handler. Express-compatible
+ * `(req, res, next)` signature; with a raw `node:http` server, pass your
+ * content handler as `next`:
+ *
+ *   const paywall = gateMiddleware(gate);
+ *   http.createServer((req, res) => paywall(req, res, () => serve(req, res)));
+ *
+ * Free and paid requests reach `next()` (paid ones with X-PAYMENT-RESPONSE
+ * already set on the response); quotes and refusals are answered here and
+ * never reach the vendor's handler.
+ */
+declare function gateMiddleware(gate: Gate, options?: GateMiddlewareOptions): (req: IncomingMessage, res: ServerResponse, next: () => void) => void;
+
+interface GatedFetchOptions {
+    /** Serves the actual content once the gate clears a request. */
+    serve?: (request: {
+        url: string;
+        method: string;
+    }) => Response | Promise<Response>;
+}
+/**
+ * The gate as an in-process vendor fetch — a drop-in replacement for
+ * createMockVendor()/createRealVendor() anywhere a FetchLike vendor is
+ * composed (guard tests, demos, the console world), with the gate's pricing,
+ * screening, replay protection, and receipts in the loop.
+ */
+declare function createGatedFetch(gate: Gate, options?: GatedFetchOptions): FetchLike;
+
+interface InspectedPayment {
+    /** Which wire dialect the payment arrived in. */
+    version: 1 | 2;
+    scheme: string;
+    network: string;
+    /** The paying wallet address (`from` in the transfer). */
+    payer: string;
+    to: string;
+    /** Atomic-unit amount. */
+    value: string;
+    /** The decoded envelope exactly as sent, for rails that re-verify it. */
+    envelope: unknown;
+}
+declare function inspectPaymentHeader(raw: string): InspectedPayment;
+
+export { type FacilitatorClientLike, Gate, GateError, type GateLineStats, type GateMiddlewareOptions, type GateOptions, type GateOutcome, type GateRails, type GateRefusalCode, type GateRequest, type GateRoute, type GateScreen, type GateSettlement, type GateStats, type GateStorePort, type GateVelocity, type GatedFetchOptions, InMemoryGateStore, type InspectedPayment, type MaybePromise, type MockFacilitatorLike, type PaymentDefaults, type PaymentRequiredV2, type PaymentRequirementsV2, RailsUnreachableError, buildPaymentRequiredV2, caip2Of, createGate, createGatedFetch, encodeBase64Json, facilitatorClientRails, gateMiddleware, inspectPaymentHeader, matchRoute, mockFacilitatorRails, requirementFor, routeDecimals, sameNetwork, v2Requirements, validateVelocity };