@routedock/routedock 0.1.0

package/dist/provider.cjs

@@ -0,0 +1,425 @@
+'use strict';
+
+var stellarSdk = require('@stellar/stellar-sdk');
+var facilitator = require('@x402/stellar/exact/facilitator');
+var stellar = require('@x402/stellar');
+var http = require('@x402/core/http');
+var server$1 = require('@stellar/mpp/charge/server');
+var server = require('mppx/server');
+var server$2 = require('@stellar/mpp/channel/server');
+
+// src/types.ts
+var RouteDockError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RouteDockError";
+  }
+};
+var RouteDockManifestError = class extends RouteDockError {
+  constructor(message) {
+    super(message);
+    this.name = "RouteDockManifestError";
+  }
+};
+var RouteDockNoSupportedModeError = class extends RouteDockError {
+  constructor(message) {
+    super(message);
+    this.name = "RouteDockNoSupportedModeError";
+  }
+};
+var RouteDockSessionError = class extends RouteDockError {
+  constructor(message) {
+    super(message);
+    this.name = "RouteDockSessionError";
+  }
+};
+var RouteDockPolicyRejectedError = class extends RouteDockError {
+  reason;
+  constructor(reason) {
+    super(`Payment rejected by policy: ${reason}`);
+    this.name = "RouteDockPolicyRejectedError";
+    this.reason = reason;
+  }
+};
+var CAIP2 = {
+  testnet: "stellar:testnet",
+  mainnet: "stellar:pubnet"
+};
+function createX402Handler(opts) {
+  const caip2 = CAIP2[opts.network];
+  const payeeKeypair = stellarSdk.Keypair.fromSecret(opts.payeeSecretKey);
+  const signer = stellar.createEd25519Signer(opts.payeeSecretKey, caip2);
+  const facilitatorScheme = new facilitator.ExactStellarScheme([signer], {
+    areFeesSponsored: true
+  });
+  const amountInBaseUnits = String(Math.round(parseFloat(opts.amount) * 1e7));
+  const requirements = {
+    scheme: "exact",
+    network: caip2,
+    asset: opts.assetContract,
+    amount: amountInBaseUnits,
+    payTo: opts.manifest.payee,
+    maxTimeoutSeconds: 60,
+    extra: {
+      areFeesSponsored: true,
+      facilitatorAddresses: [payeeKeypair.publicKey()]
+    }
+  };
+  return async (req, res, next) => {
+    try {
+      const paymentHeader = req.headers["payment-signature"] ?? req.headers["x-payment"];
+      if (!paymentHeader) {
+        const x402Response = {
+          x402Version: 2,
+          resource: {
+            url: `${req.protocol}://${req.get("host") ?? ""}${req.originalUrl}`,
+            description: opts.manifest.name
+          },
+          accepts: [requirements]
+        };
+        res.status(402).setHeader("Content-Type", "application/json").setHeader("X-Payment-Requirements", http.encodePaymentRequiredHeader(x402Response)).json({ error: "Payment Required" });
+        return;
+      }
+      const payload = http.decodePaymentSignatureHeader(paymentHeader);
+      const verifyResult = await facilitatorScheme.verify(
+        payload,
+        requirements
+      );
+      if (!verifyResult.isValid) {
+        res.status(401).json({
+          error: "Payment verification failed",
+          reason: verifyResult.invalidReason
+        });
+        return;
+      }
+      const settleResult = await facilitatorScheme.settle(
+        payload,
+        requirements
+      );
+      const txHash = settleResult.transaction ?? null;
+      if (txHash && opts.onSettled) {
+        await opts.onSettled(txHash, opts.amount, "x402");
+      }
+      if (settleResult) {
+        res.setHeader(
+          "X-Payment-Response",
+          http.encodePaymentResponseHeader(
+            settleResult
+          )
+        );
+      }
+      next();
+    } catch (err) {
+      console.error("[x402] Settlement error:", err);
+      res.status(500).json({ error: "Payment settlement failed" });
+    }
+  };
+}
+var MPP_NETWORK = {
+  testnet: "stellar:testnet",
+  mainnet: "stellar:pubnet"
+};
+function createMppChargeHandler(opts) {
+  const networkId = MPP_NETWORK[opts.network];
+  const amountHumanReadable = opts.amount;
+  const mppx = server.Mppx.create({
+    secretKey: opts.payeeSecretKey,
+    methods: [
+      server$1.stellar.charge({
+        recipient: opts.manifest.payee,
+        currency: opts.assetContract,
+        network: networkId,
+        feePayer: { envelopeSigner: opts.payeeSecretKey }
+      })
+    ]
+  });
+  return async (req, res, next) => {
+    try {
+      const fetchReq = server.Request.fromNodeListener(req, res);
+      const handler = mppx["stellar/charge"];
+      const result = await handler({
+        amount: amountHumanReadable,
+        currency: opts.assetContract,
+        recipient: opts.manifest.payee,
+        description: opts.manifest.name
+      })(fetchReq);
+      if (result.status === 402) {
+        const challenge = result.challenge;
+        res.status(402);
+        challenge.headers.forEach((v, k) => res.setHeader(k, v));
+        res.send(await challenge.text());
+        return;
+      }
+      const receipt = result.withReceipt(new Response(""));
+      receipt.headers.forEach((v, k) => res.setHeader(k, v));
+      const receiptHeader = receipt.headers.get("payment-receipt");
+      if (receiptHeader && opts.onSettled) {
+        try {
+          const parsed = JSON.parse(
+            Buffer.from(receiptHeader, "base64").toString("utf8")
+          );
+          if (parsed.reference) {
+            await opts.onSettled(parsed.reference, opts.amount, "mpp-charge");
+          }
+        } catch {
+        }
+      }
+      next();
+    } catch (err) {
+      next(err);
+    }
+  };
+}
+var MPP_NETWORK2 = {
+  testnet: "stellar:testnet",
+  mainnet: "stellar:pubnet"
+};
+function createMppSessionHandler(opts) {
+  const networkId = MPP_NETWORK2[opts.network];
+  const rateHuman = opts.rate;
+  const payeeKeypair = stellarSdk.Keypair.fromSecret(opts.payeeSecretKey);
+  const cumulativeKey = `stellar:channel:cumulative:${opts.channelContract}`;
+  const innerStore = server$2.Store.memory();
+  let lastCumulativeAmount = 0n;
+  const wrappedStore = {
+    async get(key) {
+      return innerStore.get(key);
+    },
+    async put(key, value) {
+      await innerStore.put(key, value);
+      if (key === cumulativeKey && value && typeof value === "object" && "amount" in value) {
+        lastCumulativeAmount = BigInt(value.amount);
+      }
+    },
+    async delete(key) {
+      return innerStore.delete(key);
+    }
+  };
+  const mppx = server.Mppx.create({
+    secretKey: opts.payeeSecretKey,
+    methods: [
+      server$2.stellar.channel({
+        channel: opts.channelContract,
+        commitmentKey: opts.commitmentPublicKey,
+        network: networkId,
+        store: wrappedStore,
+        sourceAccount: payeeKeypair.publicKey(),
+        feePayer: { envelopeSigner: payeeKeypair }
+      })
+    ]
+  });
+  let lastSignatureHex = "";
+  return async (req, res, next) => {
+    try {
+      if (req.method === "DELETE") {
+        const body = req.body;
+        const closeAmount = body?.amount ? BigInt(body.amount) : lastCumulativeAmount;
+        const closeSig = body?.signature ?? lastSignatureHex;
+        if (closeAmount > 0n && closeSig) {
+          const closeTxHash = await server$2.close({
+            channel: opts.channelContract,
+            amount: closeAmount,
+            signature: Buffer.from(closeSig, "hex"),
+            feePayer: { envelopeSigner: payeeKeypair },
+            network: networkId
+          });
+          if (opts.onSettled) {
+            const totalPaid = (Number(lastCumulativeAmount) / 1e7).toFixed(7);
+            await opts.onSettled(closeTxHash, totalPaid, "mpp-session");
+          }
+          res.json({ closeTxHash });
+        } else {
+          res.json({ closeTxHash: null, message: "no vouchers received" });
+        }
+        return;
+      }
+      const authHeader = req.headers["authorization"];
+      if (typeof authHeader === "string" && authHeader.startsWith("Payment ")) {
+        try {
+          const credB64 = authHeader.replace(/^Payment\s+/, "").split(",").find((p) => p.trim().startsWith("credential="));
+          if (credB64) {
+            const credJson = Buffer.from(credB64.split("=").slice(1).join("=").replace(/^"|"$/g, ""), "base64").toString("utf8");
+            const cred = JSON.parse(credJson);
+            if (cred.payload?.signature) {
+              lastSignatureHex = cred.payload.signature;
+            }
+          }
+        } catch {
+        }
+      }
+      const fetchReq = server.Request.fromNodeListener(req, res);
+      const result = await mppx.channel({
+        amount: rateHuman,
+        description: opts.manifest.name
+      })(fetchReq);
+      if (result.status === 402) {
+        const challenge = result.challenge;
+        res.status(402);
+        challenge.headers.forEach((v, k) => res.setHeader(k, v));
+        const body = await challenge.text();
+        res.send(body);
+        return;
+      }
+      next();
+    } catch (err) {
+      next(err);
+    }
+  };
+}
+
+// src/provider/routedockMiddleware.ts
+function routedock(opts) {
+  const handlers = [];
+  if (opts.modes.includes("x402")) {
+    const x402Price = opts.pricing.x402;
+    if (x402Price) {
+      handlers.push(
+        createX402Handler({
+          payeeSecretKey: opts.payeeSecretKey,
+          network: opts.network,
+          amount: x402Price,
+          assetContract: opts.assetContract,
+          ...opts.facilitatorApiKey ? { facilitatorApiKey: opts.facilitatorApiKey } : {},
+          manifest: opts.manifest,
+          ...opts.onSettled ? { onSettled: opts.onSettled } : {}
+        })
+      );
+    }
+  }
+  if (opts.modes.includes("mpp-charge")) {
+    const chargePrice = opts.pricing["mpp-charge"];
+    if (chargePrice) {
+      handlers.push(
+        createMppChargeHandler({
+          payeeSecretKey: opts.payeeSecretKey,
+          network: opts.network,
+          amount: chargePrice,
+          assetContract: opts.assetContract,
+          manifest: opts.manifest,
+          ...opts.onSettled ? { onSettled: opts.onSettled } : {}
+        })
+      );
+    }
+  }
+  if (opts.modes.includes("mpp-session")) {
+    const sessionPricing = opts.pricing["mpp-session"];
+    if (sessionPricing) {
+      if (!opts.commitmentPublicKey) {
+        throw new Error("routedock: mpp-session mode requires commitmentPublicKey");
+      }
+      handlers.push(
+        createMppSessionHandler({
+          payeeSecretKey: opts.payeeSecretKey,
+          network: opts.network,
+          channelContract: sessionPricing.channelContract,
+          rate: sessionPricing.rate,
+          assetContract: opts.assetContract,
+          manifest: opts.manifest,
+          commitmentPublicKey: opts.commitmentPublicKey,
+          ...opts.onSettled ? { onSettled: opts.onSettled } : {}
+        })
+      );
+    }
+  }
+  return (req, res, next) => {
+    if (req.path === "/.well-known/routedock.json") {
+      res.json(opts.manifest);
+      return;
+    }
+    if (handlers.length === 0) {
+      next();
+      return;
+    }
+    const hasX402Header = !!(req.headers["payment-signature"] || req.headers["x-payment"]);
+    const prefersX402 = req.headers["x-preferred-mode"] === "x402";
+    let handler;
+    if (hasX402Header || prefersX402) {
+      handler = handlers[0];
+    } else {
+      handler = handlers[handlers.length - 1];
+    }
+    if (!handler) {
+      next();
+      return;
+    }
+    void Promise.resolve().then(() => new Promise((resolve, reject) => {
+      handler(req, res, (handlerErr) => {
+        if (handlerErr != null) reject(handlerErr);
+        else resolve();
+      });
+    })).then(() => next()).catch((err) => next(err));
+  };
+}
+
+// src/store/SessionStore.ts
+var SupabaseSessionStore = class {
+  constructor(supabase) {
+    this.supabase = supabase;
+  }
+  supabase;
+  async get(channelId) {
+    const { data, error } = await this.supabase.from("sessions").select("*").eq("channel_id", channelId).maybeSingle();
+    if (error) throw new RouteDockSessionError(`SessionStore.get failed: ${error.message}`);
+    if (!data) return null;
+    return {
+      channel_id: data.channel_id,
+      payee: data.payee,
+      payer: data.payer,
+      cumulative_amount: String(data.cumulative_amount),
+      last_signature: data.last_signature,
+      status: data.status,
+      opened_at: data.opened_at,
+      updated_at: data.updated_at,
+      settlement_tx_hash: data.settlement_tx_hash
+    };
+  }
+  async upsert(channelId, state) {
+    const existing = await this.get(channelId);
+    if (existing) {
+      const prev = parseFloat(existing.cumulative_amount);
+      const next = parseFloat(state.cumulative_amount);
+      if (next <= prev) {
+        throw new RouteDockSessionError(
+          `cumulative_amount must be strictly increasing: ${next} <= ${prev}`
+        );
+      }
+    }
+    const { error } = await this.supabase.from("sessions").upsert(
+      {
+        channel_id: state.channel_id,
+        payee: state.payee,
+        payer: state.payer,
+        cumulative_amount: state.cumulative_amount,
+        last_signature: state.last_signature,
+        status: state.status,
+        opened_at: state.opened_at,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+        settlement_tx_hash: state.settlement_tx_hash
+      },
+      { onConflict: "channel_id" }
+    );
+    if (error) {
+      if (error.message.includes("strictly increasing")) {
+        throw new RouteDockSessionError(
+          `cumulative_amount must be strictly increasing (DB): ${error.message}`
+        );
+      }
+      throw new RouteDockSessionError(`SessionStore.upsert failed: ${error.message}`);
+    }
+  }
+  async close(channelId) {
+    const { error } = await this.supabase.from("sessions").update({ status: "closed", updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("channel_id", channelId);
+    if (error) throw new RouteDockSessionError(`SessionStore.close failed: ${error.message}`);
+  }
+};
+
+exports.RouteDockError = RouteDockError;
+exports.RouteDockManifestError = RouteDockManifestError;
+exports.RouteDockNoSupportedModeError = RouteDockNoSupportedModeError;
+exports.RouteDockPolicyRejectedError = RouteDockPolicyRejectedError;
+exports.RouteDockSessionError = RouteDockSessionError;
+exports.SupabaseSessionStore = SupabaseSessionStore;
+exports.createMppChargeHandler = createMppChargeHandler;
+exports.createMppSessionHandler = createMppSessionHandler;
+exports.createX402Handler = createX402Handler;
+exports.routedock = routedock;

package/dist/provider.d.cts

@@ -0,0 +1,44 @@
+import { c as RouteDockManifest, k as SessionStore } from './SessionStore-CCVO0PHM.cjs';
+export { P as PaymentMode, a as PaymentResult, b as PricingConfig, R as RouteDockError, d as RouteDockManifestError, e as RouteDockNoSupportedModeError, f as RouteDockPolicyRejectedError, g as RouteDockSessionError, S as SessionCloseResult, h as SessionHandle, i as SessionPricingConfig, j as SessionState, l as SupabaseSessionStore } from './SessionStore-CCVO0PHM.cjs';
+export { R as RouteDockMiddlewareOptions, r as routedock } from './routedockMiddleware-Beqan6QS.cjs';
+import { RequestHandler } from 'express';
+import '@supabase/supabase-js';
+
+type Network$2 = 'testnet' | 'mainnet';
+interface X402HandlerOptions {
+    payeeSecretKey: string;
+    network: Network$2;
+    amount: string;
+    assetContract: string;
+    facilitatorApiKey?: string;
+    manifest: RouteDockManifest;
+    onSettled?: (txHash: string, amount: string, mode: string) => Promise<void>;
+}
+declare function createX402Handler(opts: X402HandlerOptions): RequestHandler;
+
+type Network$1 = 'testnet' | 'mainnet';
+interface MppChargeHandlerOptions {
+    payeeSecretKey: string;
+    network: Network$1;
+    amount: string;
+    assetContract: string;
+    manifest: RouteDockManifest;
+    store?: SessionStore;
+    onSettled?: (txHash: string, amount: string, mode: string) => Promise<void>;
+}
+declare function createMppChargeHandler(opts: MppChargeHandlerOptions): RequestHandler;
+
+type Network = 'testnet' | 'mainnet';
+interface MppSessionHandlerOptions {
+    payeeSecretKey: string;
+    network: Network;
+    channelContract: string;
+    rate: string;
+    assetContract: string;
+    manifest: RouteDockManifest;
+    commitmentPublicKey: string;
+    onSettled?: (txHash: string, totalPaid: string, mode: string) => Promise<void>;
+}
+declare function createMppSessionHandler(opts: MppSessionHandlerOptions): RequestHandler;
+
+export { type MppChargeHandlerOptions, type MppSessionHandlerOptions, RouteDockManifest, SessionStore, type X402HandlerOptions, createMppChargeHandler, createMppSessionHandler, createX402Handler };

package/dist/provider.d.ts

@@ -0,0 +1,44 @@
+import { c as RouteDockManifest, k as SessionStore } from './SessionStore-CCVO0PHM.js';
+export { P as PaymentMode, a as PaymentResult, b as PricingConfig, R as RouteDockError, d as RouteDockManifestError, e as RouteDockNoSupportedModeError, f as RouteDockPolicyRejectedError, g as RouteDockSessionError, S as SessionCloseResult, h as SessionHandle, i as SessionPricingConfig, j as SessionState, l as SupabaseSessionStore } from './SessionStore-CCVO0PHM.js';
+export { R as RouteDockMiddlewareOptions, r as routedock } from './routedockMiddleware-CqnyHjhO.js';
+import { RequestHandler } from 'express';
+import '@supabase/supabase-js';
+
+type Network$2 = 'testnet' | 'mainnet';
+interface X402HandlerOptions {
+    payeeSecretKey: string;
+    network: Network$2;
+    amount: string;
+    assetContract: string;
+    facilitatorApiKey?: string;
+    manifest: RouteDockManifest;
+    onSettled?: (txHash: string, amount: string, mode: string) => Promise<void>;
+}
+declare function createX402Handler(opts: X402HandlerOptions): RequestHandler;
+
+type Network$1 = 'testnet' | 'mainnet';
+interface MppChargeHandlerOptions {
+    payeeSecretKey: string;
+    network: Network$1;
+    amount: string;
+    assetContract: string;
+    manifest: RouteDockManifest;
+    store?: SessionStore;
+    onSettled?: (txHash: string, amount: string, mode: string) => Promise<void>;
+}
+declare function createMppChargeHandler(opts: MppChargeHandlerOptions): RequestHandler;
+
+type Network = 'testnet' | 'mainnet';
+interface MppSessionHandlerOptions {
+    payeeSecretKey: string;
+    network: Network;
+    channelContract: string;
+    rate: string;
+    assetContract: string;
+    manifest: RouteDockManifest;
+    commitmentPublicKey: string;
+    onSettled?: (txHash: string, totalPaid: string, mode: string) => Promise<void>;
+}
+declare function createMppSessionHandler(opts: MppSessionHandlerOptions): RequestHandler;
+
+export { type MppChargeHandlerOptions, type MppSessionHandlerOptions, RouteDockManifest, SessionStore, type X402HandlerOptions, createMppChargeHandler, createMppSessionHandler, createX402Handler };