@routedock/routedock 0.2.0 → 0.3.1

package/dist/provider/hono.js

@@ -4,8 +4,8 @@ import { ExactStellarScheme as ExactStellarScheme$1 } from '@x402/stellar/exact/
 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 { stellar as stellar$1 } from '@stellar/mpp/charge/server';
+import { Store, stellar, close } from '@stellar/mpp/channel/server';
 import { Mppx } from 'mppx/server';
 import { createHash } from 'crypto';
 import { usdcToStroops } from '@routedock/nulth-sdk';
@@ -109,7 +109,7 @@ function verifyManifestSignature(manifest, expectedPayee) {
   }
 }
 
-// src/provider/payee.ts
+// src/internal/payee.ts
 function resolvePayee(manifest, mode) {
   const override = manifest.pricing[mode]?.payee;
   return override ?? manifest.payee;
@@ -119,6 +119,22 @@ function extractPayerAddress(key) {
   if (typeof key !== "string") return null;
   return StrKey.isValidEd25519PublicKey(key) || 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 };
 }
@@ -204,8 +220,24 @@ function hexToBytes(hex) {
 }
 
 // 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;
@@ -213,7 +245,8 @@ var InMemorySeenTxStore = class {
     if (options.warn !== false) {
       const isServerless = typeof globalThis.navigator !== "undefined" && globalThis.navigator.userAgent === "Cloudflare-Workers";
       if (isServerless) {
-        console.warn(
+        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."
         );
       }
@@ -228,21 +261,115 @@ var InMemorySeenTxStore = class {
       this.order.push(key);
       if (this.order.length > this.maxEntries) {
         const evicted = this.order.shift();
-        if (evicted !== void 0) this.map.delete(evicted);
+        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) {
+async function paymentIdempotencyKey(getHeader, scope) {
   const material = getHeader("payment-signature") ?? getHeader("x-payment") ?? getHeader("authorization");
   if (!material) return null;
-  return sha256Hex(material);
+  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
@@ -295,7 +422,7 @@ var SupabaseSeenTxStore = class {
   }
   supabase;
   async get(key) {
-    const { data, error } = await this.supabase.from("settlements").select("tx_hash, headers").eq("key", key).maybeSingle();
+    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}`);
     }
@@ -303,7 +430,8 @@ var SupabaseSeenTxStore = class {
     const headers = data.headers;
     return {
       txHash: data.tx_hash ?? null,
-      ...headers ? { headers } : {}
+      ...headers ? { headers } : {},
+      createdAt: Date.parse(data.created_at)
     };
   }
   async set(key, record) {
@@ -311,7 +439,8 @@ var SupabaseSeenTxStore = class {
       {
         key,
         tx_hash: record.txHash,
-        headers: record.headers ?? null
+        headers: record.headers ?? null,
+        created_at: new Date(record.createdAt ?? Date.now()).toISOString()
       },
       { onConflict: "key" }
     );
@@ -319,6 +448,22 @@ var SupabaseSeenTxStore = class {
       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",
@@ -398,25 +543,26 @@ async function reconcileAbandonedSessions(opts) {
   }
 }
 async function runStartupReconciliation(opts, logger) {
-  const log = logger || console.log;
-  log("[SessionReconciler] Running startup reconciliation...");
+  const log = resolveLogger(logger);
+  log("info", "[SessionReconciler] Running startup reconciliation...");
   try {
     const stats = await reconcileAbandonedSessions(opts);
     if (stats.orphanedCount === 0) {
-      log("[SessionReconciler] No orphaned sessions found");
+      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("[SessionReconciler] Reconciliation errors:");
+      log("warn", "[SessionReconciler] Reconciliation errors:");
       for (const err of stats.errors) {
-        log(`  - ${err.channelId}: ${err.reason}`);
+        log("warn", `  - ${err.channelId}: ${err.reason}`);
       }
     }
   } catch (err) {
-    log(`[SessionReconciler] Startup reconciliation failed: ${formatMppError(err)}`);
+    log("error", `[SessionReconciler] Startup reconciliation failed: ${formatMppError(err)}`);
   }
 }
 
@@ -431,7 +577,8 @@ function createX402HonoHandler(opts) {
   const payeeKeypair = Keypair.fromSecret(opts.payeeSecretKey);
   const signer = createEd25519Signer(opts.payeeSecretKey, caip2);
   const x402Price = opts.pricing.x402;
-  const seenTxStore = opts.seenTxStore ?? new InMemorySeenTxStore();
+  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
@@ -451,22 +598,28 @@ function createX402HonoHandler(opts) {
     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) {
+      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,
@@ -477,7 +630,6 @@ function createX402HonoHandler(opts) {
             resourceInfo
           );
           c.header("X-Payment-Requirements", encodePaymentRequiredHeader(paymentRequired));
-          return c.json({ error: "Payment Required" }, 402);
         } else {
           const x402Response = {
             x402Version: 2,
@@ -485,15 +637,30 @@ function createX402HonoHandler(opts) {
             accepts: [requirements]
           };
           c.header("X-Payment-Requirements", encodePaymentRequiredHeader(x402Response));
-          return c.json({ error: "Payment Required" }, 402);
         }
+        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));
+      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 cached = await seenTxStore.get(idempotencyKey);
-        if (cached) {
-          if (cached.headers) {
-            for (const [k, val] of Object.entries(cached.headers)) {
+        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);
             }
           }
@@ -513,13 +680,15 @@ function createX402HonoHandler(opts) {
       }
       if (ozServer) {
         const settleResult = await ozServer.settlePayment(payload, requirements);
-        txHash = settleResult.transaction ?? null;
-        if (settleResult) {
-          paymentResponseHeader = encodePaymentResponseHeader(
-            settleResult
-          );
-          c.header("X-Payment-Response", paymentResponseHeader);
+        const outcome = readSettleResult(settleResult);
+        if (!outcome.ok) {
+          return respondPaymentRequired("Payment settlement failed", outcome.reason);
         }
+        txHash = outcome.txHash;
+        paymentResponseHeader = encodePaymentResponseHeader(
+          settleResult
+        );
+        c.header("X-Payment-Response", paymentResponseHeader);
       } else {
         const verifyResult = await localFacilitator.verify(
           payload,
@@ -538,28 +707,33 @@ function createX402HonoHandler(opts) {
           payload,
           requirements
         );
-        txHash = settleResult.transaction ?? null;
-        if (settleResult) {
-          paymentResponseHeader = encodePaymentResponseHeader(
-            settleResult
-          );
-          c.header("X-Payment-Response", paymentResponseHeader);
+        const outcome = readSettleResult(settleResult);
+        if (!outcome.ok) {
+          return respondPaymentRequired("Payment settlement failed", outcome.reason);
         }
+        txHash = outcome.txHash;
+        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 });
+        await seenTxStore.set(idempotencyKey, { txHash, headers, createdAt: Date.now() });
       }
       if (txHash && opts.onSettled) {
         Promise.resolve().then(() => opts.onSettled(txHash, x402Price, "x402", payerAddress)).catch((err) => {
-          console.error("[x402] onSettled callback error:", err);
+          logger("error", "[x402] onSettled callback error", { error: err });
           opts.onCallbackError?.(err, "onSettled");
         });
       }
       await next();
     } catch (err) {
-      console.error("[x402] Settlement error:", err);
+      if (err instanceof RouteDockManifestError) {
+        throw err;
+      }
+      logger("error", "[x402] Settlement error", { error: err });
       return c.json({ error: "Payment settlement failed" }, 500);
     }
   };
@@ -568,20 +742,37 @@ 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 }
-      })
-    ]
-  });
+  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({
+            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");
@@ -597,12 +788,23 @@ function createMppChargeHonoHandler(opts) {
         }
       } catch {
       }
-      const idempotencyKey = await paymentIdempotencyKey((name) => c.req.header(name));
+      const idempotencyKey = await paymentIdempotencyKey(
+        (name) => c.req.header(name),
+        {
+          method: c.req.method,
+          path: c.req.path,
+          amount: chargePrice,
+          payTo: recipient
+        }
+      );
       if (idempotencyKey) {
-        const cached = await seenTxStore.get(idempotencyKey);
-        if (cached) {
-          if (cached.headers) {
-            for (const [k, val] of Object.entries(cached.headers)) {
+        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);
             }
           }
@@ -613,7 +815,7 @@ function createMppChargeHonoHandler(opts) {
       const handler = mppx["stellar/charge"];
       const result = await handler({
         amount: chargePrice,
-        currency: opts.assetContract,
+        currency: assetContract,
         recipient,
         description: opts.manifest.name
       })(c.req.raw);
@@ -643,12 +845,13 @@ function createMppChargeHonoHandler(opts) {
       if (idempotencyKey) {
         await seenTxStore.set(idempotencyKey, {
           txHash: reference ?? null,
-          headers: receiptHeaders
+          headers: receiptHeaders,
+          createdAt: Date.now()
         });
       }
       if (reference && opts.onSettled) {
         Promise.resolve().then(() => opts.onSettled(reference, chargePrice, "mpp-charge", payerAddress)).catch((err) => {
-          console.error("[mpp-charge] onSettled callback error:", err);
+          logger("error", "[mpp-charge] onSettled callback error", { error: err });
           opts.onCallbackError?.(err, "onSettled");
         });
       }
@@ -665,6 +868,7 @@ function mppSessionWsVerified(c) {
 function createMppSessionHandlerState(opts, sessionPricing, reportMode) {
   const networkId = CAIP2[opts.network];
   const payeeKeypair = Keypair.fromSecret(opts.payeeSecretKey);
+  const logger = resolveLogger(opts.logger);
   const voucherRecordKey = `routedock:session:voucher:${sessionPricing.channelFactory}`;
   const innerStore = opts.sessionStore ?? Store.memory();
   let record = null;
@@ -717,7 +921,7 @@ function createMppSessionHandlerState(opts, sessionPricing, reportMode) {
           reason
         });
       } catch (err) {
-        console.error("[mpp-session] onOrphaned handler failed:", err);
+        logger("error", "[mpp-session] onOrphaned handler failed", { error: err });
       }
     }
   }
@@ -764,7 +968,7 @@ function createMppSessionHandlerState(opts, sessionPricing, reportMode) {
       sessionOpened = true;
       if (opts.onSessionOpen) {
         Promise.resolve().then(() => opts.onSessionOpen(sessionPricing.channelFactory, record.payer)).catch((err) => {
-          console.error("[mpp-session] onSessionOpen callback error:", err);
+          logger("error", "[mpp-session] onSessionOpen callback error", { error: err });
           opts.onCallbackError?.(err, "onSessionOpen");
         });
       }
@@ -772,7 +976,7 @@ function createMppSessionHandlerState(opts, sessionPricing, reportMode) {
     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);
+        logger("error", "[mpp-session] onVoucher callback error", { error: err });
         opts.onCallbackError?.(err, "onVoucher");
       });
     }
@@ -782,7 +986,7 @@ function createMppSessionHandlerState(opts, sessionPricing, reportMode) {
     methods: [
       withTypedChannelErrors(
         onVerifiedCredential(
-          stellar$1({
+          stellar({
             channel: sessionPricing.channelFactory,
             commitmentKey: opts.commitmentPublicKey,
             network: networkId,
@@ -829,7 +1033,7 @@ function createMppSessionHandlerState(opts, sessionPricing, reportMode) {
         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);
+            logger("error", "[mpp-session] onSettled callback error", { error: err });
             opts.onCallbackError?.(err, "onSettled");
           });
         }