trustbase-seller-backend 0.7.2 → 0.7.4

package/core/chain-reconcile.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * chain-reconcile.js — 链上 slot 与本地 store_products 对账
+ *
+ * 原则：
+ * - 链上 ACTIVE、本地未标记：自动 recover 本地（仅补链上已有的状态）
+ * - 本地已标记、链上不存在：只告警，不自动删除/清除本地状态
+ * - 链上读失败：显式 degraded，不静默把本地缓存当真
+ */
+
+const ACTIVE = "SLOT_STATUS_ACTIVE";
+
+function ensureTables(db) {
+    db.exec(`
+CREATE TABLE IF NOT EXISTS chain_reconcile_log (
+  id             INTEGER PRIMARY KEY AUTOINCREMENT,
+  sku_id         TEXT NOT NULL DEFAULT '',
+  seller_address TEXT NOT NULL DEFAULT '',
+  action         TEXT NOT NULL,
+  detail         TEXT NOT NULL DEFAULT '',
+  created_at     TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE TABLE IF NOT EXISTS chain_reconcile_state (
+  id             INTEGER PRIMARY KEY CHECK (id = 1),
+  last_run_at    TEXT NOT NULL DEFAULT (datetime('now')),
+  status         TEXT NOT NULL,
+  detail         TEXT NOT NULL DEFAULT ''
+);
+`);
+}
+
+function logItem(db, skuId, seller, action, detail) {
+    db.prepare("INSERT INTO chain_reconcile_log (sku_id, seller_address, action, detail) VALUES (?, ?, ?, ?)")
+        .run(skuId || "", seller || "", action, String(detail || "").slice(0, 800));
+}
+
+function saveState(db, status, detail) {
+    db.prepare(`INSERT OR REPLACE INTO chain_reconcile_state (id, last_run_at, status, detail)
+      VALUES (1, datetime('now'), ?, ?)`).run(status, String(detail || "").slice(0, 1000));
+}
+
+function getChainReconcileStatus(db) {
+    ensureTables(db);
+    return db.prepare("SELECT * FROM chain_reconcile_state WHERE id = 1").get() || null;
+}
+
+async function fetchSlots(lcdUrl, seller) {
+    const url = `${lcdUrl.replace(/\/$/, "")}/oxiaom/trustchain/marketplace/v1/sellers/${encodeURIComponent(seller)}/slots`;
+    const res = await fetch(url, { signal: AbortSignal.timeout(10000) });
+    if (!res.ok) throw new Error(`LCD ${res.status} ${url}`);
+    const body = await res.json();
+    const list = body && body.slots && Array.isArray(body.slots.slots) ? body.slots.slots : [];
+    return list;
+}
+
+function updateLocalFromSlot(db, product, slot) {
+    const createdMs = Number(slot.created_at) > 0 ? Number(slot.created_at) * 1000 : Date.now();
+    db.prepare(`UPDATE store_products SET
+      chain_listed = 1,
+      chain_sku_id = ?,
+      chain_slot_index = ?,
+      chain_stake_per_unit = ?,
+      chain_listed_at = ?
+      WHERE id = ?`)
+        .run(slot.sku_id, Number(slot.slot_index), String(slot.stake_per_unit || ""), createdMs, product.id);
+}
+
+/**
+ * 单次对账。返回 { status, recovered, warnings, errors, checked }。
+ */
+async function runChainReconcile({ db, lcdUrl }) {
+    ensureTables(db);
+    const sellers = db.prepare("SELECT DISTINCT seller_address FROM store_products WHERE seller_address IS NOT NULL AND seller_address != ''").all()
+        .map((r) => r.seller_address);
+    const summary = { status: "success", recovered: 0, warnings: 0, errors: 0, checked: 0 };
+
+    for (const seller of sellers) {
+        let slots;
+        try {
+            slots = await fetchSlots(lcdUrl, seller);
+        } catch (e) {
+            summary.errors += 1;
+            summary.status = "degraded";
+            logItem(db, "", seller, "lcd_error", e.message);
+            continue; // 该卖家的本地数据一律不动
+        }
+
+        const localProducts = db.prepare("SELECT * FROM store_products WHERE seller_address = ?").all(seller);
+        const localBySku = new Map(localProducts.map((p) => [p.id, p]));
+        const activeBySku = new Map(slots.filter((s) => s.status === ACTIVE).map((s) => [s.sku_id, s]));
+
+        for (const p of localProducts) {
+            summary.checked += 1;
+            const slot = activeBySku.get(p.id);
+            if (slot) {
+                const needsRecover = !p.chain_listed || p.chain_sku_id !== slot.sku_id ||
+                    Number(p.chain_slot_index) !== Number(slot.slot_index) ||
+                    String(p.chain_stake_per_unit || "") !== String(slot.stake_per_unit || "");
+                if (needsRecover) {
+                    updateLocalFromSlot(db, p, slot);
+                    summary.recovered += 1;
+                    logItem(db, p.id, seller, "recovered", `slot_index=${slot.slot_index}`);
+                }
+            } else if (p.chain_listed) {
+                summary.warnings += 1;
+                logItem(db, p.id, seller, "chain_missing", "本地 chain_listed=1 但链上无 ACTIVE slot；不自动清理");
+            }
+        }
+
+        // 链上 ACTIVE 但本地完全没有该商品：只记孤儿，不自动创建商品。
+        for (const slot of activeBySku.values()) {
+            if (!localBySku.has(slot.sku_id)) {
+                summary.warnings += 1;
+                logItem(db, slot.sku_id, seller, "orphan_chain_slot", `slot_index=${slot.slot_index}`);
+            }
+        }
+    }
+
+    saveState(db, summary.status, JSON.stringify(summary));
+    return summary;
+}
+
+function startChainReconcile({ db, lcdUrl }) {
+    if (process.env.CHAIN_RECONCILE_ENABLED === "false") return null;
+    const intervalMs = Number(process.env.CHAIN_RECONCILE_INTERVAL_MS || 3600000);
+    let running = false;
+    const tick = async () => {
+        if (running) return;
+        running = true;
+        try {
+            const r = await runChainReconcile({ db, lcdUrl });
+            console.log(`[ChainReconcile] ${r.status}: recovered=${r.recovered} warnings=${r.warnings} errors=${r.errors} checked=${r.checked}`);
+        } catch (e) {
+            console.error("[ChainReconcile] failed:", e.message);
+        } finally {
+            running = false;
+        }
+    };
+    setImmediate(tick);
+    const timer = setInterval(tick, intervalMs);
+    if (timer.unref) timer.unref();
+    return timer;
+}
+
+module.exports = { runChainReconcile, startChainReconcile, getChainReconcileStatus, ensureTables };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trustbase-seller-backend",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "TrustBase Seller Backend (merchant edition) — 商品上链/订单/支付/质押 write API for TrustBase 保障链生态. 单卖家自托管形态: 签名 key 即卖家身份, 私钥不出门.",
   "main": "run-unified.js",
   "bin": {

package/run-unified.js

@@ -53,6 +53,7 @@ exports.startUnifiedServer = startUnifiedServer;
 require('./core/boot-env').loadBootEnv();
 const base_paths_1 = require("./core/paths");
 const chain_write_log_1 = require("./core/chain-write-log");
+const chain_reconcile_1 = require("./core/chain-reconcile");
 const env_1 = require("./utils/env");
 const express_1 = __importDefault(require("express"));
 const cors_1 = __importDefault(require("cors"));
@@ -295,6 +296,11 @@ async function startUnifiedServer() {
     await indexer.start();
     // 2026-10-17 kimi: 初始化上链尝试审计（append-only，独立于幂等表 chain_write_log）。
     chain_write_log_1.initChainWriteLogger(sqliteIndexer.getRawDb());
+    // 2026-10-17 kimi: 启动时 + 定时对账；链上读失败显式 degraded，不静默返回缓存。
+    chain_reconcile_1.startChainReconcile({
+        db: sqliteIndexer.getRawDb(),
+        lcdUrl: process.env.CHAIN_LCD_URL || process.env.LCD_URL || 'http://localhost:1317',
+    });
     // ── F-01 fix: ChainListener 接回 run-unified ──
     // SQLitePlugin.start() 本身不 wire ChainListener (只有 TrustCoinIndexer.start() wire).
     // 原来 run.ts 走 TrustCoinIndexer 所以 listener 自动起来, run-unified 直用
@@ -917,7 +923,13 @@ async function startUnifiedServer() {
     }));
     console.log(`   ✅ Chain RPC/LCD proxy mounted: /rpc -> ${CHAIN_RPC_PROXY_TARGET}, /lcd -> ${CHAIN_LCD_PROXY_TARGET}`);
     // 7.5 静态文件托管（PRD-E §5.1）
-    const webDist = node_path_1.default.resolve(__dirname, '../../web/dist');
+    // 2026-10-17 kimi: 买家 PWA 已内嵌到包内 web/dist；优先包内路径，
+    // 包外 ../../web/dist 仅作老部署兼容，避免“文件装上了却打不开页面”。
+    const webDistCandidates = [
+        node_path_1.default.resolve(__dirname, 'web/dist'),
+        node_path_1.default.resolve(__dirname, '../../web/dist'),
+    ];
+    const webDist = webDistCandidates.find((p) => node_fs_1.default.existsSync(p)) || webDistCandidates[0];
     if (node_fs_1.default.existsSync(webDist)) {
         // index.html 不缓存 (baobei 15442): index.html 引用带 hash 的 assets, 缓存旧版会引旧 hash → 404/旧内容.
         // assets 本身 (带 content hash) 走 maxAge 长缓存.

package/test-chain-reconcile.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * test-chain-reconcile.js — 链上/本地对账离线单测
+ * node --test test-chain-reconcile.js
+ */
+const test = require("node:test");
+const assert = require("node:assert");
+const http = require("http");
+const Database = require("better-sqlite3");
+const { runChainReconcile, getChainReconcileStatus } = require("./core/chain-reconcile");
+
+const SELLER = "tct1seller";
+function makeDb() {
+    const db = new Database(":memory:");
+    db.exec(`CREATE TABLE store_products (
+      id TEXT PRIMARY KEY,
+      seller_address TEXT NOT NULL,
+      title TEXT NOT NULL DEFAULT '',
+      chain_sku_id TEXT,
+      chain_slot_index INTEGER,
+      chain_listed INTEGER NOT NULL DEFAULT 0,
+      chain_listed_at INTEGER,
+      chain_tx_hash TEXT,
+      chain_stake_per_unit TEXT
+    )`);
+    return db;
+}
+function insertProduct(db, id, listed = 0) {
+    db.prepare("INSERT INTO store_products (id, seller_address, title, chain_listed, chain_sku_id, chain_slot_index, chain_stake_per_unit) VALUES (?, ?, ?, ?, ?, ?, ?)")
+        .run(id, SELLER, id, listed, listed ? id : null, listed ? 0 : null, listed ? "3000000" : null);
+}
+function activeSlot(skuId) {
+    return { seller: SELLER, slot_index: "0", sku_id: skuId, status: "SLOT_STATUS_ACTIVE", stake_per_unit: "3000000", created_at: "1790170236" };
+}
+async function startLcd(handler) {
+    const srv = http.createServer((req, res) => {
+        if (req.url.includes("/slots")) {
+            const out = handler(req.url);
+            if (out.error) { res.writeHead(500); return res.end(out.error); }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            return res.end(JSON.stringify({ slots: { slots: out.slots || [] } }));
+        }
+        res.writeHead(404); res.end();
+    });
+    srv.listen(0);
+    await new Promise((r) => srv.once("listening", r));
+    return { srv, url: `http://127.0.0.1:${srv.address().port}` };
+}
+
+test("链上 ACTIVE、本地未标记 → 自动 recover，不补造 txhash", async () => {
+    const db = makeDb(); insertProduct(db, "sku-1", 0);
+    const { srv, url } = await startLcd(() => ({ slots: [activeSlot("sku-1")] }));
+    try {
+        const r = await runChainReconcile({ db, lcdUrl: url });
+        assert.strictEqual(r.status, "success");
+        assert.strictEqual(r.recovered, 1);
+        const p = db.prepare("SELECT * FROM store_products WHERE id = 'sku-1'").get();
+        assert.strictEqual(p.chain_listed, 1);
+        assert.strictEqual(p.chain_slot_index, 0);
+        assert.strictEqual(p.chain_stake_per_unit, "3000000");
+        assert.strictEqual(p.chain_tx_hash, null, "不编造 txhash");
+        assert.strictEqual(db.prepare("SELECT action FROM chain_reconcile_log").get().action, "recovered");
+    } finally { srv.close(); db.close(); }
+});
+
+test("本地已上架、链上无 ACTIVE → 只告警，不自动清理", async () => {
+    const db = makeDb(); insertProduct(db, "sku-1", 1);
+    const { srv, url } = await startLcd(() => ({ slots: [] }));
+    try {
+        const r = await runChainReconcile({ db, lcdUrl: url });
+        assert.strictEqual(r.warnings, 1);
+        assert.strictEqual(db.prepare("SELECT chain_listed FROM store_products WHERE id = 'sku-1'").get().chain_listed, 1);
+        assert.strictEqual(db.prepare("SELECT action FROM chain_reconcile_log").get().action, "chain_missing");
+    } finally { srv.close(); db.close(); }
+});
+
+test("链上读失败 → degraded，本地不被改动", async () => {
+    const db = makeDb(); insertProduct(db, "sku-1", 1);
+    const before = db.prepare("SELECT * FROM store_products WHERE id = 'sku-1'").get();
+    const { srv, url } = await startLcd(() => ({ error: "boom" }));
+    try {
+        const r = await runChainReconcile({ db, lcdUrl: url });
+        assert.strictEqual(r.status, "degraded");
+        const after = db.prepare("SELECT * FROM store_products WHERE id = 'sku-1'").get();
+        assert.deepStrictEqual(after, before);
+        assert.strictEqual(getChainReconcileStatus(db).status, "degraded");
+    } finally { srv.close(); db.close(); }
+});
+
+test("链上孤儿 slot → 只记录，不自动创建商品", async () => {
+    const db = makeDb();
+    insertProduct(db, "other", 0); // 有卖家可查，但没有与 orphan-1 对应的本地商品
+    const { srv, url } = await startLcd(() => ({ slots: [activeSlot("orphan-1")] }));
+    try {
+        const r = await runChainReconcile({ db, lcdUrl: url });
+        assert.strictEqual(r.warnings, 1);
+        assert.strictEqual(db.prepare("SELECT count(*) c FROM store_products WHERE id = 'orphan-1'").get().c, 0);
+        assert.strictEqual(db.prepare("SELECT action FROM chain_reconcile_log").get().action, "orphan_chain_slot");
+    } finally { srv.close(); db.close(); }
+});
+
+test("已经一致 → 不重复 recover", async () => {
+    const db = makeDb(); insertProduct(db, "sku-1", 1);
+    const { srv, url } = await startLcd(() => ({ slots: [activeSlot("sku-1")] }));
+    try {
+        const r = await runChainReconcile({ db, lcdUrl: url });
+        assert.strictEqual(r.recovered, 0);
+    } finally { srv.close(); db.close(); }
+});