@routedock/routedock 0.1.2 → 0.3.0

package/dist/provider/fastify.js

@@ -0,0 +1,1097 @@
+import { Keypair, StrKey, Contract, nativeToScVal, TransactionBuilder, BASE_FEE } 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 { usdcToStroops } from '@routedock/nulth-sdk';
+import { stellar as stellar$1 } from '@stellar/mpp/charge/server';
+import { Request, Mppx } from 'mppx/server';
+import { Store, stellar, close } from '@stellar/mpp/channel/server';
+import { Errors } from 'mppx';
+import { createHash } from 'crypto';
+
+// src/provider/x402Handler.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";
+  }
+};
+
+// src/internal/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;
+}
+
+// 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/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;
+}
+
+// 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/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/x402Handler.ts
+var CAIP2 = {
+  testnet: "stellar:testnet",
+  mainnet: "stellar:pubnet"
+};
+var OZ_FACILITATOR_URL = "https://channels.openzeppelin.com/x402";
+function createX402Handler(opts) {
+  const caip2 = CAIP2[opts.network];
+  const payeeKeypair = Keypair.fromSecret(opts.payeeSecretKey);
+  const signer = createEd25519Signer(opts.payeeSecretKey, caip2);
+  const logger = resolveLogger(opts.logger);
+  const seenTxStore = opts.seenTxStore ?? new InMemorySeenTxStore({ logger });
+  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(opts.amount));
+  const payTo = resolvePayee(opts.manifest, "x402");
+  return async (req, res, next) => {
+    try {
+      const endpoint = req.path || req.originalUrl;
+      const assetContract = resolveAssetContract(
+        opts.manifest,
+        "x402",
+        endpoint,
+        opts.assetContract
+      );
+      const requirements = {
+        scheme: "exact",
+        network: caip2,
+        asset: assetContract,
+        amount: amountInBaseUnits,
+        payTo,
+        maxTimeoutSeconds: 60,
+        extra: {
+          areFeesSponsored: true,
+          ...useOzFacilitator ? {} : { facilitatorAddresses: [payeeKeypair.publicKey()] }
+        }
+      };
+      const respondPaymentRequired = async (error, reason) => {
+        const body = { error, ...reason ? { reason } : {} };
+        if (ozServer) {
+          const resourceInfo = {
+            url: `${req.protocol}://${req.get("host") ?? ""}${req.originalUrl}`,
+            description: opts.manifest.name
+          };
+          const paymentRequired = await ozServer.createPaymentRequiredResponse(
+            [requirements],
+            resourceInfo
+          );
+          res.status(402).setHeader("Content-Type", "application/json").setHeader("X-Payment-Requirements", encodePaymentRequiredHeader(paymentRequired)).json(body);
+        } else {
+          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", encodePaymentRequiredHeader(x402Response)).json(body);
+        }
+      };
+      const paymentHeader = req.headers["payment-signature"] ?? req.headers["x-payment"];
+      if (!paymentHeader) {
+        await respondPaymentRequired("Payment Required");
+        return;
+      }
+      const idempotencyKey = await paymentIdempotencyKey(
+        (name) => {
+          const v = req.headers[name.toLowerCase()];
+          return Array.isArray(v) ? v[0] : v;
+        },
+        {
+          method: req.method,
+          path: req.originalUrl.split("?")[0],
+          amount: requirements.amount,
+          payTo: requirements.payTo
+        }
+      );
+      if (idempotencyKey) {
+        const replayCheck = await checkSettlementReplay(seenTxStore, idempotencyKey);
+        if (replayCheck.kind === "spent") {
+          res.status(402).json({ error: "Payment already used" });
+          return;
+        }
+        if (replayCheck.kind === "replay") {
+          if (replayCheck.record.headers) {
+            for (const [k, val] of Object.entries(replayCheck.record.headers)) {
+              res.setHeader(k, val);
+            }
+          }
+          next();
+          return;
+        }
+      }
+      const payload = decodePaymentSignatureHeader(paymentHeader);
+      let txHash = null;
+      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) {
+          await respondPaymentRequired("Payment settlement failed", outcome.reason);
+          return;
+        }
+        txHash = outcome.txHash;
+        res.setHeader(
+          "X-Payment-Response",
+          encodePaymentResponseHeader(
+            settleResult
+          )
+        );
+      } else {
+        const verifyResult = await localFacilitator.verify(
+          payload,
+          requirements
+        );
+        if (!verifyResult.isValid) {
+          res.status(401).json({
+            error: "Payment verification failed",
+            reason: verifyResult.invalidReason
+          });
+          return;
+        }
+        const settleResult = await localFacilitator.settle(
+          payload,
+          requirements
+        );
+        const outcome = readSettleResult(settleResult);
+        if (!outcome.ok) {
+          await respondPaymentRequired("Payment settlement failed", outcome.reason);
+          return;
+        }
+        txHash = outcome.txHash;
+        res.setHeader(
+          "X-Payment-Response",
+          encodePaymentResponseHeader(
+            settleResult
+          )
+        );
+      }
+      if (idempotencyKey) {
+        const headers = {};
+        const paymentResponse = res.getHeader("X-Payment-Response");
+        if (typeof paymentResponse === "string") {
+          headers["X-Payment-Response"] = paymentResponse;
+        }
+        await seenTxStore.set(idempotencyKey, { txHash, headers, createdAt: Date.now() });
+      }
+      if (txHash && opts.onSettled) {
+        Promise.resolve().then(() => opts.onSettled(txHash, opts.amount, "x402", payerAddress)).catch((err) => {
+          logger("error", "[x402] onSettled callback error", { error: err });
+          opts.onCallbackError?.(err, "onSettled");
+        });
+      }
+      next();
+    } catch (err) {
+      if (err instanceof RouteDockManifestError) {
+        next(err);
+        return;
+      }
+      logger("error", "[x402] Settlement error", { 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 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 = Mppx.create({
+        secretKey: opts.payeeSecretKey,
+        methods: [
+          stellar$1.charge({
+            recipient,
+            currency: contract,
+            network: networkId,
+            feePayer: { envelopeSigner: opts.payeeSecretKey }
+          })
+        ]
+      });
+      mppxInstances.set(contract, instance);
+    }
+    return instance;
+  }
+  return async (req, res, next) => {
+    try {
+      const endpoint = req.path || req.originalUrl;
+      const assetContract = resolveAssetContract(
+        opts.manifest,
+        "mpp-charge",
+        endpoint,
+        opts.assetContract
+      );
+      const mppx = getMppx(assetContract);
+      let payerAddress = null;
+      try {
+        const authHeader = req.headers["authorization"];
+        if (typeof authHeader === "string" && 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 = Buffer.from(b64, "base64").toString("utf8");
+            const cred = JSON.parse(credJson);
+            const key = cred.sender ?? cred.payload?.sender ?? cred.payload?.from;
+            payerAddress = extractPayerAddress(key);
+          }
+        }
+      } catch {
+      }
+      const idempotencyKey = await paymentIdempotencyKey(
+        (name) => {
+          const v = req.headers[name.toLowerCase()];
+          return Array.isArray(v) ? v[0] : v;
+        },
+        {
+          method: req.method,
+          path: req.originalUrl.split("?")[0],
+          amount: amountHumanReadable,
+          payTo: recipient
+        }
+      );
+      if (idempotencyKey) {
+        const replayCheck = await checkSettlementReplay(seenTxStore, idempotencyKey);
+        if (replayCheck.kind === "spent") {
+          res.status(402).json({ error: "Payment already used" });
+          return;
+        }
+        if (replayCheck.kind === "replay") {
+          if (replayCheck.record.headers) {
+            for (const [k, val] of Object.entries(replayCheck.record.headers)) {
+              res.setHeader(k, val);
+            }
+          }
+          next();
+          return;
+        }
+      }
+      const fetchReq = Request.fromNodeListener(req, res);
+      const handler = mppx["stellar/charge"];
+      const result = await handler({
+        amount: amountHumanReadable,
+        currency: assetContract,
+        recipient,
+        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(""));
+      const receiptHeaders = {};
+      receipt.headers.forEach((v, k) => {
+        res.setHeader(k, v);
+        receiptHeaders[k] = v;
+      });
+      const receiptHeader = receipt.headers.get("payment-receipt");
+      let reference;
+      if (receiptHeader) {
+        try {
+          const parsed = JSON.parse(
+            Buffer.from(receiptHeader, "base64").toString("utf8")
+          );
+          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, opts.amount, "mpp-charge", payerAddress)).catch((err) => {
+          logger("error", "[mpp-charge] onSettled callback error", { error: err });
+          opts.onCallbackError?.(err, "onSettled");
+        });
+      }
+      next();
+    } catch (err) {
+      next(err);
+    }
+  };
+}
+function resolveVaultSettlementAddresses(payer, payee) {
+  if (!payer) return null;
+  return { payer, payee };
+}
+function buildSessionSettlementTransaction(source, vaultContractId, channelId, addresses, amount, voucherCount, networkPassphrase) {
+  const vault = new Contract(vaultContractId);
+  const op = vault.call(
+    "record_session_settlement",
+    nativeToScVal(channelId, { type: "address" }),
+    nativeToScVal(addresses.payer, { type: "address" }),
+    nativeToScVal(addresses.payee, { type: "address" }),
+    nativeToScVal(amount, { type: "i128" }),
+    nativeToScVal(voucherCount, { type: "u32" })
+  );
+  return new TransactionBuilder(source, {
+    fee: BASE_FEE,
+    networkPassphrase
+  }).addOperation(op).setTimeout(30).build();
+}
+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/MppSessionHandler.ts
+var MPP_NETWORK2 = {
+  testnet: "stellar:testnet",
+  mainnet: "stellar:pubnet"
+};
+function createMppSessionHandler(opts) {
+  const networkId = MPP_NETWORK2[opts.network];
+  const rateHuman = opts.rate;
+  const payeeKeypair = Keypair.fromSecret(opts.payeeSecretKey);
+  const logger = resolveLogger(opts.logger);
+  const voucherRecordKey = `routedock:session:voucher:${opts.channelFactory}`;
+  const innerStore = Store.memory();
+  let record = null;
+  let voucherCount = 0;
+  let sessionOpened = false;
+  let idleTimer = null;
+  let settledCleanly = false;
+  let closeListenerArmed = false;
+  function clearIdleTimer() {
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = null;
+    }
+  }
+  function armIdleTimer() {
+    if (!opts.idleTimeoutMs) return;
+    clearIdleTimer();
+    idleTimer = setTimeout(() => {
+      void flagOrphan("idle-timeout");
+    }, opts.idleTimeoutMs);
+    if (typeof idleTimer.unref === "function") idleTimer.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;
+    closeListenerArmed = false;
+    clearIdleTimer();
+    const cumulativeAmount = record ? (Number(record.amount) / 1e7).toFixed(7) : "0.0000000";
+    if (opts.onOrphaned) {
+      try {
+        await opts.onOrphaned(opts.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(opts.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(opts.channelFactory, voucherCount, humanAmount, record.signature)).catch((err) => {
+        logger("error", "[mpp-session] onVoucher callback error", { error: err });
+        opts.onCallbackError?.(err, "onVoucher");
+      });
+    }
+  }
+  const mppx = Mppx.create({
+    secretKey: opts.payeeSecretKey,
+    methods: [
+      withTypedChannelErrors(
+        onVerifiedCredential(
+          stellar.channel({
+            channel: opts.channelFactory,
+            commitmentKey: opts.commitmentPublicKey,
+            network: networkId,
+            store: wrappedStore,
+            sourceAccount: payeeKeypair.publicKey(),
+            feePayer: channelAuthorizer(payeeKeypair)
+          }),
+          commit
+        )
+      )
+    ]
+  });
+  return async (req, res, next) => {
+    try {
+      if (req.method === "DELETE") {
+        await loadPersistedRecord();
+        const body = req.body;
+        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 ?? "";
+        }
+        if (closeAmount > 0n && closeSig) {
+          const closePayer = record?.payer ?? null;
+          const closeTxHash = await close({
+            channel: opts.channelFactory,
+            amount: closeAmount,
+            signature: Buffer.from(closeSig, "hex"),
+            feePayer: channelAuthorizer(payeeKeypair),
+            network: networkId
+          });
+          settledCleanly = true;
+          clearIdleTimer();
+          if (opts.onSettled) {
+            const totalPaid = (Number(closeAmount) / 1e7).toFixed(7);
+            Promise.resolve().then(() => opts.onSettled(closeTxHash, totalPaid, "mpp-session", closePayer)).catch((err) => {
+              logger("error", "[mpp-session] onSettled callback error", { error: err });
+              opts.onCallbackError?.(err, "onSettled");
+            });
+          }
+          const vaultContract = process.env.AGENT_VAULT_CONTRACT;
+          if (vaultContract) {
+            const settlementAddresses = resolveVaultSettlementAddresses(
+              closePayer,
+              payeeKeypair.publicKey()
+            );
+            if (!settlementAddresses) {
+              logger("warn", "[mpp-session] skipped session_settled vault record: payer address unavailable");
+            } else {
+              try {
+                const { Networks } = await import('@stellar/stellar-sdk');
+                const { Server } = await import('@stellar/stellar-sdk/rpc');
+                const networkPassphrase = opts.network === "mainnet" ? Networks.PUBLIC : Networks.TESTNET;
+                const rpcUrl = opts.network === "mainnet" ? "https://mainnet.sorobanrpc.com" : "https://soroban-testnet.stellar.org";
+                const server = new Server(rpcUrl);
+                const payeePublicKey = payeeKeypair.publicKey();
+                const sourceAccount = await server.getAccount(payeePublicKey);
+                const tx = buildSessionSettlementTransaction(
+                  sourceAccount,
+                  vaultContract,
+                  opts.channelFactory,
+                  settlementAddresses,
+                  closeAmount,
+                  voucherCount,
+                  networkPassphrase
+                );
+                const preparedTx = await server.prepareTransaction(tx);
+                preparedTx.sign(payeeKeypair);
+                await server.sendTransaction(preparedTx);
+              } catch (recordErr) {
+                logger("error", "[mpp-session] failed to record session_settled on vault", { error: recordErr });
+              }
+            }
+          }
+          res.json({ closeTxHash });
+        } else {
+          res.json({ closeTxHash: null, message: "no vouchers received" });
+        }
+        sessionOpened = false;
+        voucherCount = 0;
+        record = null;
+        await innerStore.delete(voucherRecordKey);
+        closeListenerArmed = false;
+        clearIdleTimer();
+        return;
+      }
+      const fetchReq = 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;
+      }
+      if (!closeListenerArmed) {
+        closeListenerArmed = true;
+        req.on("close", () => {
+          void flagOrphan("connection-closed");
+        });
+      }
+      next();
+    } catch (err) {
+      next(err);
+    }
+  };
+}
+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") };
+}
+
+// src/provider/fastify.ts
+function buildExpressShims(rawReq, rawRes, fastifyRequest, fastifyReply) {
+  const req = rawReq;
+  const urlStr = rawReq.url ?? "/";
+  const parsedUrl = new URL(urlStr, "http://placeholder");
+  const reqGet = (name) => {
+    const val = rawReq.headers[name.toLowerCase()];
+    return Array.isArray(val) ? val[0] : val;
+  };
+  if (!("get" in req && typeof req.get === "function")) {
+    Object.defineProperty(req, "get", { value: reqGet, configurable: true });
+    Object.defineProperty(req, "header", { value: reqGet, configurable: true });
+  }
+  if (!("protocol" in req)) {
+    Object.defineProperty(req, "protocol", {
+      get: () => fastifyRequest.protocol ?? "http",
+      configurable: true
+    });
+  }
+  if (!("originalUrl" in req)) {
+    Object.defineProperty(req, "originalUrl", { value: urlStr, configurable: true });
+  }
+  if (!("path" in req)) {
+    Object.defineProperty(req, "path", { value: parsedUrl.pathname, configurable: true });
+  }
+  if (!("query" in req)) {
+    const q = {};
+    parsedUrl.searchParams.forEach((v, k) => {
+      q[k] = v;
+    });
+    Object.defineProperty(req, "query", { value: q, configurable: true });
+  }
+  const res = rawRes;
+  const nativeSetHeader = rawRes.setHeader.bind(rawRes);
+  const nativeGetHeader = rawRes.getHeader.bind(rawRes);
+  const nativeEnd = rawRes.end.bind(rawRes);
+  const extraHeaders = {};
+  const resSend = (body) => {
+    if (!rawRes.headersSent) {
+      for (const [k, v] of Object.entries(extraHeaders)) {
+        nativeSetHeader(k, v);
+      }
+      if (typeof body === "string") {
+        nativeEnd(body);
+      } else if (body !== void 0 && body !== null) {
+        if (!nativeGetHeader("content-type")) {
+          nativeSetHeader("Content-Type", "application/json");
+        }
+        nativeEnd(JSON.stringify(body));
+      } else {
+        nativeEnd();
+      }
+    }
+    return res;
+  };
+  const resJson = (data) => {
+    if (!nativeGetHeader("content-type")) {
+      nativeSetHeader("Content-Type", "application/json");
+    }
+    return resSend(data);
+  };
+  const resStatus = (code) => {
+    rawRes.statusCode = code;
+    return res;
+  };
+  const resSet = (field, val) => {
+    if (typeof field === "object") {
+      for (const [k, v] of Object.entries(field)) nativeSetHeader(k, v);
+    } else if (val !== void 0) {
+      extraHeaders[field] = val;
+      nativeSetHeader(field, val);
+    }
+    return res;
+  };
+  const resSetHeader = (name, value) => {
+    nativeSetHeader(name, value);
+    return res;
+  };
+  if (!("status" in res && typeof res.status === "function")) {
+    Object.defineProperty(res, "status", { value: resStatus, configurable: true });
+    Object.defineProperty(res, "json", { value: resJson, configurable: true });
+    Object.defineProperty(res, "send", { value: resSend, configurable: true });
+    Object.defineProperty(res, "set", { value: resSet, configurable: true });
+    Object.defineProperty(res, "setHeader", { value: resSetHeader, configurable: true });
+    Object.defineProperty(res, "end", {
+      value: (data) => {
+        nativeEnd(data);
+      },
+      configurable: true
+    });
+  }
+  return { req, res };
+}
+function runExpressHandler(handler, fastifyRequest, fastifyReply) {
+  const rawRes = fastifyReply.raw;
+  const { req, res } = buildExpressShims(
+    fastifyRequest.raw,
+    rawRes,
+    fastifyRequest);
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (err) => {
+      if (settled) return;
+      settled = true;
+      if (err != null) return reject(err);
+      if (rawRes.writableEnded || rawRes.headersSent) fastifyReply.hijack();
+      resolve();
+    };
+    Promise.resolve(handler(req, res, (err) => finish(err))).then(() => finish(), finish);
+  });
+}
+var MPP_MODES = ["mpp-session", "mpp-charge"];
+function routedockFastify(opts) {
+  const signedManifest = signManifest(opts.manifest, opts.payeeSecretKey);
+  const handlerMap = /* @__PURE__ */ new Map();
+  if (opts.modes.includes("x402")) {
+    const x402Price = opts.pricing.x402;
+    if (x402Price) {
+      handlerMap.set(
+        "x402",
+        createX402Handler({
+          payeeSecretKey: opts.payeeSecretKey,
+          network: opts.network,
+          amount: x402Price,
+          ...opts.assetContract ? { assetContract: opts.assetContract } : {},
+          ...opts.facilitatorApiKey ? { facilitatorApiKey: opts.facilitatorApiKey } : {},
+          manifest: signedManifest,
+          ...opts.onSettled ? { onSettled: opts.onSettled } : {},
+          ...opts.onCallbackError ? { onCallbackError: opts.onCallbackError } : {},
+          ...opts.seenTxStore ? { seenTxStore: opts.seenTxStore } : {},
+          ...opts.logger ? { logger: opts.logger } : {}
+        })
+      );
+    }
+  }
+  if (opts.modes.includes("mpp-charge")) {
+    const chargePrice = opts.pricing["mpp-charge"];
+    if (chargePrice) {
+      handlerMap.set(
+        "mpp-charge",
+        createMppChargeHandler({
+          payeeSecretKey: opts.payeeSecretKey,
+          network: opts.network,
+          amount: chargePrice,
+          ...opts.assetContract ? { assetContract: opts.assetContract } : {},
+          manifest: signedManifest,
+          ...opts.onSettled ? { onSettled: opts.onSettled } : {},
+          ...opts.onCallbackError ? { onCallbackError: opts.onCallbackError } : {},
+          ...opts.seenTxStore ? { seenTxStore: opts.seenTxStore } : {},
+          ...opts.logger ? { logger: opts.logger } : {}
+        })
+      );
+    }
+  }
+  if (opts.modes.includes("mpp-session")) {
+    const sessionPricing = opts.pricing["mpp-session"];
+    if (sessionPricing) {
+      if (!opts.commitmentPublicKey) {
+        throw new Error("routedockFastify: mpp-session mode requires commitmentPublicKey");
+      }
+      handlerMap.set(
+        "mpp-session",
+        createMppSessionHandler({
+          payeeSecretKey: opts.payeeSecretKey,
+          network: opts.network,
+          channelFactory: sessionPricing.channelFactory,
+          rate: sessionPricing.rate,
+          ...opts.assetContract ? { assetContract: opts.assetContract } : {},
+          manifest: signedManifest,
+          commitmentPublicKey: opts.commitmentPublicKey,
+          ...opts.onSettled ? { onSettled: opts.onSettled } : {},
+          ...opts.onSessionOpen ? { onSessionOpen: opts.onSessionOpen } : {},
+          ...opts.onVoucher ? { onVoucher: opts.onVoucher } : {},
+          ...opts.onCallbackError ? { onCallbackError: opts.onCallbackError } : {},
+          ...opts.onOrphaned ? { onOrphaned: opts.onOrphaned } : {},
+          ...opts.idleTimeoutMs != null ? { idleTimeoutMs: opts.idleTimeoutMs } : {},
+          ...opts.logger ? { logger: opts.logger } : {}
+        })
+      );
+    }
+  }
+  const defaultMode = MPP_MODES.find((mode) => handlerMap.has(mode)) ?? (handlerMap.has("x402") ? "x402" : void 0);
+  const plugin = async (fastify) => {
+    fastify.addHook("onRequest", async (request, reply) => {
+      if (request.url === "/.well-known/routedock.json") {
+        reply.hijack();
+        const body = JSON.stringify(signedManifest);
+        reply.raw.setHeader("Content-Type", "application/json");
+        reply.raw.setHeader("Content-Length", Buffer.byteLength(body));
+        reply.raw.end(body);
+        return;
+      }
+      if (handlerMap.size === 0) return;
+      const prefersX402 = !!(request.headers["payment-signature"] || request.headers["x-payment"]) || request.headers["x-preferred-mode"] === "x402";
+      const selectedMode = prefersX402 ? handlerMap.has("x402") ? "x402" : defaultMode : defaultMode;
+      if (!selectedMode) return;
+      const handler = handlerMap.get(selectedMode);
+      if (!handler) return;
+      await runExpressHandler(handler, request, reply);
+    });
+  };
+  Object.defineProperty(plugin, /* @__PURE__ */ Symbol.for("skip-override"), { value: true });
+  return plugin;
+}
+
+export { routedockFastify };