@siglume/direct-request-payment 0.4.17 → 0.4.18

package/examples/hosted-checkout-typescript/src/order-store.ts

@@ -0,0 +1,52 @@
+export type OrderStatus = "created" | "pending" | "paid" | "fulfilled_unsettled" | "review_required";
+
+export interface Order {
+  id: string;
+  amount_minor: number;
+  currency: "JPY" | "USD";
+  payment_attempt: number;
+  siglume_challenge_hash?: string;
+  siglume_checkout_session_id?: string;
+  siglume_requirement_id?: string;
+  siglume_chain_receipt_id?: string;
+  siglume_payment_status: OrderStatus;
+}
+
+const orders = new Map<string, Order>([
+  [
+    "order_123",
+    {
+      id: "order_123",
+      amount_minor: 1200,
+      currency: "JPY",
+      payment_attempt: 0,
+      siglume_payment_status: "created",
+    },
+  ],
+]);
+
+const processedWebhookEvents = new Set<string>();
+
+export function getOrder(orderId: string): Order | undefined {
+  return orders.get(orderId);
+}
+
+export function allOrders(): Order[] {
+  return [...orders.values()];
+}
+
+export function saveOrder(order: Order): void {
+  orders.set(order.id, order);
+}
+
+export function findOrderByChallengeHash(challengeHash: string): Order | undefined {
+  return [...orders.values()].find((order) => order.siglume_challenge_hash === challengeHash);
+}
+
+export function markWebhookEventProcessedOnce(eventId: string): boolean {
+  if (processedWebhookEvents.has(eventId)) {
+    return false;
+  }
+  processedWebhookEvents.add(eventId);
+  return true;
+}

package/examples/hosted-checkout-typescript/src/server.ts

@@ -0,0 +1,139 @@
+import "dotenv/config";
+
+import express from "express";
+import {
+  classifyDirectPaymentConfirmation,
+  DirectRequestPaymentMerchantClient,
+  HostedCheckoutNotAvailableError,
+  verifyDirectRequestPaymentWebhook,
+} from "@siglume/direct-request-payment";
+
+import {
+  allOrders,
+  findOrderByChallengeHash,
+  getOrder,
+  markWebhookEventProcessedOnce,
+  saveOrder,
+} from "./order-store.js";
+
+const app = express();
+const port = Number(process.env.PORT || 3000);
+const merchantKey = process.env.SIGLUME_DIRECT_PAYMENT_MERCHANT || "example_merchant";
+const shopOrigin = process.env.SHOP_PUBLIC_ORIGIN || "https://www.example.com";
+
+const siglumeMerchant = new DirectRequestPaymentMerchantClient({
+  auth_token: process.env.SIGLUME_MERCHANT_AUTH_TOKEN,
+});
+
+const asyncRoute =
+  (handler: express.RequestHandler): express.RequestHandler =>
+  (req, res, next) => {
+    Promise.resolve(handler(req, res, next)).catch(next);
+  };
+
+app.get("/orders", (_req, res) => {
+  res.json({ orders: allOrders() });
+});
+
+app.post(
+  "/checkout/siglume/start",
+  express.json(),
+  asyncRoute(async (req, res) => {
+    const orderId = String(req.body?.order_id || "");
+    const order = getOrder(orderId);
+    if (!order) {
+      res.status(404).json({ error: "order_not_found" });
+      return;
+    }
+
+    order.payment_attempt += 1;
+    const session = await siglumeMerchant.createCheckoutSession({
+      merchant: merchantKey,
+      amount_minor: order.amount_minor,
+      currency: order.currency,
+      nonce: `${order.id}-attempt_${order.payment_attempt}`,
+      success_url: `${shopOrigin}/thanks`,
+      cancel_url: `${shopOrigin}/cart`,
+      metadata: { order_id: order.id },
+    });
+
+    order.siglume_challenge_hash = session.challenge_hash;
+    order.siglume_checkout_session_id = session.session_id;
+    order.siglume_payment_status = "pending";
+    saveOrder(order);
+
+    res.json({
+      order_id: order.id,
+      amount_minor: order.amount_minor,
+      currency: order.currency,
+      checkout_url: session.checkout_url,
+      session_id: session.session_id,
+    });
+  }),
+);
+
+app.post(
+  "/siglume/webhook",
+  express.raw({ type: "application/json" }),
+  asyncRoute(async (req, res) => {
+    const { event } = await verifyDirectRequestPaymentWebhook(
+      process.env.SIGLUME_WEBHOOK_SECRET || "",
+      req.body,
+      req.header("siglume-signature") || "",
+    );
+
+    if (!markWebhookEventProcessedOnce(event.id)) {
+      res.status(204).send();
+      return;
+    }
+
+    if (event.type === "direct_payment.confirmed") {
+      const confirmation = classifyDirectPaymentConfirmation(event);
+
+      if (confirmation.kind === "standard_settled") {
+        const order = findOrderByChallengeHash(confirmation.challenge_hash);
+        if (order) {
+          order.siglume_payment_status = "paid";
+          order.siglume_requirement_id = confirmation.requirement_id;
+          order.siglume_chain_receipt_id = confirmation.chain_receipt_id;
+          saveOrder(order);
+        }
+      } else if (confirmation.kind === "metered_usage_accepted") {
+        const order = findOrderByChallengeHash(confirmation.challenge_hash);
+        if (order) {
+          order.siglume_payment_status = "fulfilled_unsettled";
+          order.siglume_requirement_id = confirmation.requirement_id;
+          saveOrder(order);
+        }
+      } else if (confirmation.kind === "metered_batch_settled") {
+        console.info("metered batch settled", {
+          settlement_batch_id: confirmation.settlement_batch_id,
+          chain_receipt_id: confirmation.chain_receipt_id,
+        });
+      } else {
+        console.warn("manual payment review required", {
+          event_id: event.id,
+          reason: confirmation.reason,
+          requirement_id: confirmation.requirement_id,
+        });
+      }
+    }
+
+    res.status(204).send();
+  }),
+);
+
+app.use((error: unknown, _req: express.Request, res: express.Response, _next: express.NextFunction) => {
+  if (error instanceof HostedCheckoutNotAvailableError) {
+    res.status(409).json({ error: "hosted_checkout_not_enabled" });
+    return;
+  }
+  console.error("checkout starter error:", {
+    name: error instanceof Error ? error.name : "Error",
+  });
+  res.status(500).json({ error: "internal_error" });
+});
+
+app.listen(port, () => {
+  console.log(`Siglume Hosted Checkout starter listening on http://localhost:${port}`);
+});

package/examples/hosted-checkout-typescript/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siglume/direct-request-payment",
-  "version": "0.4.17",
+  "version": "0.4.18",
   "description": "SDK for the Siglume Direct Request Payment SDRP payment protocol",
   "keywords": [
     "siglume",
@@ -54,6 +54,9 @@
     "dist",
     "docs",
     "examples",
+    "!examples/**/node_modules",
+    "!examples/**/__pycache__",
+    "!examples/**/*.pyc",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"