@routedock/routedock 0.1.0

package/dist/index.cjs

@@ -0,0 +1,932 @@
+'use strict';
+
+var stellarSdk = require('@stellar/stellar-sdk');
+var Ajv = require('ajv');
+var stellar = require('@x402/stellar');
+var client = require('@x402/stellar/exact/client');
+var client$1 = require('@x402/core/client');
+var http = require('@x402/core/http');
+var client$3 = require('@stellar/mpp/charge/client');
+var client$2 = require('mppx/client');
+var client$4 = require('@stellar/mpp/channel/client');
+var facilitator = require('@x402/stellar/exact/facilitator');
+var server$1 = require('@stellar/mpp/charge/server');
+var server = require('mppx/server');
+var server$2 = require('@stellar/mpp/channel/server');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
+
+// src/types.ts
+var RouteDockError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RouteDockError";
+  }
+};
+var RouteDockManifestError = class extends RouteDockError {
+  constructor(message) {
+    super(message);
+    this.name = "RouteDockManifestError";
+  }
+};
+var RouteDockNoSupportedModeError = class extends RouteDockError {
+  constructor(message) {
+    super(message);
+    this.name = "RouteDockNoSupportedModeError";
+  }
+};
+var RouteDockSessionError = class extends RouteDockError {
+  constructor(message) {
+    super(message);
+    this.name = "RouteDockSessionError";
+  }
+};
+var RouteDockPolicyRejectedError = class extends RouteDockError {
+  reason;
+  constructor(reason) {
+    super(`Payment rejected by policy: ${reason}`);
+    this.name = "RouteDockPolicyRejectedError";
+    this.reason = reason;
+  }
+};
+
+// src/schemas/routedock.schema.json
+var routedock_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://routedock.dev/schemas/routedock.schema.json",
+  title: "RouteDock Manifest",
+  description: "Discovery manifest served at /.well-known/routedock.json on every RouteDock provider endpoint",
+  type: "object",
+  required: [
+    "routedock",
+    "name",
+    "description",
+    "modes",
+    "network",
+    "asset",
+    "asset_contract",
+    "payee",
+    "pricing",
+    "endpoints",
+    "tags"
+  ],
+  additionalProperties: false,
+  properties: {
+    routedock: {
+      type: "string",
+      const: "1.0",
+      description: "Manifest schema version. Always '1.0' for this version."
+    },
+    name: {
+      type: "string",
+      minLength: 1,
+      maxLength: 120,
+      description: "Human-readable provider name"
+    },
+    description: {
+      type: "string",
+      minLength: 1,
+      maxLength: 500,
+      description: "Human-readable description of the provider's data or service"
+    },
+    modes: {
+      type: "array",
+      minItems: 1,
+      uniqueItems: true,
+      items: {
+        $ref: "#/definitions/PaymentMode"
+      },
+      description: "Payment modes supported by this provider"
+    },
+    network: {
+      type: "string",
+      enum: ["testnet", "mainnet"],
+      description: "Stellar network this provider operates on"
+    },
+    asset: {
+      type: "string",
+      description: "Asset ticker symbol (e.g. 'USDC')"
+    },
+    asset_contract: {
+      type: "string",
+      description: "Stellar Asset Contract (SAC) address for the payment asset"
+    },
+    payee: {
+      type: "string",
+      description: "Stellar address (G...) that receives payments"
+    },
+    pricing: {
+      type: "object",
+      description: "Pricing configuration per supported payment mode",
+      additionalProperties: false,
+      properties: {
+        x402: {
+          $ref: "#/definitions/PricingConfig"
+        },
+        "mpp-charge": {
+          $ref: "#/definitions/PricingConfig"
+        },
+        "mpp-session": {
+          $ref: "#/definitions/SessionPricingConfig"
+        }
+      },
+      minProperties: 1
+    },
+    endpoints: {
+      type: "object",
+      description: "Map of endpoint name to HTTP method + path (e.g. { 'price': 'GET /price' })",
+      additionalProperties: {
+        type: "string"
+      },
+      minProperties: 1
+    },
+    tags: {
+      type: "array",
+      items: {
+        type: "string",
+        minLength: 1,
+        maxLength: 64
+      },
+      uniqueItems: true,
+      description: "Capability tags indexed with trigram search in the provider registry"
+    }
+  },
+  definitions: {
+    PaymentMode: {
+      type: "string",
+      enum: ["x402", "mpp-charge", "mpp-session"],
+      description: "A supported RouteDock payment mode"
+    },
+    PricingConfig: {
+      type: "object",
+      description: "Per-request pricing for x402 or mpp-charge modes",
+      required: ["amount", "per"],
+      additionalProperties: false,
+      properties: {
+        amount: {
+          type: "string",
+          description: "Cost per request in the payment asset (decimal string, e.g. '0.001')"
+        },
+        per: {
+          type: "string",
+          const: "request",
+          description: "Billing unit \u2014 always 'request' for non-session modes"
+        },
+        facilitator: {
+          type: "string",
+          description: "x402 facilitator URL (required for x402 mode). OpenZeppelin Channels endpoint."
+        }
+      }
+    },
+    SessionPricingConfig: {
+      type: "object",
+      description: "Per-voucher pricing for mpp-session (one-way-channel) mode",
+      required: ["rate", "per", "channel_contract", "min_deposit", "refund_waiting_period_ledgers"],
+      additionalProperties: false,
+      properties: {
+        rate: {
+          type: "string",
+          description: "Cost per voucher in the payment asset (decimal string, e.g. '0.0001')"
+        },
+        per: {
+          type: "string",
+          const: "voucher",
+          description: "Billing unit \u2014 always 'voucher' for session mode"
+        },
+        channel_contract: {
+          type: "string",
+          description: "Soroban contract address (C...) for the one-way-channel contract"
+        },
+        min_deposit: {
+          type: "string",
+          description: "Minimum initial deposit to open a channel (decimal string)"
+        },
+        refund_waiting_period_ledgers: {
+          type: "integer",
+          minimum: 1,
+          description: "Ledgers the server has to settle before the funder can reclaim. Default: 17280 (~24h). Do not reduce in production."
+        }
+      }
+    }
+  }
+};
+
+// src/client/ModeRouter.ts
+var ajv = new Ajv__default.default();
+var validateManifest = ajv.compile(routedock_schema_default);
+var CACHE_TTL_MS = 6e4;
+var manifestCache = /* @__PURE__ */ new Map();
+async function fetchManifest(baseUrl) {
+  const cached = manifestCache.get(baseUrl);
+  if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
+    return cached.manifest;
+  }
+  const url = baseUrl.replace(/\/$/, "") + "/.well-known/routedock.json";
+  let raw;
+  try {
+    const resp = await fetch(url);
+    if (!resp.ok) {
+      throw new RouteDockManifestError(`Manifest fetch failed: HTTP ${resp.status} from ${url}`);
+    }
+    raw = await resp.json();
+  } catch (err) {
+    if (err instanceof RouteDockManifestError) throw err;
+    throw new RouteDockManifestError(`Manifest fetch error: ${String(err)}`);
+  }
+  if (!validateManifest(raw)) {
+    const msgs = ajv.errorsText(validateManifest.errors);
+    throw new RouteDockManifestError(`Invalid manifest at ${url}: ${msgs}`);
+  }
+  const manifest = raw;
+  manifestCache.set(baseUrl, { manifest, fetchedAt: Date.now() });
+  return manifest;
+}
+function selectMode(manifest, options = {}) {
+  const modes = manifest.modes;
+  if (options.forceMode) {
+    if (!modes.includes(options.forceMode)) {
+      throw new RouteDockNoSupportedModeError(
+        `Provider does not support forced mode: ${options.forceMode} (available: ${modes.join(", ")})`
+      );
+    }
+    console.log(`[RouteDock] ${manifest.name} \u2192 ${options.forceMode} (forced)`);
+    return options.forceMode;
+  }
+  if ((options.sustained || options.session) && modes.includes("mpp-session")) {
+    const mode = "mpp-session";
+    console.log(`[RouteDock] ${manifest.name} \u2192 ${mode}`);
+    return mode;
+  }
+  if (modes.includes("mpp-charge")) {
+    const mode = "mpp-charge";
+    console.log(`[RouteDock] ${manifest.name} \u2192 ${mode}`);
+    return mode;
+  }
+  if (modes.includes("x402")) {
+    const mode = "x402";
+    console.log(`[RouteDock] ${manifest.name} \u2192 ${mode}`);
+    return mode;
+  }
+  throw new RouteDockNoSupportedModeError(
+    `No supported payment mode found in manifest (modes: ${modes.join(", ")})`
+  );
+}
+var CAIP2 = {
+  testnet: "stellar:testnet",
+  mainnet: "stellar:pubnet"
+};
+var X402Client = class {
+  constructor(secretKey, network) {
+    this.secretKey = secretKey;
+    this.network = network;
+    const caip2 = CAIP2[network];
+    const signer = stellar.createEd25519Signer(secretKey, caip2);
+    const scheme = new client.ExactStellarScheme(signer);
+    const core = new client$1.x402Client();
+    core.register(caip2, scheme);
+    this.httpClient = new client$1.x402HTTPClient(core);
+  }
+  secretKey;
+  network;
+  httpClient;
+  async pay(url, manifest) {
+    const pricing = manifest.pricing.x402;
+    if (!pricing) {
+      throw new RouteDockManifestError("manifest.pricing.x402 missing");
+    }
+    if (!pricing.facilitator) {
+      throw new RouteDockManifestError("manifest.pricing.x402.facilitator missing");
+    }
+    const init = await fetch(url, { headers: { "X-Preferred-Mode": "x402" } });
+    if (init.status !== 402) {
+      const data2 = await init.json();
+      return { data: data2, txHash: null, mode: "x402", amount: pricing.amount, timestamp: Date.now() };
+    }
+    const reqHeader = init.headers.get("X-Payment-Requirements");
+    if (!reqHeader) {
+      throw new RouteDockManifestError("402 response missing X-Payment-Requirements header");
+    }
+    const paymentRequired = http.decodePaymentRequiredHeader(reqHeader);
+    const paymentPayload = await this.httpClient.createPaymentPayload(paymentRequired);
+    const paymentHeaders = this.httpClient.encodePaymentSignatureHeader(paymentPayload);
+    const settled = await fetch(url, { headers: paymentHeaders });
+    if (!settled.ok) {
+      throw new RouteDockManifestError(`x402 payment failed: HTTP ${settled.status}`);
+    }
+    let txHash = null;
+    const responseHeader = settled.headers.get("X-Payment-Response");
+    if (responseHeader) {
+      try {
+        const settleResponse = http.decodePaymentResponseHeader(responseHeader);
+        txHash = settleResponse.transaction ?? null;
+      } catch {
+      }
+    }
+    const data = await settled.json();
+    return { data, txHash, mode: "x402", amount: pricing.amount, timestamp: Date.now() };
+  }
+};
+var MppChargeClient = class {
+  constructor(keypair, network) {
+    this.keypair = keypair;
+    this.network = network;
+  }
+  keypair;
+  network;
+  async pay(url, manifest) {
+    const pricing = manifest.pricing["mpp-charge"];
+    if (!pricing) {
+      throw new RouteDockManifestError("manifest.pricing.mpp-charge missing");
+    }
+    let txHash = null;
+    const mppx = client$2.Mppx.create({
+      polyfill: false,
+      methods: [
+        client$3.stellar.charge({
+          keypair: this.keypair,
+          mode: "pull",
+          onProgress(event) {
+            if (event.type === "paid") {
+              txHash = event.hash;
+            }
+          }
+        })
+      ]
+    });
+    const response = await mppx.fetch(url);
+    if (!response.ok) {
+      throw new RouteDockManifestError(`MPP charge failed: HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    return { data, txHash, mode: "mpp-charge", amount: pricing.amount, timestamp: Date.now() };
+  }
+};
+var MIN_REFUND_WAITING_PERIOD = 17280;
+var MppSessionClient = class {
+  constructor(keypair, network) {
+    this.keypair = keypair;
+    this.network = network;
+  }
+  keypair;
+  network;
+  async openSession(url, manifest, commitmentSecret) {
+    const pricing = manifest.pricing["mpp-session"];
+    if (!pricing) {
+      throw new RouteDockManifestError("manifest.pricing.mpp-session missing");
+    }
+    const refundPeriod = pricing.refund_waiting_period_ledgers;
+    if (refundPeriod < MIN_REFUND_WAITING_PERIOD) {
+      throw new RouteDockManifestError(
+        `refund_waiting_period_ledgers ${refundPeriod} < minimum ${MIN_REFUND_WAITING_PERIOD}`
+      );
+    }
+    const commitmentKey = stellarSdk.Keypair.fromSecret(commitmentSecret);
+    const channelContract = pricing.channel_contract;
+    const agentPublicKey = this.keypair.publicKey();
+    let currentCumulative = 0n;
+    let vouchersIssued = 0;
+    const mppx = client$2.Mppx.create({
+      polyfill: false,
+      methods: [
+        client$4.stellar.channel({
+          commitmentKey,
+          sourceAccount: this.keypair.publicKey(),
+          onProgress(event) {
+            if (event.type === "signed") {
+              currentCumulative = BigInt(event.cumulativeAmount);
+            }
+          }
+        })
+      ]
+    });
+    const openTxHash = channelContract;
+    const handle = {
+      channelId: channelContract,
+      openTxHash,
+      async *stream() {
+        while (true) {
+          let resp = null;
+          for (let attempt = 0; attempt < 3; attempt++) {
+            try {
+              resp = await mppx.fetch(url);
+              if (resp.ok) break;
+              resp = null;
+            } catch {
+              if (attempt === 2) throw new RouteDockSessionError("Voucher request failed after 3 retries");
+              await new Promise((r) => setTimeout(r, 1e3 * (attempt + 1)));
+            }
+          }
+          if (!resp || !resp.ok) {
+            throw new RouteDockSessionError(`Voucher request failed: HTTP ${resp?.status ?? "unknown"}`);
+          }
+          vouchersIssued++;
+          yield await resp.json();
+        }
+      },
+      async close() {
+        const { rpc: rpcMod, Contract, nativeToScVal, TransactionBuilder, BASE_FEE } = await import('@stellar/stellar-sdk');
+        const rpcUrl = "https://soroban-testnet.stellar.org";
+        const server = new rpcMod.Server(rpcUrl);
+        const contract = new Contract(channelContract);
+        const passphrase = "Test SDF Network ; September 2015";
+        const account = await server.getAccount(agentPublicKey);
+        const simTx = new TransactionBuilder(account, { fee: BASE_FEE, networkPassphrase: passphrase }).addOperation(contract.call("prepare_commitment", nativeToScVal(currentCumulative, { type: "i128" }))).setTimeout(30).build();
+        const simResult = await server.simulateTransaction(simTx);
+        if (rpcMod.Api.isSimulationError(simResult)) {
+          throw new RouteDockSessionError(`prepare_commitment simulation failed: ${simResult.error}`);
+        }
+        const commitmentBytes = simResult.result?.retval?.bytes();
+        if (!commitmentBytes) throw new RouteDockSessionError("prepare_commitment returned no bytes");
+        const signature = commitmentKey.sign(Buffer.from(commitmentBytes));
+        const closeResp = await fetch(url, {
+          method: "DELETE",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            amount: currentCumulative.toString(),
+            signature: Buffer.from(signature).toString("hex")
+          })
+        });
+        if (!closeResp.ok) {
+          throw new RouteDockSessionError(`Channel close failed: HTTP ${closeResp.status}`);
+        }
+        const closeData = await closeResp.json();
+        const closeTxHash = closeData.closeTxHash ?? null;
+        if (!closeTxHash) {
+          throw new RouteDockSessionError("Channel close response missing closeTxHash");
+        }
+        const totalPaid = (Number(currentCumulative) / 1e7).toFixed(7);
+        return { closeTxHash, totalPaid, vouchersIssued };
+      }
+    };
+    return handle;
+  }
+};
+
+// src/client/RouteDockClient.ts
+var RouteDockClient = class {
+  keypair;
+  network;
+  spendCap;
+  commitmentSecret;
+  /** Local daily accumulator keyed by YYYY-MM-DD */
+  dailySpend = { date: "", total: 0 };
+  x402;
+  charge;
+  session;
+  constructor(config) {
+    this.keypair = typeof config.wallet === "string" ? stellarSdk.Keypair.fromSecret(config.wallet) : config.wallet;
+    this.network = config.network;
+    this.spendCap = config.spendCap;
+    this.commitmentSecret = config.commitmentSecret;
+    const secretKey = this.keypair.secret();
+    this.x402 = new X402Client(secretKey, this.network);
+    this.charge = new MppChargeClient(this.keypair, this.network);
+    this.session = new MppSessionClient(this.keypair, this.network);
+  }
+  /**
+   * Pay for one request at `url`. Fetches manifest, selects payment mode,
+   * checks local spend cap, executes payment, returns result.
+   */
+  async pay(url, options) {
+    const baseUrl = new URL(url).origin;
+    const manifest = await fetchManifest(baseUrl);
+    const mode = selectMode(manifest, options);
+    let result;
+    switch (mode) {
+      case "x402":
+        result = await this.x402.pay(url, manifest);
+        break;
+      case "mpp-charge":
+        result = await this.charge.pay(url, manifest);
+        break;
+      case "mpp-session":
+        throw new RouteDockManifestError(
+          "Use client.openSession() for mpp-session mode \u2014 client.pay() only handles discrete payments"
+        );
+      default:
+        throw new RouteDockManifestError(`Unknown payment mode: ${mode}`);
+    }
+    this._checkAndRecordSpend(result.amount);
+    return result;
+  }
+  /**
+   * Open a sustained MPP session at `url`. Verifies mpp-session is supported
+   * before opening a channel. Returns a SessionHandle for streaming + closing.
+   */
+  async openSession(url) {
+    const baseUrl = new URL(url).origin;
+    const manifest = await fetchManifest(baseUrl);
+    if (!manifest.modes.includes("mpp-session")) {
+      throw new RouteDockManifestError(
+        `Provider at ${baseUrl} does not support mpp-session mode`
+      );
+    }
+    if (!this.commitmentSecret) {
+      throw new RouteDockManifestError(
+        "commitmentSecret is required in RouteDockClientConfig for mpp-session mode"
+      );
+    }
+    return this.session.openSession(url, manifest, this.commitmentSecret);
+  }
+  /** Check local daily cap and record the spend. Throws if cap exceeded. */
+  _checkAndRecordSpend(amount) {
+    if (!this.spendCap) return;
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    if (this.dailySpend.date !== today) {
+      this.dailySpend = { date: today, total: 0 };
+    }
+    const amountNum = parseFloat(amount);
+    const capNum = parseFloat(this.spendCap.daily);
+    if (this.dailySpend.total + amountNum > capNum) {
+      throw new RouteDockPolicyRejectedError("local_daily_cap_exceeded");
+    }
+    this.dailySpend.total += amountNum;
+  }
+};
+
+// src/store/SessionStore.ts
+var SupabaseSessionStore = class {
+  constructor(supabase) {
+    this.supabase = supabase;
+  }
+  supabase;
+  async get(channelId) {
+    const { data, error } = await this.supabase.from("sessions").select("*").eq("channel_id", channelId).maybeSingle();
+    if (error) throw new RouteDockSessionError(`SessionStore.get failed: ${error.message}`);
+    if (!data) return null;
+    return {
+      channel_id: data.channel_id,
+      payee: data.payee,
+      payer: data.payer,
+      cumulative_amount: String(data.cumulative_amount),
+      last_signature: data.last_signature,
+      status: data.status,
+      opened_at: data.opened_at,
+      updated_at: data.updated_at,
+      settlement_tx_hash: data.settlement_tx_hash
+    };
+  }
+  async upsert(channelId, state) {
+    const existing = await this.get(channelId);
+    if (existing) {
+      const prev = parseFloat(existing.cumulative_amount);
+      const next = parseFloat(state.cumulative_amount);
+      if (next <= prev) {
+        throw new RouteDockSessionError(
+          `cumulative_amount must be strictly increasing: ${next} <= ${prev}`
+        );
+      }
+    }
+    const { error } = await this.supabase.from("sessions").upsert(
+      {
+        channel_id: state.channel_id,
+        payee: state.payee,
+        payer: state.payer,
+        cumulative_amount: state.cumulative_amount,
+        last_signature: state.last_signature,
+        status: state.status,
+        opened_at: state.opened_at,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+        settlement_tx_hash: state.settlement_tx_hash
+      },
+      { onConflict: "channel_id" }
+    );
+    if (error) {
+      if (error.message.includes("strictly increasing")) {
+        throw new RouteDockSessionError(
+          `cumulative_amount must be strictly increasing (DB): ${error.message}`
+        );
+      }
+      throw new RouteDockSessionError(`SessionStore.upsert failed: ${error.message}`);
+    }
+  }
+  async close(channelId) {
+    const { error } = await this.supabase.from("sessions").update({ status: "closed", updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("channel_id", channelId);
+    if (error) throw new RouteDockSessionError(`SessionStore.close failed: ${error.message}`);
+  }
+};
+var CAIP22 = {
+  testnet: "stellar:testnet",
+  mainnet: "stellar:pubnet"
+};
+function createX402Handler(opts) {
+  const caip2 = CAIP22[opts.network];
+  const payeeKeypair = stellarSdk.Keypair.fromSecret(opts.payeeSecretKey);
+  const signer = stellar.createEd25519Signer(opts.payeeSecretKey, caip2);
+  const facilitatorScheme = new facilitator.ExactStellarScheme([signer], {
+    areFeesSponsored: true
+  });
+  const amountInBaseUnits = String(Math.round(parseFloat(opts.amount) * 1e7));
+  const requirements = {
+    scheme: "exact",
+    network: caip2,
+    asset: opts.assetContract,
+    amount: amountInBaseUnits,
+    payTo: opts.manifest.payee,
+    maxTimeoutSeconds: 60,
+    extra: {
+      areFeesSponsored: true,
+      facilitatorAddresses: [payeeKeypair.publicKey()]
+    }
+  };
+  return async (req, res, next) => {
+    try {
+      const paymentHeader = req.headers["payment-signature"] ?? req.headers["x-payment"];
+      if (!paymentHeader) {
+        const x402Response = {
+          x402Version: 2,
+          resource: {
+            url: `${req.protocol}://${req.get("host") ?? ""}${req.originalUrl}`,
+            description: opts.manifest.name
+          },
+          accepts: [requirements]
+        };
+        res.status(402).setHeader("Content-Type", "application/json").setHeader("X-Payment-Requirements", http.encodePaymentRequiredHeader(x402Response)).json({ error: "Payment Required" });
+        return;
+      }
+      const payload = http.decodePaymentSignatureHeader(paymentHeader);
+      const verifyResult = await facilitatorScheme.verify(
+        payload,
+        requirements
+      );
+      if (!verifyResult.isValid) {
+        res.status(401).json({
+          error: "Payment verification failed",
+          reason: verifyResult.invalidReason
+        });
+        return;
+      }
+      const settleResult = await facilitatorScheme.settle(
+        payload,
+        requirements
+      );
+      const txHash = settleResult.transaction ?? null;
+      if (txHash && opts.onSettled) {
+        await opts.onSettled(txHash, opts.amount, "x402");
+      }
+      if (settleResult) {
+        res.setHeader(
+          "X-Payment-Response",
+          http.encodePaymentResponseHeader(
+            settleResult
+          )
+        );
+      }
+      next();
+    } catch (err) {
+      console.error("[x402] Settlement error:", err);
+      res.status(500).json({ error: "Payment settlement failed" });
+    }
+  };
+}
+var MPP_NETWORK = {
+  testnet: "stellar:testnet",
+  mainnet: "stellar:pubnet"
+};
+function createMppChargeHandler(opts) {
+  const networkId = MPP_NETWORK[opts.network];
+  const amountHumanReadable = opts.amount;
+  const mppx = server.Mppx.create({
+    secretKey: opts.payeeSecretKey,
+    methods: [
+      server$1.stellar.charge({
+        recipient: opts.manifest.payee,
+        currency: opts.assetContract,
+        network: networkId,
+        feePayer: { envelopeSigner: opts.payeeSecretKey }
+      })
+    ]
+  });
+  return async (req, res, next) => {
+    try {
+      const fetchReq = server.Request.fromNodeListener(req, res);
+      const handler = mppx["stellar/charge"];
+      const result = await handler({
+        amount: amountHumanReadable,
+        currency: opts.assetContract,
+        recipient: opts.manifest.payee,
+        description: opts.manifest.name
+      })(fetchReq);
+      if (result.status === 402) {
+        const challenge = result.challenge;
+        res.status(402);
+        challenge.headers.forEach((v, k) => res.setHeader(k, v));
+        res.send(await challenge.text());
+        return;
+      }
+      const receipt = result.withReceipt(new Response(""));
+      receipt.headers.forEach((v, k) => res.setHeader(k, v));
+      const receiptHeader = receipt.headers.get("payment-receipt");
+      if (receiptHeader && opts.onSettled) {
+        try {
+          const parsed = JSON.parse(
+            Buffer.from(receiptHeader, "base64").toString("utf8")
+          );
+          if (parsed.reference) {
+            await opts.onSettled(parsed.reference, opts.amount, "mpp-charge");
+          }
+        } catch {
+        }
+      }
+      next();
+    } catch (err) {
+      next(err);
+    }
+  };
+}
+var MPP_NETWORK2 = {
+  testnet: "stellar:testnet",
+  mainnet: "stellar:pubnet"
+};
+function createMppSessionHandler(opts) {
+  const networkId = MPP_NETWORK2[opts.network];
+  const rateHuman = opts.rate;
+  const payeeKeypair = stellarSdk.Keypair.fromSecret(opts.payeeSecretKey);
+  const cumulativeKey = `stellar:channel:cumulative:${opts.channelContract}`;
+  const innerStore = server$2.Store.memory();
+  let lastCumulativeAmount = 0n;
+  const wrappedStore = {
+    async get(key) {
+      return innerStore.get(key);
+    },
+    async put(key, value) {
+      await innerStore.put(key, value);
+      if (key === cumulativeKey && value && typeof value === "object" && "amount" in value) {
+        lastCumulativeAmount = BigInt(value.amount);
+      }
+    },
+    async delete(key) {
+      return innerStore.delete(key);
+    }
+  };
+  const mppx = server.Mppx.create({
+    secretKey: opts.payeeSecretKey,
+    methods: [
+      server$2.stellar.channel({
+        channel: opts.channelContract,
+        commitmentKey: opts.commitmentPublicKey,
+        network: networkId,
+        store: wrappedStore,
+        sourceAccount: payeeKeypair.publicKey(),
+        feePayer: { envelopeSigner: payeeKeypair }
+      })
+    ]
+  });
+  let lastSignatureHex = "";
+  return async (req, res, next) => {
+    try {
+      if (req.method === "DELETE") {
+        const body = req.body;
+        const closeAmount = body?.amount ? BigInt(body.amount) : lastCumulativeAmount;
+        const closeSig = body?.signature ?? lastSignatureHex;
+        if (closeAmount > 0n && closeSig) {
+          const closeTxHash = await server$2.close({
+            channel: opts.channelContract,
+            amount: closeAmount,
+            signature: Buffer.from(closeSig, "hex"),
+            feePayer: { envelopeSigner: payeeKeypair },
+            network: networkId
+          });
+          if (opts.onSettled) {
+            const totalPaid = (Number(lastCumulativeAmount) / 1e7).toFixed(7);
+            await opts.onSettled(closeTxHash, totalPaid, "mpp-session");
+          }
+          res.json({ closeTxHash });
+        } else {
+          res.json({ closeTxHash: null, message: "no vouchers received" });
+        }
+        return;
+      }
+      const authHeader = req.headers["authorization"];
+      if (typeof authHeader === "string" && authHeader.startsWith("Payment ")) {
+        try {
+          const credB64 = authHeader.replace(/^Payment\s+/, "").split(",").find((p) => p.trim().startsWith("credential="));
+          if (credB64) {
+            const credJson = Buffer.from(credB64.split("=").slice(1).join("=").replace(/^"|"$/g, ""), "base64").toString("utf8");
+            const cred = JSON.parse(credJson);
+            if (cred.payload?.signature) {
+              lastSignatureHex = cred.payload.signature;
+            }
+          }
+        } catch {
+        }
+      }
+      const fetchReq = server.Request.fromNodeListener(req, res);
+      const result = await mppx.channel({
+        amount: rateHuman,
+        description: opts.manifest.name
+      })(fetchReq);
+      if (result.status === 402) {
+        const challenge = result.challenge;
+        res.status(402);
+        challenge.headers.forEach((v, k) => res.setHeader(k, v));
+        const body = await challenge.text();
+        res.send(body);
+        return;
+      }
+      next();
+    } catch (err) {
+      next(err);
+    }
+  };
+}
+
+// src/provider/routedockMiddleware.ts
+function routedock(opts) {
+  const handlers = [];
+  if (opts.modes.includes("x402")) {
+    const x402Price = opts.pricing.x402;
+    if (x402Price) {
+      handlers.push(
+        createX402Handler({
+          payeeSecretKey: opts.payeeSecretKey,
+          network: opts.network,
+          amount: x402Price,
+          assetContract: opts.assetContract,
+          ...opts.facilitatorApiKey ? { facilitatorApiKey: opts.facilitatorApiKey } : {},
+          manifest: opts.manifest,
+          ...opts.onSettled ? { onSettled: opts.onSettled } : {}
+        })
+      );
+    }
+  }
+  if (opts.modes.includes("mpp-charge")) {
+    const chargePrice = opts.pricing["mpp-charge"];
+    if (chargePrice) {
+      handlers.push(
+        createMppChargeHandler({
+          payeeSecretKey: opts.payeeSecretKey,
+          network: opts.network,
+          amount: chargePrice,
+          assetContract: opts.assetContract,
+          manifest: opts.manifest,
+          ...opts.onSettled ? { onSettled: opts.onSettled } : {}
+        })
+      );
+    }
+  }
+  if (opts.modes.includes("mpp-session")) {
+    const sessionPricing = opts.pricing["mpp-session"];
+    if (sessionPricing) {
+      if (!opts.commitmentPublicKey) {
+        throw new Error("routedock: mpp-session mode requires commitmentPublicKey");
+      }
+      handlers.push(
+        createMppSessionHandler({
+          payeeSecretKey: opts.payeeSecretKey,
+          network: opts.network,
+          channelContract: sessionPricing.channelContract,
+          rate: sessionPricing.rate,
+          assetContract: opts.assetContract,
+          manifest: opts.manifest,
+          commitmentPublicKey: opts.commitmentPublicKey,
+          ...opts.onSettled ? { onSettled: opts.onSettled } : {}
+        })
+      );
+    }
+  }
+  return (req, res, next) => {
+    if (req.path === "/.well-known/routedock.json") {
+      res.json(opts.manifest);
+      return;
+    }
+    if (handlers.length === 0) {
+      next();
+      return;
+    }
+    const hasX402Header = !!(req.headers["payment-signature"] || req.headers["x-payment"]);
+    const prefersX402 = req.headers["x-preferred-mode"] === "x402";
+    let handler;
+    if (hasX402Header || prefersX402) {
+      handler = handlers[0];
+    } else {
+      handler = handlers[handlers.length - 1];
+    }
+    if (!handler) {
+      next();
+      return;
+    }
+    void Promise.resolve().then(() => new Promise((resolve, reject) => {
+      handler(req, res, (handlerErr) => {
+        if (handlerErr != null) reject(handlerErr);
+        else resolve();
+      });
+    })).then(() => next()).catch((err) => next(err));
+  };
+}
+
+exports.MppChargeClient = MppChargeClient;
+exports.MppSessionClient = MppSessionClient;
+exports.RouteDockClient = RouteDockClient;
+exports.RouteDockError = RouteDockError;
+exports.RouteDockManifestError = RouteDockManifestError;
+exports.RouteDockNoSupportedModeError = RouteDockNoSupportedModeError;
+exports.RouteDockPolicyRejectedError = RouteDockPolicyRejectedError;
+exports.RouteDockSessionError = RouteDockSessionError;
+exports.SupabaseSessionStore = SupabaseSessionStore;
+exports.X402Client = X402Client;
+exports.fetchManifest = fetchManifest;
+exports.routedock = routedock;
+exports.selectMode = selectMode;