@invago/mixin 1.0.9 → 1.0.10

package/src/mixpay-service.ts

@@ -0,0 +1,211 @@
+import crypto from "node:crypto";
+import axios from "axios";
+import type { MixinMixpayConfig } from "./config-schema.js";
+import type { MixpayOrderStatus } from "./mixpay-store.js";
+
+const DEFAULT_API_BASE_URL = "https://api.mixpay.me/v1";
+
+export type CreateMixpayPaymentInput = {
+  config: MixinMixpayConfig;
+  orderId?: string;
+  quoteAmount: string;
+  quoteAssetId: string;
+  settlementAssetId?: string;
+  memo?: string;
+  expireMinutes?: number;
+};
+
+export type MixpayCreateResult = {
+  orderId: string;
+  traceId: string;
+  paymentId?: string;
+  code?: string;
+  paymentUrl?: string;
+  createdAt: string;
+  expireAt?: string;
+  raw: Record<string, unknown>;
+};
+
+export type MixpayPaymentResult = {
+  orderId: string;
+  traceId?: string;
+  payeeId?: string;
+  quoteAssetId?: string;
+  quoteAmount?: string;
+  settlementAssetId?: string;
+  status: MixpayOrderStatus;
+  rawStatus: string;
+  settleStatus?: string;
+  raw: Record<string, unknown>;
+};
+
+function resolveApiBaseUrl(config: MixinMixpayConfig): string {
+  return (config.apiBaseUrl?.trim() || DEFAULT_API_BASE_URL).replace(/\/+$/, "");
+}
+
+function generateShortId(): string {
+  return crypto.randomBytes(5).toString("hex");
+}
+
+export function createMixpayOrderId(): string {
+  return `mixpay_${Date.now()}_${generateShortId()}`;
+}
+
+export function createMixpayTraceId(): string {
+  return crypto.randomUUID();
+}
+
+function normalizeAmount(value: string): string {
+  const normalized = value.trim();
+  if (!normalized || !/^\d+(\.\d+)?$/.test(normalized)) {
+    throw new Error("invalid MixPay quote amount");
+  }
+  return normalized;
+}
+
+function mapMixpayStatus(rawStatus: string, settleStatus?: string, quoteAmount?: string, paidAmount?: string): MixpayOrderStatus {
+  const status = rawStatus.trim().toLowerCase();
+  if (status === "success" && settleStatus?.trim().toLowerCase() === "success") {
+    return "success";
+  }
+  if (status === "success") {
+    return "pending";
+  }
+  if (status === "pending") {
+    return "pending";
+  }
+  if (status === "unpaid") {
+    return "unpaid";
+  }
+  if (status === "failed" || status === "fail") {
+    return "failed";
+  }
+  if (status === "expired") {
+    return "expired";
+  }
+  if (quoteAmount && paidAmount) {
+    const expected = Number.parseFloat(quoteAmount);
+    const actual = Number.parseFloat(paidAmount);
+    if (Number.isFinite(expected) && Number.isFinite(actual) && actual < expected) {
+      return "paid_less";
+    }
+  }
+  return "unknown";
+}
+
+function extractString(obj: Record<string, unknown>, ...keys: string[]): string | undefined {
+  for (const key of keys) {
+    const value = obj[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return undefined;
+}
+
+function extractDataRecord(payload: unknown): Record<string, unknown> {
+  if (payload && typeof payload === "object") {
+    const record = payload as Record<string, unknown>;
+    const nested = record.data;
+    if (nested && typeof nested === "object") {
+      return nested as Record<string, unknown>;
+    }
+    return record;
+  }
+  return {};
+}
+
+export async function createMixpayPayment(input: CreateMixpayPaymentInput): Promise<MixpayCreateResult> {
+  if (!input.config.enabled) {
+    throw new Error("MixPay is disabled");
+  }
+  if (!input.config.payeeId?.trim()) {
+    throw new Error("MixPay payeeId is not configured");
+  }
+
+  const orderId = input.orderId?.trim() || createMixpayOrderId();
+  const traceId = createMixpayTraceId();
+  const quoteAmount = normalizeAmount(input.quoteAmount);
+  const quoteAssetId = input.quoteAssetId.trim();
+  if (!quoteAssetId) {
+    throw new Error("MixPay quoteAssetId is not configured");
+  }
+  const settlementAssetId = input.settlementAssetId?.trim() || input.config.defaultSettlementAssetId?.trim();
+  const expireMinutes = Math.max(1, Math.floor(input.expireMinutes ?? input.config.expireMinutes ?? 15));
+  const expiredTimestamp = Date.now() + expireMinutes * 60 * 1000;
+
+  const body = new URLSearchParams();
+  body.set("payeeId", input.config.payeeId.trim());
+  body.set("orderId", orderId);
+  body.set("traceId", traceId);
+  body.set("quoteAssetId", quoteAssetId);
+  body.set("quoteAmount", quoteAmount);
+  body.set("expiredTimestamp", String(expiredTimestamp));
+  if (settlementAssetId) {
+    body.set("settlementAssetId", settlementAssetId);
+  }
+  if (input.memo?.trim()) {
+    body.set("memo", input.memo.trim());
+  }
+
+  const response = await axios.post(`${resolveApiBaseUrl(input.config)}/one_time_payment`, body, {
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+    },
+    timeout: 20_000,
+  });
+
+  const data = extractDataRecord(response.data);
+  const code = extractString(data, "code");
+  const paymentId = extractString(data, "paymentId", "payment_id", "id");
+  const paymentUrl = code ? `https://mixpay.me/code/${code}` : extractString(data, "paymentUrl", "payment_url", "url");
+  const createdAt = new Date().toISOString();
+
+  return {
+    orderId,
+    traceId,
+    paymentId,
+    code,
+    paymentUrl,
+    createdAt,
+    expireAt: new Date(expiredTimestamp).toISOString(),
+    raw: data,
+  };
+}
+
+export async function getMixpayPaymentResult(params: {
+  config: MixinMixpayConfig;
+  orderId: string;
+  traceId?: string;
+}): Promise<MixpayPaymentResult> {
+  if (!params.config.enabled) {
+    throw new Error("MixPay is disabled");
+  }
+
+  const response = await axios.get(`${resolveApiBaseUrl(params.config)}/payments_result`, {
+    params: {
+      orderId: params.orderId,
+      traceId: params.traceId,
+    },
+    timeout: 20_000,
+  });
+
+  const data = extractDataRecord(response.data);
+  const rawStatus = extractString(data, "status") ?? "unknown";
+  const settleStatus = extractString(data, "settleStatus", "settle_status");
+  const quoteAmount = extractString(data, "quoteAmount", "quote_amount");
+  const paidAmount = extractString(data, "baseAmount", "base_amount", "paidAmount", "paid_amount");
+
+  return {
+    orderId: extractString(data, "orderId", "order_id") ?? params.orderId,
+    traceId: extractString(data, "traceId", "trace_id") ?? params.traceId,
+    payeeId: extractString(data, "payeeId", "payee_id"),
+    quoteAssetId: extractString(data, "quoteAssetId", "quote_asset_id"),
+    quoteAmount,
+    settlementAssetId: extractString(data, "settlementAssetId", "settlement_asset_id"),
+    status: mapMixpayStatus(rawStatus, settleStatus, quoteAmount, paidAmount),
+    rawStatus,
+    settleStatus,
+    raw: data,
+  };
+}

package/src/mixpay-store.ts

@@ -0,0 +1,205 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { getMixinRuntime } from "./runtime.js";
+
+export type MixpayOrderStatus =
+  | "unpaid"
+  | "pending"
+  | "paid_less"
+  | "success"
+  | "failed"
+  | "expired"
+  | "unknown";
+
+export type MixpayOrderRecord = {
+  orderId: string;
+  traceId: string;
+  paymentId?: string;
+  code?: string;
+  paymentUrl?: string;
+  accountId: string;
+  conversationId: string;
+  recipientId?: string;
+  creatorId: string;
+  quoteAssetId: string;
+  quoteAmount: string;
+  settlementAssetId?: string;
+  memo?: string;
+  status: MixpayOrderStatus;
+  rawStatus?: string;
+  createdAt: string;
+  updatedAt: string;
+  expireAt?: string;
+  lastPolledAt?: string;
+  lastNotifyStatus?: string;
+  latestError?: string;
+};
+
+type MixpayStoreState = {
+  loaded: boolean;
+  persistChain: Promise<void>;
+  orders: MixpayOrderRecord[];
+};
+
+const state: MixpayStoreState = {
+  loaded: false,
+  persistChain: Promise.resolve(),
+  orders: [],
+};
+
+function resolveFallbackStoreDir(env: NodeJS.ProcessEnv = process.env): string {
+  const stateOverride = env.OPENCLAW_STATE_DIR?.trim() || env.CLAWDBOT_STATE_DIR?.trim();
+  if (stateOverride) {
+    return path.join(stateOverride, "mixin");
+  }
+  const openClawHome = env.OPENCLAW_HOME?.trim();
+  if (openClawHome) {
+    return path.join(openClawHome, ".openclaw", "mixin");
+  }
+  return path.join(os.homedir(), ".openclaw", "mixin");
+}
+
+function resolveStoreDir(): string {
+  try {
+    return path.join(getMixinRuntime().state.resolveStateDir(process.env, os.homedir), "mixin");
+  } catch {
+    return resolveFallbackStoreDir();
+  }
+}
+
+function resolveStorePaths(): {
+  storeDir: string;
+  storeFile: string;
+  storeTmpFile: string;
+} {
+  const storeDir = resolveStoreDir();
+  const storeFile = path.join(storeDir, "mixpay-orders.json");
+  return {
+    storeDir,
+    storeFile,
+    storeTmpFile: `${storeFile}.tmp`,
+  };
+}
+
+function normalizeRecord(record: MixpayOrderRecord): MixpayOrderRecord {
+  return {
+    ...record,
+    recipientId: record.recipientId || undefined,
+    paymentId: record.paymentId || undefined,
+    code: record.code || undefined,
+    paymentUrl: record.paymentUrl || undefined,
+    settlementAssetId: record.settlementAssetId || undefined,
+    memo: record.memo || undefined,
+    rawStatus: record.rawStatus || undefined,
+    expireAt: record.expireAt || undefined,
+    lastPolledAt: record.lastPolledAt || undefined,
+    lastNotifyStatus: record.lastNotifyStatus || undefined,
+    latestError: record.latestError || undefined,
+  };
+}
+
+const ORDER_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+const TERMINAL_STATUSES: MixpayOrderStatus[] = ["success", "failed", "expired"];
+
+async function ensureLoaded(): Promise<void> {
+  if (state.loaded) {
+    return;
+  }
+  const { storeFile } = resolveStorePaths();
+  try {
+    const raw = await readFile(storeFile, "utf8");
+    const parsed = JSON.parse(raw) as { orders?: MixpayOrderRecord[] } | MixpayOrderRecord[];
+    const orders = Array.isArray(parsed) ? parsed : Array.isArray(parsed.orders) ? parsed.orders : [];
+    const cutoff = Date.now() - ORDER_RETENTION_MS;
+    state.orders = orders
+      .map(normalizeRecord)
+      .filter((order) => {
+        if (!TERMINAL_STATUSES.includes(order.status)) {
+          return true;
+        }
+        return Date.parse(order.updatedAt) > cutoff;
+      });
+  } catch {
+    state.orders = [];
+  }
+  state.loaded = true;
+}
+
+async function persist(): Promise<void> {
+  const { storeDir, storeFile, storeTmpFile } = resolveStorePaths();
+  await mkdir(storeDir, { recursive: true });
+  const raw = JSON.stringify({ orders: state.orders }, null, 2);
+  await writeFile(storeTmpFile, raw, "utf8");
+  await rename(storeTmpFile, storeFile);
+}
+
+function queuePersist(): Promise<void> {
+  state.persistChain = state.persistChain.then(() => persist());
+  return state.persistChain;
+}
+
+export async function getMixpayStoreSnapshot(): Promise<{
+  storeDir: string;
+  storeFile: string;
+  total: number;
+  pending: number;
+}> {
+  await ensureLoaded();
+  const { storeDir, storeFile } = resolveStorePaths();
+  const pending = state.orders.filter((order) => order.status === "unpaid" || order.status === "pending").length;
+  return {
+    storeDir,
+    storeFile,
+    total: state.orders.length,
+    pending,
+  };
+}
+
+export async function createMixpayOrder(record: MixpayOrderRecord): Promise<MixpayOrderRecord> {
+  await ensureLoaded();
+  state.orders = [normalizeRecord(record), ...state.orders.filter((item) => item.orderId !== record.orderId)];
+  await queuePersist();
+  return record;
+}
+
+export async function updateMixpayOrder(
+  orderId: string,
+  updater: (current: MixpayOrderRecord) => MixpayOrderRecord,
+): Promise<MixpayOrderRecord | null> {
+  await ensureLoaded();
+  const index = state.orders.findIndex((item) => item.orderId === orderId);
+  if (index < 0) {
+    return null;
+  }
+  const next = normalizeRecord(updater(state.orders[index]!));
+  state.orders[index] = next;
+  await queuePersist();
+  return next;
+}
+
+export async function findMixpayOrder(orderId: string): Promise<MixpayOrderRecord | null> {
+  await ensureLoaded();
+  return state.orders.find((item) => item.orderId === orderId) ?? null;
+}
+
+export async function listRecentMixpayOrders(params?: {
+  accountId?: string;
+  conversationId?: string;
+  limit?: number;
+}): Promise<MixpayOrderRecord[]> {
+  await ensureLoaded();
+  const limit = Math.max(1, params?.limit ?? 5);
+  return state.orders
+    .filter((item) => !params?.accountId || item.accountId === params.accountId)
+    .filter((item) => !params?.conversationId || item.conversationId === params.conversationId)
+    .sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt))
+    .slice(0, limit);
+}
+
+export async function listPendingMixpayOrders(): Promise<MixpayOrderRecord[]> {
+  await ensureLoaded();
+  return state.orders
+    .filter((item) => item.status === "unpaid" || item.status === "pending")
+    .sort((a, b) => Date.parse(a.updatedAt) - Date.parse(b.updatedAt));
+}