@routedock/routedock 0.1.1 → 0.2.0

package/dist/provider/hono.js

@@ -0,0 +1,938 @@
+import { Keypair, StrKey } from '@stellar/stellar-sdk';
+import { ExactStellarScheme } from '@x402/stellar/exact/facilitator';
+import { ExactStellarScheme as ExactStellarScheme$1 } from '@x402/stellar/exact/server';
+import { HTTPFacilitatorClient, x402ResourceServer } from '@x402/core/server';
+import { createEd25519Signer } from '@x402/stellar';
+import { encodePaymentRequiredHeader, decodePaymentSignatureHeader, encodePaymentResponseHeader } from '@x402/core/http';
+import { stellar } from '@stellar/mpp/charge/server';
+import { Store, stellar as stellar$1, close } from '@stellar/mpp/channel/server';
+import { Mppx } from 'mppx/server';
+import { createHash } from 'crypto';
+import { usdcToStroops } from '@routedock/nulth-sdk';
+import { Errors } from '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 createHash("sha256").update(canonical, "utf8").digest();
+}
+function signManifest(manifest, payeeSecretKey) {
+  const keypair = 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 = 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/provider/payee.ts
+function resolvePayee(manifest, mode) {
+  const override = manifest.pricing[mode]?.payee;
+  return override ?? manifest.payee;
+}
+var usdcToUnits = usdcToStroops;
+function extractPayerAddress(key) {
+  if (typeof key !== "string") return null;
+  return StrKey.isValidEd25519PublicKey(key) || StrKey.isValidMed25519PublicKey(key) ? key : null;
+}
+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 Errors.SignerMismatchError({ reason });
+  }
+  if (/already used|replay|challenge/i.test(message)) {
+    return new Errors.InvalidChallengeError({ reason });
+  }
+  if (/channel has been closed|channel is closed|finalized/i.test(message)) {
+    return new Errors.ChannelClosedError({ reason });
+  }
+  if (/exceeds channel balance|exceeds.*deposit/i.test(message)) {
+    return new Errors.AmountExceedsDepositError({ reason });
+  }
+  if (/channel not found|no channel/i.test(message)) {
+    return new Errors.ChannelNotFoundError({ reason });
+  }
+  if (/must be greater|does not cover|below.*minimum/i.test(message)) {
+    return new Errors.DeltaTooSmallError({ reason });
+  }
+  if (/signature/i.test(message)) {
+    return new Errors.InvalidSignatureError({ reason });
+  }
+  return new 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 InMemorySeenTxStore = class {
+  map = /* @__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) {
+        console.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.map.set(key, record);
+  }
+};
+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) {
+  const material = getHeader("payment-signature") ?? getHeader("x-payment") ?? getHeader("authorization");
+  if (!material) return null;
+  return sha256Hex(material);
+}
+
+// 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").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 } : {}
+    };
+  }
+  async set(key, record) {
+    const { error } = await this.supabase.from("settlements").upsert(
+      {
+        key,
+        tx_hash: record.txHash,
+        headers: record.headers ?? null
+      },
+      { onConflict: "key" }
+    );
+    if (error) {
+      throw new RouteDockNetworkError(`SupabaseSeenTxStore.set failed: ${error.message}`);
+    }
+  }
+};
+var MPP_NETWORK = {
+  testnet: "stellar:testnet",
+  mainnet: "stellar:pubnet"
+};
+function decimalToStroops(amountStr) {
+  return usdcToStroops(amountStr);
+}
+async function reconcileAbandonedSessions(opts) {
+  const stats = {
+    orphanedCount: 0,
+    recoveredCount: 0,
+    skippedCount: 0,
+    failedCount: 0,
+    errors: []
+  };
+  const payeeKeypair = 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 = logger || console.log;
+  log("[SessionReconciler] Running startup reconciliation...");
+  try {
+    const stats = await reconcileAbandonedSessions(opts);
+    if (stats.orphanedCount === 0) {
+      log("[SessionReconciler] No orphaned sessions found");
+      return;
+    }
+    log(
+      `[SessionReconciler] Found ${stats.orphanedCount} orphaned session(s). Recovered: ${stats.recoveredCount}, Skipped: ${stats.skippedCount}, Failed: ${stats.failedCount}`
+    );
+    if (stats.errors.length > 0) {
+      log("[SessionReconciler] Reconciliation errors:");
+      for (const err of stats.errors) {
+        log(`  - ${err.channelId}: ${err.reason}`);
+      }
+    }
+  } catch (err) {
+    log(`[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 = Keypair.fromSecret(opts.payeeSecretKey);
+  const signer = createEd25519Signer(opts.payeeSecretKey, caip2);
+  const x402Price = opts.pricing.x402;
+  const seenTxStore = opts.seenTxStore ?? new InMemorySeenTxStore();
+  const useOzFacilitator = opts.network === "mainnet" && opts.facilitatorApiKey;
+  const localFacilitator = new ExactStellarScheme([signer], {
+    areFeesSponsored: true
+  });
+  let ozServer = null;
+  if (useOzFacilitator) {
+    const apiKey = opts.facilitatorApiKey;
+    const facilitator = new HTTPFacilitatorClient({
+      url: OZ_FACILITATOR_URL,
+      createAuthHeaders: async () => ({
+        verify: { Authorization: `Bearer ${apiKey}` },
+        settle: { Authorization: `Bearer ${apiKey}` },
+        supported: { Authorization: `Bearer ${apiKey}` }
+      })
+    });
+    ozServer = new x402ResourceServer(facilitator);
+    ozServer.register(caip2, new ExactStellarScheme$1());
+  }
+  const amountInBaseUnits = String(usdcToUnits(x402Price));
+  const requirements = {
+    scheme: "exact",
+    network: caip2,
+    asset: opts.assetContract,
+    amount: amountInBaseUnits,
+    payTo: resolvePayee(opts.manifest, "x402"),
+    maxTimeoutSeconds: 60,
+    extra: {
+      areFeesSponsored: true,
+      ...useOzFacilitator ? {} : { facilitatorAddresses: [payeeKeypair.publicKey()] }
+    }
+  };
+  return async (c, next) => {
+    try {
+      const paymentHeader = c.req.header("payment-signature") ?? c.req.header("x-payment");
+      if (!paymentHeader) {
+        if (ozServer) {
+          const resourceInfo = {
+            url: c.req.url,
+            description: opts.manifest.name
+          };
+          const paymentRequired = await ozServer.createPaymentRequiredResponse(
+            [requirements],
+            resourceInfo
+          );
+          c.header("X-Payment-Requirements", encodePaymentRequiredHeader(paymentRequired));
+          return c.json({ error: "Payment Required" }, 402);
+        } else {
+          const x402Response = {
+            x402Version: 2,
+            resource: { url: c.req.url, description: opts.manifest.name },
+            accepts: [requirements]
+          };
+          c.header("X-Payment-Requirements", encodePaymentRequiredHeader(x402Response));
+          return c.json({ error: "Payment Required" }, 402);
+        }
+      }
+      const idempotencyKey = await paymentIdempotencyKey((name) => c.req.header(name));
+      if (idempotencyKey) {
+        const cached = await seenTxStore.get(idempotencyKey);
+        if (cached) {
+          if (cached.headers) {
+            for (const [k, val] of Object.entries(cached.headers)) {
+              c.header(k, val);
+            }
+          }
+          await next();
+          return;
+        }
+      }
+      const payload = 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);
+        txHash = settleResult.transaction ?? null;
+        if (settleResult) {
+          paymentResponseHeader = 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
+        );
+        txHash = settleResult.transaction ?? null;
+        if (settleResult) {
+          paymentResponseHeader = 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 });
+      }
+      if (txHash && opts.onSettled) {
+        Promise.resolve().then(() => opts.onSettled(txHash, x402Price, "x402", payerAddress)).catch((err) => {
+          console.error("[x402] onSettled callback error:", err);
+          opts.onCallbackError?.(err, "onSettled");
+        });
+      }
+      await next();
+    } catch (err) {
+      console.error("[x402] Settlement 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 seenTxStore = opts.seenTxStore ?? new InMemorySeenTxStore();
+  const mppx = Mppx.create({
+    secretKey: opts.payeeSecretKey,
+    methods: [
+      stellar({
+        recipient,
+        currency: opts.assetContract,
+        network: networkId,
+        feePayer: { envelopeSigner: opts.payeeSecretKey }
+      })
+    ]
+  });
+  return async (c, next) => {
+    try {
+      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));
+      if (idempotencyKey) {
+        const cached = await seenTxStore.get(idempotencyKey);
+        if (cached) {
+          if (cached.headers) {
+            for (const [k, val] of Object.entries(cached.headers)) {
+              c.header(k, val);
+            }
+          }
+          await next();
+          return;
+        }
+      }
+      const handler = mppx["stellar/charge"];
+      const result = await handler({
+        amount: chargePrice,
+        currency: opts.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
+        });
+      }
+      if (reference && opts.onSettled) {
+        Promise.resolve().then(() => opts.onSettled(reference, chargePrice, "mpp-charge", payerAddress)).catch((err) => {
+          console.error("[mpp-charge] onSettled callback 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 = Keypair.fromSecret(opts.payeeSecretKey);
+  const voucherRecordKey = `routedock:session:voucher:${sessionPricing.channelFactory}`;
+  const innerStore = opts.sessionStore ?? 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) {
+        console.error("[mpp-session] onOrphaned handler failed:", 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) => {
+          console.error("[mpp-session] onSessionOpen callback 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) => {
+        console.error("[mpp-session] onVoucher callback error:", err);
+        opts.onCallbackError?.(err, "onVoucher");
+      });
+    }
+  }
+  const mppx = Mppx.create({
+    secretKey: opts.payeeSecretKey,
+    methods: [
+      withTypedChannelErrors(
+        onVerifiedCredential(
+          stellar$1({
+            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 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) => {
+            console.error(`[mpp-session] onSettled callback 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);
+  };
+}
+
+export { InMemorySeenTxStore, MPP_SESSION_WS_VERIFIED, SupabaseSeenTxStore, mppSessionWsVerified, reconcileAbandonedSessions, registerProvider, routedockHono, runStartupReconciliation, signManifest };