@routedock/routedock 0.1.2 → 0.3.0

package/dist/provider/hono.cjs

@@ -0,0 +1,1152 @@
+'use strict';
+
+var stellarSdk = require('@stellar/stellar-sdk');
+var facilitator = require('@x402/stellar/exact/facilitator');
+var server$1 = require('@x402/stellar/exact/server');
+var server = require('@x402/core/server');
+var stellar = require('@x402/stellar');
+var http = require('@x402/core/http');
+var server$4 = require('@stellar/mpp/charge/server');
+var server$2 = require('@stellar/mpp/channel/server');
+var server$3 = require('mppx/server');
+var crypto$1 = require('crypto');
+var nulthSdk = require('@routedock/nulth-sdk');
+var mppx = require('mppx');
+
+// src/provider/hono.ts
+
+// src/errors.ts
+var RouteDockError = class extends Error {
+  code;
+  retryable;
+  retryAfterMs;
+  constructor(message, code, retryable, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "RouteDockError";
+    this.code = code;
+    this.retryable = retryable;
+    if (options.retryAfterMs !== void 0) {
+      this.retryAfterMs = options.retryAfterMs;
+    }
+  }
+};
+var RouteDockManifestError = class extends RouteDockError {
+  constructor(message, options = {}) {
+    super(message, "MANIFEST", false, options);
+    this.name = "RouteDockManifestError";
+  }
+};
+var RouteDockNetworkError = class extends RouteDockError {
+  constructor(message, options = {}) {
+    super(message, "NETWORK", true, options);
+    this.name = "RouteDockNetworkError";
+  }
+};
+var RouteDockSignatureError = class extends RouteDockError {
+  constructor(message, options = {}) {
+    super(message, "SIGNATURE", false, options);
+    this.name = "RouteDockSignatureError";
+  }
+};
+
+// src/manifest/sign.ts
+var MANIFEST_SIGNATURE_VERSION = "2";
+function canonicalize(value) {
+  if (Array.isArray(value)) {
+    return value.map(canonicalize);
+  }
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.keys(value).sort().map((key) => [key, canonicalize(value[key])])
+    );
+  }
+  return value;
+}
+function manifestDigest(manifest) {
+  const { signature: _omit, ...rest } = manifest;
+  const canonical = JSON.stringify(canonicalize(rest));
+  return crypto$1.createHash("sha256").update(canonical, "utf8").digest();
+}
+function signManifest(manifest, payeeSecretKey) {
+  const keypair = stellarSdk.Keypair.fromSecret(payeeSecretKey);
+  const versionedManifest = {
+    ...manifest,
+    signature_version: MANIFEST_SIGNATURE_VERSION
+  };
+  const digest = manifestDigest(versionedManifest);
+  const sig = keypair.sign(digest);
+  return { ...versionedManifest, signature: Buffer.from(sig).toString("base64") };
+}
+function verifyManifestSignature(manifest, expectedPayee) {
+  if (!manifest.signature) {
+    throw new RouteDockSignatureError(
+      "Manifest is missing a signature field \u2014 cannot verify payee authenticity"
+    );
+  }
+  if (manifest.signature_version !== MANIFEST_SIGNATURE_VERSION) {
+    throw new RouteDockSignatureError(
+      `Manifest signature version must be ${MANIFEST_SIGNATURE_VERSION}; legacy signatures are not safe because nested fields were excluded from their digest`
+    );
+  }
+  const keypair = stellarSdk.Keypair.fromPublicKey(manifest.payee);
+  const digest = manifestDigest(manifest);
+  let sigBytes;
+  try {
+    sigBytes = Buffer.from(manifest.signature, "base64");
+  } catch {
+    throw new RouteDockSignatureError("Manifest signature is not valid base64");
+  }
+  let valid = false;
+  try {
+    valid = keypair.verify(digest, sigBytes);
+  } catch {
+    throw new RouteDockSignatureError(
+      `Manifest signature verification failed for payee ${manifest.payee}`
+    );
+  }
+  if (!valid) {
+    throw new RouteDockSignatureError(
+      `Manifest signature verification failed for payee ${manifest.payee}`
+    );
+  }
+}
+
+// src/internal/payee.ts
+function resolvePayee(manifest, mode) {
+  const override = manifest.pricing[mode]?.payee;
+  return override ?? manifest.payee;
+}
+var usdcToUnits = nulthSdk.usdcToStroops;
+function extractPayerAddress(key) {
+  if (typeof key !== "string") return null;
+  return stellarSdk.StrKey.isValidEd25519PublicKey(key) || stellarSdk.StrKey.isValidMed25519PublicKey(key) ? key : null;
+}
+
+// src/internal/logger.ts
+function createConsoleLogger() {
+  return (level, message, fields) => {
+    const values = fields ? Object.values(fields) : [];
+    if (values.length > 0) {
+      console[level](message, ...values);
+    } else {
+      console[level](message);
+    }
+  };
+}
+var consoleLogger = createConsoleLogger();
+function resolveLogger(logger, fallback = consoleLogger) {
+  return logger ?? fallback;
+}
+function channelAuthorizer(envelopeSigner) {
+  return { envelopeSigner };
+}
+function formatMppError(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  try {
+    const serialized = JSON.stringify(error);
+    return serialized === void 0 ? String(error) : serialized;
+  } catch {
+    return String(error);
+  }
+}
+function withTypedChannelErrors(method) {
+  return {
+    ...method,
+    async verify(parameters) {
+      try {
+        return await method.verify(parameters);
+      } catch (error) {
+        throw mapChannelError(error);
+      }
+    }
+  };
+}
+function onVerifiedCredential(method, commit) {
+  return {
+    ...method,
+    async verify(parameters) {
+      const receipt = await method.verify(parameters);
+      await commit(parameters.credential);
+      return receipt;
+    }
+  };
+}
+function mapChannelError(error) {
+  const message = formatMppError(error);
+  const details = error && typeof error === "object" && "details" in error ? error.details : void 0;
+  const reason = details && Object.keys(details).length > 0 ? `${message} (${JSON.stringify(details)})` : message;
+  if (/signer mismatch|authori[sz]er|unauthori[sz]ed/i.test(message)) {
+    return new mppx.Errors.SignerMismatchError({ reason });
+  }
+  if (/already used|replay|challenge/i.test(message)) {
+    return new mppx.Errors.InvalidChallengeError({ reason });
+  }
+  if (/channel has been closed|channel is closed|finalized/i.test(message)) {
+    return new mppx.Errors.ChannelClosedError({ reason });
+  }
+  if (/exceeds channel balance|exceeds.*deposit/i.test(message)) {
+    return new mppx.Errors.AmountExceedsDepositError({ reason });
+  }
+  if (/channel not found|no channel/i.test(message)) {
+    return new mppx.Errors.ChannelNotFoundError({ reason });
+  }
+  if (/must be greater|does not cover|below.*minimum/i.test(message)) {
+    return new mppx.Errors.DeltaTooSmallError({ reason });
+  }
+  if (/signature/i.test(message)) {
+    return new mppx.Errors.InvalidSignatureError({ reason });
+  }
+  return new mppx.Errors.VerificationFailedError({ reason });
+}
+
+// src/provider/encoding.ts
+function base64ToUtf8(b64) {
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return new TextDecoder().decode(bytes);
+}
+function hexToBytes(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  if (clean.length % 2 !== 0) {
+    throw new Error("hexToBytes: hex string must have an even length");
+  }
+  const bytes = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+
+// src/provider/SeenTxStore.ts
+var SETTLEMENT_REPLAY_WINDOW_MS = 6e4;
+var MAX_SETTLEMENT_REPLAYS = 1;
+async function checkSettlementReplay(store, key, now = Date.now()) {
+  const record = await store.get(key);
+  if (!record) return { kind: "miss" };
+  const { createdAt } = record;
+  if (createdAt !== void 0 && now - createdAt > SETTLEMENT_REPLAY_WINDOW_MS) {
+    return { kind: "spent" };
+  }
+  if (store.claimReplay) {
+    const replayed = await store.claimReplay(key);
+    if (replayed > MAX_SETTLEMENT_REPLAYS) return { kind: "spent" };
+  }
+  return { kind: "replay", record };
+}
+var InMemorySeenTxStore = class {
+  map = /* @__PURE__ */ new Map();
+  replayCounts = /* @__PURE__ */ new Map();
+  order = [];
+  constructor(maxEntriesOrOptions = 1e4) {
+    const options = typeof maxEntriesOrOptions === "number" ? { maxEntries: maxEntriesOrOptions } : maxEntriesOrOptions;
+    this.maxEntries = options.maxEntries ?? 1e4;
+    if (options.warn !== false) {
+      const isServerless = typeof globalThis.navigator !== "undefined" && globalThis.navigator.userAgent === "Cloudflare-Workers";
+      if (isServerless) {
+        resolveLogger(options.logger)(
+          "warn",
+          "[RouteDock] Using in-memory SeenTxStore: settlement deduplication is NOT durable and resets on every isolate restart. Supply a SupabaseSeenTxStore (or other durable SeenTxStore) for production safety."
+        );
+      }
+    }
+  }
+  maxEntries;
+  get(key) {
+    return this.map.get(key);
+  }
+  set(key, record) {
+    if (!this.map.has(key)) {
+      this.order.push(key);
+      if (this.order.length > this.maxEntries) {
+        const evicted = this.order.shift();
+        if (evicted !== void 0) {
+          this.map.delete(evicted);
+          this.replayCounts.delete(evicted);
+        }
+      }
+    }
+    this.map.set(key, record);
+  }
+  claimReplay(key) {
+    if (!this.map.has(key)) return Number.POSITIVE_INFINITY;
+    const next = (this.replayCounts.get(key) ?? 0) + 1;
+    this.replayCounts.set(key, next);
+    return next;
+  }
+};
+async function sha256Hex(input) {
+  const buf = new TextEncoder().encode(input);
+  const digest = await crypto.subtle.digest("SHA-256", buf);
+  return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function paymentIdempotencyKey(getHeader, scope) {
+  const material = getHeader("payment-signature") ?? getHeader("x-payment") ?? getHeader("authorization");
+  if (!material) return null;
+  return sha256Hex(
+    [scope.method, scope.path, scope.amount, scope.payTo, material].join("\n")
+  );
+}
+
+// src/internal/assetUtils.ts
+function normalizeManifestAssets(manifest) {
+  if (manifest.assets && manifest.assets.length > 0) {
+    return manifest.assets;
+  }
+  if (manifest.asset && manifest.asset_contract) {
+    return [
+      {
+        asset: manifest.asset,
+        asset_contract: manifest.asset_contract
+      }
+    ];
+  }
+  throw new RouteDockManifestError(
+    "Manifest must define either assets[] or root asset/asset_contract fields"
+  );
+}
+function getEligibleAssets(manifest, mode, endpoint) {
+  const assets = normalizeManifestAssets(manifest);
+  return assets.filter((asset) => {
+    if (asset.modes && !asset.modes.includes(mode)) {
+      return false;
+    }
+    if (endpoint && asset.endpoints && asset.endpoints.length > 0) {
+      const trimmedEndpoint = endpoint.replace(/^\//, "");
+      if (asset.endpoints.includes(endpoint) || asset.endpoints.includes(trimmedEndpoint)) {
+        return true;
+      }
+      if (manifest.endpoints) {
+        let pathname = endpoint;
+        if (endpoint.startsWith("http://") || endpoint.startsWith("https://")) {
+          try {
+            pathname = new URL(endpoint).pathname;
+          } catch {
+          }
+        }
+        const trimmedPathname = pathname.replace(/^\//, "");
+        const matchesEndpoint = Object.entries(manifest.endpoints).some(([key, desc]) => {
+          const pathMatches = desc.path === pathname || desc.path === endpoint || desc.path.replace(/\/+$/, "") === pathname.replace(/\/+$/, "") || desc.path.replace(/^\//, "") === trimmedPathname;
+          const keyMatches = key === endpoint || key === trimmedEndpoint;
+          if (pathMatches || keyMatches) {
+            return asset.endpoints.includes(key) || asset.endpoints.includes(desc.path) || asset.endpoints.includes(desc.path.replace(/^\//, ""));
+          }
+          return false;
+        });
+        if (!matchesEndpoint) {
+          return false;
+        }
+      } else {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+function resolveAssetContract(manifest, mode, endpoint, explicitContract) {
+  if (manifest.assets && manifest.assets.length > 0) {
+    return selectAsset(manifest, mode, endpoint).asset_contract;
+  }
+  return explicitContract ?? selectAsset(manifest, mode, endpoint).asset_contract;
+}
+function selectAsset(manifest, mode, endpoint) {
+  const eligible = getEligibleAssets(manifest, mode, endpoint);
+  if (eligible.length === 0) {
+    const endpointMsg = endpoint ? ` for endpoint '${endpoint}'` : "";
+    throw new RouteDockManifestError(
+      `No eligible assets found for mode '${mode}'${endpointMsg}`
+    );
+  }
+  return eligible[0];
+}
+
+// src/provider/settleResult.ts
+function readSettleResult(result) {
+  const settle = result;
+  const failed = (reason) => reason ? { ok: false, reason } : { ok: false };
+  if (!settle || settle.success !== true) return failed(settle?.errorReason);
+  if (typeof settle.transaction !== "string" || settle.transaction.length === 0) {
+    return failed(settle.errorReason);
+  }
+  return { ok: true, txHash: settle.transaction };
+}
+
+// src/provider/registerProvider.ts
+async function registerProvider(optionsOrSupabase, manifestArg, baseUrlArg, verifiedArg) {
+  let supabase;
+  let manifest;
+  let baseUrl;
+  let verified;
+  if ("supabase" in optionsOrSupabase) {
+    supabase = optionsOrSupabase.supabase;
+    manifest = optionsOrSupabase.manifest;
+    baseUrl = optionsOrSupabase.baseUrl;
+    verified = optionsOrSupabase.verified ?? true;
+  } else {
+    supabase = optionsOrSupabase;
+    if (!manifestArg || !baseUrlArg) {
+      throw new RouteDockManifestError("manifest and baseUrl are required for registerProvider");
+    }
+    manifest = manifestArg;
+    baseUrl = baseUrlArg;
+    verified = verifiedArg ?? true;
+  }
+  verifyManifestSignature(manifest);
+  const normalizedBaseUrl = baseUrl.replace(/\/$/, "");
+  const { error } = await supabase.from("providers").upsert(
+    {
+      name: manifest.name,
+      description: manifest.description ?? null,
+      base_url: normalizedBaseUrl,
+      modes: manifest.modes,
+      tags: manifest.tags ?? [],
+      categories: manifest.categories ?? [],
+      network: manifest.network,
+      payee: manifest.payee,
+      manifest,
+      verified,
+      registered_at: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    { onConflict: "base_url" }
+  );
+  if (error) {
+    throw new Error(`Failed to register provider in Supabase: ${error.message}`);
+  }
+}
+
+// src/store/SupabaseSeenTxStore.ts
+var SupabaseSeenTxStore = class {
+  constructor(supabase) {
+    this.supabase = supabase;
+  }
+  supabase;
+  async get(key) {
+    const { data, error } = await this.supabase.from("settlements").select("tx_hash, headers, created_at").eq("key", key).maybeSingle();
+    if (error) {
+      throw new RouteDockNetworkError(`SupabaseSeenTxStore.get failed: ${error.message}`);
+    }
+    if (!data) return void 0;
+    const headers = data.headers;
+    return {
+      txHash: data.tx_hash ?? null,
+      ...headers ? { headers } : {},
+      createdAt: Date.parse(data.created_at)
+    };
+  }
+  async set(key, record) {
+    const { error } = await this.supabase.from("settlements").upsert(
+      {
+        key,
+        tx_hash: record.txHash,
+        headers: record.headers ?? null,
+        created_at: new Date(record.createdAt ?? Date.now()).toISOString()
+      },
+      { onConflict: "key" }
+    );
+    if (error) {
+      throw new RouteDockNetworkError(`SupabaseSeenTxStore.set failed: ${error.message}`);
+    }
+  }
+  /**
+   * Atomically increment the settlement's replay counter through the
+   * `claim_settlement_replay` Postgres function (migration 006). The UPDATE's
+   * row lock gives concurrent claims distinct counts. Returns `Infinity` when
+   * the key no longer exists, so the caller treats it as spent.
+   */
+  async claimReplay(key) {
+    const { data, error } = await this.supabase.rpc("claim_settlement_replay", {
+      p_key: key
+    });
+    if (error) {
+      throw new RouteDockNetworkError(`SupabaseSeenTxStore.claimReplay failed: ${error.message}`);
+    }
+    if (data == null) return Number.POSITIVE_INFINITY;
+    return data;
+  }
+};
+var MPP_NETWORK = {
+  testnet: "stellar:testnet",
+  mainnet: "stellar:pubnet"
+};
+function decimalToStroops(amountStr) {
+  return nulthSdk.usdcToStroops(amountStr);
+}
+async function reconcileAbandonedSessions(opts) {
+  const stats = {
+    orphanedCount: 0,
+    recoveredCount: 0,
+    skippedCount: 0,
+    failedCount: 0,
+    errors: []
+  };
+  const payeeKeypair = stellarSdk.Keypair.fromSecret(opts.payeeSecretKey);
+  const networkId = MPP_NETWORK[opts.network];
+  try {
+    const { data: closingSessions, error } = await opts.supabase.from("sessions").select("channel_id, channel_contract, cumulative_amount, last_signature, settlement_tx_hash").eq("status", "closing").eq("network", opts.network).eq("payee", payeeKeypair.publicKey()).is("settlement_tx_hash", null).not("last_signature", "is", null).order("updated_at", { ascending: true }).limit(100);
+    if (error) {
+      throw new Error(`Failed to query sessions: ${error.message}`);
+    }
+    stats.orphanedCount = closingSessions?.length ?? 0;
+    if (!closingSessions || closingSessions.length === 0) {
+      return stats;
+    }
+    for (const session of closingSessions) {
+      try {
+        const {
+          channel_id: sessionId,
+          channel_contract: channelContract,
+          cumulative_amount,
+          last_signature
+        } = session;
+        const channelId = channelContract || sessionId;
+        if (!channelId || !cumulative_amount || !last_signature) {
+          stats.skippedCount++;
+          continue;
+        }
+        const closeAmount = decimalToStroops(cumulative_amount);
+        const closeSig = Buffer.from(last_signature, "hex");
+        const closeFn = opts.channelClose ?? (await import('@stellar/mpp/channel/server')).close;
+        const closeTxHash = await closeFn({
+          channel: channelId,
+          amount: closeAmount,
+          signature: closeSig,
+          feePayer: channelAuthorizer(payeeKeypair),
+          network: networkId
+        });
+        const totalPaid = (Number(closeAmount) / 1e7).toFixed(7);
+        const { error: updateError } = await opts.supabase.from("sessions").update({
+          status: "closed",
+          settlement_tx_hash: closeTxHash,
+          updated_at: (/* @__PURE__ */ new Date()).toISOString()
+        }).eq("channel_id", sessionId);
+        if (updateError) {
+          throw new Error(`Failed to update session: ${updateError.message}`);
+        }
+        stats.recoveredCount++;
+        if (opts.onRecovered) {
+          await opts.onRecovered(channelId, closeTxHash, totalPaid);
+        }
+      } catch (err) {
+        stats.failedCount++;
+        stats.errors.push({
+          channelId: session.channel_id,
+          reason: formatMppError(err)
+        });
+      }
+    }
+    return stats;
+  } catch (err) {
+    throw new Error(
+      `Session reconciliation failed: ${formatMppError(err)}`
+    );
+  }
+}
+async function runStartupReconciliation(opts, logger) {
+  const log = resolveLogger(logger);
+  log("info", "[SessionReconciler] Running startup reconciliation...");
+  try {
+    const stats = await reconcileAbandonedSessions(opts);
+    if (stats.orphanedCount === 0) {
+      log("info", "[SessionReconciler] No orphaned sessions found");
+      return;
+    }
+    log(
+      "info",
+      `[SessionReconciler] Found ${stats.orphanedCount} orphaned session(s). Recovered: ${stats.recoveredCount}, Skipped: ${stats.skippedCount}, Failed: ${stats.failedCount}`
+    );
+    if (stats.errors.length > 0) {
+      log("warn", "[SessionReconciler] Reconciliation errors:");
+      for (const err of stats.errors) {
+        log("warn", `  - ${err.channelId}: ${err.reason}`);
+      }
+    }
+  } catch (err) {
+    log("error", `[SessionReconciler] Startup reconciliation failed: ${formatMppError(err)}`);
+  }
+}
+
+// src/provider/hono.ts
+var CAIP2 = {
+  testnet: "stellar:testnet",
+  mainnet: "stellar:pubnet"
+};
+var OZ_FACILITATOR_URL = "https://channels.openzeppelin.com/x402";
+function createX402HonoHandler(opts) {
+  const caip2 = CAIP2[opts.network];
+  const payeeKeypair = stellarSdk.Keypair.fromSecret(opts.payeeSecretKey);
+  const signer = stellar.createEd25519Signer(opts.payeeSecretKey, caip2);
+  const x402Price = opts.pricing.x402;
+  const logger = resolveLogger(opts.logger);
+  const seenTxStore = opts.seenTxStore ?? new InMemorySeenTxStore({ logger });
+  const useOzFacilitator = opts.network === "mainnet" && opts.facilitatorApiKey;
+  const localFacilitator = new facilitator.ExactStellarScheme([signer], {
+    areFeesSponsored: true
+  });
+  let ozServer = null;
+  if (useOzFacilitator) {
+    const apiKey = opts.facilitatorApiKey;
+    const facilitator = new server.HTTPFacilitatorClient({
+      url: OZ_FACILITATOR_URL,
+      createAuthHeaders: async () => ({
+        verify: { Authorization: `Bearer ${apiKey}` },
+        settle: { Authorization: `Bearer ${apiKey}` },
+        supported: { Authorization: `Bearer ${apiKey}` }
+      })
+    });
+    ozServer = new server.x402ResourceServer(facilitator);
+    ozServer.register(caip2, new server$1.ExactStellarScheme());
+  }
+  const amountInBaseUnits = String(usdcToUnits(x402Price));
+  return async (c, next) => {
+    try {
+      const endpoint = c.req.path;
+      const assetContract = resolveAssetContract(
+        opts.manifest,
+        "x402",
+        endpoint,
+        opts.assetContract
+      );
+      const requirements = {
+        scheme: "exact",
+        network: caip2,
+        asset: assetContract,
+        amount: amountInBaseUnits,
+        payTo: resolvePayee(opts.manifest, "x402"),
+        maxTimeoutSeconds: 60,
+        extra: {
+          areFeesSponsored: true,
+          ...useOzFacilitator ? {} : { facilitatorAddresses: [payeeKeypair.publicKey()] }
+        }
+      };
+      const respondPaymentRequired = async (error, reason) => {
+        if (ozServer) {
+          const resourceInfo = {
+            url: c.req.url,
+            description: opts.manifest.name
+          };
+          const paymentRequired = await ozServer.createPaymentRequiredResponse(
+            [requirements],
+            resourceInfo
+          );
+          c.header("X-Payment-Requirements", http.encodePaymentRequiredHeader(paymentRequired));
+        } else {
+          const x402Response = {
+            x402Version: 2,
+            resource: { url: c.req.url, description: opts.manifest.name },
+            accepts: [requirements]
+          };
+          c.header("X-Payment-Requirements", http.encodePaymentRequiredHeader(x402Response));
+        }
+        return c.json({ error, ...reason ? { reason } : {} }, 402);
+      };
+      const paymentHeader = c.req.header("payment-signature") ?? c.req.header("x-payment");
+      if (!paymentHeader) {
+        return respondPaymentRequired("Payment Required");
+      }
+      const idempotencyKey = await paymentIdempotencyKey(
+        (name) => c.req.header(name),
+        {
+          method: c.req.method,
+          path: c.req.path,
+          amount: requirements.amount,
+          payTo: requirements.payTo
+        }
+      );
+      if (idempotencyKey) {
+        const replayCheck = await checkSettlementReplay(seenTxStore, idempotencyKey);
+        if (replayCheck.kind === "spent") {
+          return c.json({ error: "Payment already used" }, 402);
+        }
+        if (replayCheck.kind === "replay") {
+          if (replayCheck.record.headers) {
+            for (const [k, val] of Object.entries(replayCheck.record.headers)) {
+              c.header(k, val);
+            }
+          }
+          await next();
+          return;
+        }
+      }
+      const payload = http.decodePaymentSignatureHeader(paymentHeader);
+      let txHash = null;
+      let paymentResponseHeader;
+      let payerAddress = null;
+      try {
+        const creds = payload.authorization?.credentials;
+        const key = Array.isArray(creds) ? creds[0]?.publicKey : void 0;
+        payerAddress = extractPayerAddress(key);
+      } catch {
+      }
+      if (ozServer) {
+        const settleResult = await ozServer.settlePayment(payload, requirements);
+        const outcome = readSettleResult(settleResult);
+        if (!outcome.ok) {
+          return respondPaymentRequired("Payment settlement failed", outcome.reason);
+        }
+        txHash = outcome.txHash;
+        paymentResponseHeader = http.encodePaymentResponseHeader(
+          settleResult
+        );
+        c.header("X-Payment-Response", paymentResponseHeader);
+      } else {
+        const verifyResult = await localFacilitator.verify(
+          payload,
+          requirements
+        );
+        if (!verifyResult.isValid) {
+          return c.json(
+            {
+              error: "Payment verification failed",
+              reason: verifyResult.invalidReason
+            },
+            401
+          );
+        }
+        const settleResult = await localFacilitator.settle(
+          payload,
+          requirements
+        );
+        const outcome = readSettleResult(settleResult);
+        if (!outcome.ok) {
+          return respondPaymentRequired("Payment settlement failed", outcome.reason);
+        }
+        txHash = outcome.txHash;
+        paymentResponseHeader = http.encodePaymentResponseHeader(
+          settleResult
+        );
+        c.header("X-Payment-Response", paymentResponseHeader);
+      }
+      if (idempotencyKey) {
+        const headers = {};
+        if (paymentResponseHeader) headers["X-Payment-Response"] = paymentResponseHeader;
+        await seenTxStore.set(idempotencyKey, { txHash, headers, createdAt: Date.now() });
+      }
+      if (txHash && opts.onSettled) {
+        Promise.resolve().then(() => opts.onSettled(txHash, x402Price, "x402", payerAddress)).catch((err) => {
+          logger("error", "[x402] onSettled callback error", { error: err });
+          opts.onCallbackError?.(err, "onSettled");
+        });
+      }
+      await next();
+    } catch (err) {
+      if (err instanceof RouteDockManifestError) {
+        throw err;
+      }
+      logger("error", "[x402] Settlement error", { error: err });
+      return c.json({ error: "Payment settlement failed" }, 500);
+    }
+  };
+}
+function createMppChargeHonoHandler(opts) {
+  const networkId = CAIP2[opts.network];
+  const chargePrice = opts.pricing["mpp-charge"];
+  const recipient = resolvePayee(opts.manifest, "mpp-charge");
+  const logger = resolveLogger(opts.logger);
+  const seenTxStore = opts.seenTxStore ?? new InMemorySeenTxStore({ logger });
+  const mppxInstances = /* @__PURE__ */ new Map();
+  function getMppx(contract) {
+    let instance = mppxInstances.get(contract);
+    if (!instance) {
+      instance = server$3.Mppx.create({
+        secretKey: opts.payeeSecretKey,
+        methods: [
+          server$4.stellar({
+            recipient,
+            currency: contract,
+            network: networkId,
+            feePayer: { envelopeSigner: opts.payeeSecretKey }
+          })
+        ]
+      });
+      mppxInstances.set(contract, instance);
+    }
+    return instance;
+  }
+  return async (c, next) => {
+    try {
+      const endpoint = c.req.path;
+      const assetContract = resolveAssetContract(
+        opts.manifest,
+        "mpp-charge",
+        endpoint,
+        opts.assetContract
+      );
+      const mppx = getMppx(assetContract);
+      let payerAddress = null;
+      try {
+        const authHeader = c.req.header("authorization");
+        if (authHeader?.startsWith("Payment ")) {
+          const credPart = authHeader.replace(/^Payment\s+/, "").split(",").find((p) => p.trim().startsWith("credential="));
+          if (credPart) {
+            const b64 = credPart.split("=").slice(1).join("=").replace(/^"|"$/g, "");
+            const credJson = base64ToUtf8(b64);
+            const cred = JSON.parse(credJson);
+            const key = cred.sender ?? cred.payload?.sender ?? cred.payload?.from;
+            payerAddress = extractPayerAddress(key);
+          }
+        }
+      } catch {
+      }
+      const idempotencyKey = await paymentIdempotencyKey(
+        (name) => c.req.header(name),
+        {
+          method: c.req.method,
+          path: c.req.path,
+          amount: chargePrice,
+          payTo: recipient
+        }
+      );
+      if (idempotencyKey) {
+        const replayCheck = await checkSettlementReplay(seenTxStore, idempotencyKey);
+        if (replayCheck.kind === "spent") {
+          return c.json({ error: "Payment already used" }, 402);
+        }
+        if (replayCheck.kind === "replay") {
+          if (replayCheck.record.headers) {
+            for (const [k, val] of Object.entries(replayCheck.record.headers)) {
+              c.header(k, val);
+            }
+          }
+          await next();
+          return;
+        }
+      }
+      const handler = mppx["stellar/charge"];
+      const result = await handler({
+        amount: chargePrice,
+        currency: assetContract,
+        recipient,
+        description: opts.manifest.name
+      })(c.req.raw);
+      if (result.status === 402) {
+        const challenge = result.challenge;
+        const headers = {};
+        challenge.headers.forEach((v, k) => {
+          headers[k] = v;
+        });
+        return new Response(await challenge.text(), { status: 402, headers });
+      }
+      const receipt = result.withReceipt(new Response(""));
+      const receiptHeaders = {};
+      receipt.headers.forEach((v, k) => {
+        c.header(k, v);
+        receiptHeaders[k] = v;
+      });
+      const receiptHeader = receipt.headers.get("payment-receipt");
+      let reference;
+      if (receiptHeader) {
+        try {
+          const parsed = JSON.parse(base64ToUtf8(receiptHeader));
+          reference = parsed.reference;
+        } catch {
+        }
+      }
+      if (idempotencyKey) {
+        await seenTxStore.set(idempotencyKey, {
+          txHash: reference ?? null,
+          headers: receiptHeaders,
+          createdAt: Date.now()
+        });
+      }
+      if (reference && opts.onSettled) {
+        Promise.resolve().then(() => opts.onSettled(reference, chargePrice, "mpp-charge", payerAddress)).catch((err) => {
+          logger("error", "[mpp-charge] onSettled callback error", { error: err });
+          opts.onCallbackError?.(err, "onSettled");
+        });
+      }
+      await next();
+    } catch (err) {
+      throw err;
+    }
+  };
+}
+var MPP_SESSION_WS_VERIFIED = "routedock.mppSessionWs.verified";
+function mppSessionWsVerified(c) {
+  return c.get(MPP_SESSION_WS_VERIFIED) === true;
+}
+function createMppSessionHandlerState(opts, sessionPricing, reportMode) {
+  const networkId = CAIP2[opts.network];
+  const payeeKeypair = stellarSdk.Keypair.fromSecret(opts.payeeSecretKey);
+  const logger = resolveLogger(opts.logger);
+  const voucherRecordKey = `routedock:session:voucher:${sessionPricing.channelFactory}`;
+  const innerStore = opts.sessionStore ?? server$2.Store.memory();
+  let record = null;
+  let voucherCount = 0;
+  let sessionOpened = false;
+  let idleTimer = null;
+  let settledCleanly = false;
+  let abortListenerArmed = false;
+  function clearIdleTimer() {
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = null;
+    }
+  }
+  function armIdleTimer() {
+    if (!opts.idleTimeoutMs) return;
+    clearIdleTimer();
+    idleTimer = setTimeout(() => {
+      void flagOrphan("idle-timeout");
+    }, opts.idleTimeoutMs);
+    const maybeUnref = idleTimer;
+    if (typeof maybeUnref.unref === "function") maybeUnref.unref();
+  }
+  async function loadPersistedRecord() {
+    if (record) return record;
+    try {
+      const stored = await innerStore.get(voucherRecordKey);
+      if (!stored || typeof stored.amount !== "string" || typeof stored.signature !== "string") {
+        return null;
+      }
+      record = { amount: BigInt(stored.amount), signature: stored.signature, payer: stored.payer ?? null };
+    } catch {
+      return null;
+    }
+    return record;
+  }
+  async function flagOrphan(reason) {
+    await loadPersistedRecord();
+    if (!sessionOpened || settledCleanly) return;
+    sessionOpened = false;
+    abortListenerArmed = false;
+    clearIdleTimer();
+    const cumulativeAmount = record ? (Number(record.amount) / 1e7).toFixed(7) : "0.0000000";
+    if (opts.onOrphaned) {
+      try {
+        await opts.onOrphaned(sessionPricing.channelFactory, {
+          cumulativeAmount,
+          lastSignature: record?.signature ?? "",
+          voucherCount,
+          reason
+        });
+      } catch (err) {
+        logger("error", "[mpp-session] onOrphaned handler failed", { error: err });
+      }
+    }
+  }
+  const wrappedStore = {
+    async get(key) {
+      return innerStore.get(key);
+    },
+    async put(key, value) {
+      return innerStore.put(key, value);
+    },
+    async delete(key) {
+      return innerStore.delete(key);
+    },
+    async update(key, fn) {
+      const storeWithUpdate = innerStore;
+      if (typeof storeWithUpdate.update === "function") {
+        return storeWithUpdate.update(key, fn);
+      }
+      throw new Error("Store does not support atomic update operations");
+    }
+  };
+  async function commit(credential) {
+    await loadPersistedRecord();
+    const payload = credential.payload;
+    if (typeof payload?.amount !== "string" || typeof payload.signature !== "string") return;
+    let amount;
+    try {
+      amount = BigInt(payload.amount);
+    } catch {
+      return;
+    }
+    if (record && amount < record.amount) return;
+    const payer = record?.payer ?? extractPayerAddress(credential.source);
+    record = { amount, signature: payload.signature, payer };
+    await innerStore.put(voucherRecordKey, {
+      amount: record.amount.toString(),
+      signature: record.signature,
+      payer: record.payer
+    });
+    voucherCount++;
+    settledCleanly = false;
+    armIdleTimer();
+    if (!sessionOpened) {
+      sessionOpened = true;
+      if (opts.onSessionOpen) {
+        Promise.resolve().then(() => opts.onSessionOpen(sessionPricing.channelFactory, record.payer)).catch((err) => {
+          logger("error", "[mpp-session] onSessionOpen callback error", { error: err });
+          opts.onCallbackError?.(err, "onSessionOpen");
+        });
+      }
+    }
+    if (opts.onVoucher) {
+      const humanAmount = (Number(record.amount) / 1e7).toFixed(7);
+      Promise.resolve().then(() => opts.onVoucher(sessionPricing.channelFactory, voucherCount, humanAmount, record.signature)).catch((err) => {
+        logger("error", "[mpp-session] onVoucher callback error", { error: err });
+        opts.onCallbackError?.(err, "onVoucher");
+      });
+    }
+  }
+  const mppx = server$3.Mppx.create({
+    secretKey: opts.payeeSecretKey,
+    methods: [
+      withTypedChannelErrors(
+        onVerifiedCredential(
+          server$2.stellar({
+            channel: sessionPricing.channelFactory,
+            commitmentKey: opts.commitmentPublicKey,
+            network: networkId,
+            store: wrappedStore,
+            sourceAccount: payeeKeypair.publicKey(),
+            feePayer: channelAuthorizer(payeeKeypair)
+          }),
+          commit
+        )
+      )
+    ]
+  });
+  return {
+    mppx,
+    async handleDelete(c) {
+      await loadPersistedRecord();
+      let body;
+      try {
+        body = await c.req.json();
+      } catch {
+      }
+      const bodyAmount = body?.amount ? BigInt(body.amount) : 0n;
+      const recordAmount = record?.amount ?? 0n;
+      let closeAmount;
+      let closeSig;
+      if (bodyAmount > recordAmount) {
+        closeAmount = bodyAmount;
+        closeSig = body?.signature ?? record?.signature ?? "";
+      } else {
+        closeAmount = recordAmount;
+        closeSig = record?.signature || (bodyAmount === recordAmount ? body?.signature ?? "" : "");
+      }
+      if (closeAmount > 0n && closeSig) {
+        const closeTxHash = await server$2.close({
+          channel: sessionPricing.channelFactory,
+          amount: closeAmount,
+          signature: hexToBytes(closeSig),
+          feePayer: channelAuthorizer(payeeKeypair),
+          network: networkId
+        });
+        settledCleanly = true;
+        clearIdleTimer();
+        const closePayer = record?.payer ?? null;
+        if (opts.onSettled) {
+          const totalPaid = (Number(closeAmount) / 1e7).toFixed(7);
+          Promise.resolve().then(() => opts.onSettled(closeTxHash, totalPaid, reportMode, closePayer)).catch((err) => {
+            logger("error", "[mpp-session] onSettled callback error", { error: err });
+            opts.onCallbackError?.(err, "onSettled");
+          });
+        }
+        sessionOpened = false;
+        voucherCount = 0;
+        record = null;
+        await innerStore.delete(voucherRecordKey);
+        abortListenerArmed = false;
+        return c.json({ closeTxHash });
+      }
+      return c.json({ closeTxHash: null, message: "no vouchers received" });
+    },
+    armAbortGuard(c) {
+      const signal = c.req.raw.signal;
+      if (signal && !abortListenerArmed) {
+        abortListenerArmed = true;
+        signal.addEventListener(
+          "abort",
+          () => {
+            void flagOrphan("connection-closed");
+          },
+          { once: true }
+        );
+      }
+    }
+  };
+}
+function createMppSessionHonoHandler(opts, config, state) {
+  const sessionPricing = opts.pricing[config.mode];
+  return async (c, next) => {
+    try {
+      if (c.req.method === "DELETE") {
+        return state.handleDelete(c);
+      }
+      const result = await state.mppx.channel({
+        amount: sessionPricing.rate,
+        description: opts.manifest.name
+      })(c.req.raw);
+      if (result.status === 402) {
+        const challenge = result.challenge;
+        const headers = {};
+        challenge.headers.forEach((v, k) => {
+          headers[k] = v;
+        });
+        return new Response(await challenge.text(), { status: 402, headers });
+      }
+      state.armAbortGuard(c);
+      if (config.mode === "mpp-session-ws" && isWebSocketUpgradeRequest(c)) {
+        c.set(MPP_SESSION_WS_VERIFIED, true);
+        await next();
+        return;
+      }
+      await next();
+    } catch (err) {
+      throw err;
+    }
+  };
+}
+function isWebSocketUpgradeRequest(c) {
+  return (c.req.header("upgrade") ?? "").toLowerCase() === "websocket";
+}
+function routedockHono(opts) {
+  const handlers = [];
+  const signedManifest = signManifest(opts.manifest, opts.payeeSecretKey);
+  if (opts.modes.includes("x402") && opts.pricing.x402) {
+    handlers.push(createX402HonoHandler({ ...opts, manifest: signedManifest }));
+  }
+  if (opts.modes.includes("mpp-charge") && opts.pricing["mpp-charge"]) {
+    handlers.push(createMppChargeHonoHandler({ ...opts, manifest: signedManifest }));
+  }
+  const sessionModes = ["mpp-session", "mpp-session-ws"].filter(
+    (mode) => opts.modes.includes(mode) && !!opts.pricing[mode]
+  );
+  const primarySessionMode = sessionModes[0];
+  if (primarySessionMode) {
+    if (!opts.commitmentPublicKey) {
+      throw new Error("routedockHono: mpp-session/mpp-session-ws mode requires commitmentPublicKey");
+    }
+    const sessionPricing = opts.pricing[primarySessionMode];
+    const sharedState = createMppSessionHandlerState(opts, sessionPricing, primarySessionMode);
+    for (const mode of sessionModes) {
+      handlers.push(
+        createMppSessionHonoHandler({ ...opts, manifest: signedManifest }, { mode }, sharedState)
+      );
+    }
+  }
+  return async (c, next) => {
+    if (c.req.path === "/.well-known/routedock.json") {
+      return c.json(signedManifest);
+    }
+    if (handlers.length === 0) {
+      await next();
+      return;
+    }
+    const hasX402Header = !!(c.req.header("payment-signature") || c.req.header("x-payment"));
+    const prefersX402 = c.req.header("x-preferred-mode") === "x402";
+    const handler = hasX402Header || prefersX402 ? handlers[0] : handlers[handlers.length - 1];
+    if (!handler) {
+      await next();
+      return;
+    }
+    return handler(c, next);
+  };
+}
+
+exports.InMemorySeenTxStore = InMemorySeenTxStore;
+exports.MPP_SESSION_WS_VERIFIED = MPP_SESSION_WS_VERIFIED;
+exports.SupabaseSeenTxStore = SupabaseSeenTxStore;
+exports.mppSessionWsVerified = mppSessionWsVerified;
+exports.reconcileAbandonedSessions = reconcileAbandonedSessions;
+exports.registerProvider = registerProvider;
+exports.routedockHono = routedockHono;
+exports.runStartupReconciliation = runStartupReconciliation;
+exports.signManifest = signManifest;