nolo-cli 0.1.29 → 0.1.31

package/server/handlers/providerRequestIdsHandler.ts

@@ -0,0 +1,105 @@
+import {
+  collectProviderRequestIds,
+  type DeepInfraRequestIdStore,
+} from "../../ai/token/deepinfraRequestIdQuery";
+
+const JSON_HEADERS = {
+  "content-type": "application/json; charset=utf-8",
+};
+
+type ProviderRequestIdsEnv = NodeJS.ProcessEnv & {
+  BILLING_LEDGER_AUDIT_SECRET?: string;
+};
+
+const json = (body: unknown, status = 200) =>
+  new Response(JSON.stringify(body), { status, headers: JSON_HEADERS });
+
+const parseOptionalTimestamp = (value: string | null) => {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  if (/^\d+$/.test(trimmed)) return Number(trimmed);
+  const parsed = Date.parse(trimmed);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`invalid timestamp: ${value}`);
+  }
+  return parsed;
+};
+
+const parseLimit = (value: string | null) => {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return 5000;
+  return Math.min(Math.max(Math.floor(parsed), 1), 10_000);
+};
+
+const resolveDefaultStore = async (): Promise<DeepInfraRequestIdStore> => {
+  const dbModule = await import("../../database/server/db");
+  return dbModule.default as DeepInfraRequestIdStore;
+};
+
+export function createProviderRequestIdsHandler({
+  store,
+  env = process.env,
+  nowMs,
+}: {
+  store?: DeepInfraRequestIdStore;
+  env?: Partial<ProviderRequestIdsEnv>;
+  nowMs?: number;
+} = {}) {
+  return async function handleProviderRequestIds(req: Request) {
+    const expectedSecret = String(env.BILLING_LEDGER_AUDIT_SECRET || "").trim();
+    if (!expectedSecret) {
+      return new Response("Not Found", { status: 404 });
+    }
+
+    const providedSecret =
+      req.headers.get("x-billing-ledger-audit-secret")?.trim() || "";
+    if (providedSecret !== expectedSecret) {
+      return json({ success: false, error: "Unauthorized" }, 401);
+    }
+
+    try {
+      const url = new URL(req.url);
+      const provider = url.searchParams.get("provider")?.trim();
+      if (!provider) throw new Error("provider is required");
+      const now = nowMs ?? Date.now();
+      const untilMs = parseOptionalTimestamp(url.searchParams.get("until")) ?? now;
+      const sinceMs =
+        parseOptionalTimestamp(url.searchParams.get("since")) ?? untilMs - 3600_000;
+      const limit = parseLimit(url.searchParams.get("limit"));
+      const result = await collectProviderRequestIds({
+        store: store ?? (await resolveDefaultStore()),
+        provider,
+        bucketStart: new Date(sinceMs).toISOString(),
+        bucketEnd: new Date(untilMs).toISOString(),
+      });
+      const requestIds = result.requestIds.slice(0, limit);
+      const responseIds = result.responseIds.slice(0, limit);
+      return json({
+        success: true,
+        report: {
+          provider,
+          sinceMs,
+          untilMs,
+          requestIds,
+          responseIds,
+          scannedTokenRecords: result.scannedTokenRecords,
+          matchedTokenRecords: result.matchedTokenRecords,
+          truncated:
+            result.requestIds.length > requestIds.length ||
+            result.responseIds.length > responseIds.length,
+        },
+      });
+    } catch (error) {
+      return json(
+        {
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+        },
+        400
+      );
+    }
+  };
+}
+
+export const handleProviderRequestIds = createProviderRequestIdsHandler();

package/server/handlers/tableAccess.ts

@@ -1,8 +1,10 @@
 import { metaKey } from "../../database/keys";
-import serverDb from "../../database/server/db";
+import { getServerAuthorityStore } from "../../database/server/db";
 import type { TableMeta } from "../../render/table/types";
 import { hasSpaceRole } from "./appSpaceAccess";
 
+const getTableAccessStore = () => getServerAuthorityStore();
+
 export async function canReadTableRows(params: {
   userId: string | null | undefined;
   tenantId: string;
@@ -15,7 +17,9 @@ export async function canReadTableRows(params: {
 
   const tableMeta =
     params.tableMeta ??
-    ((await serverDb.get(metaKey(tenantId, tableId)).catch(() => null)) as TableMeta | null);
+    ((await getTableAccessStore()
+      .get(metaKey(tenantId, tableId))
+      .catch(() => null)) as TableMeta | null);
   const spaceId = typeof tableMeta?.spaceId === "string" ? tableMeta.spaceId.trim() : "";
   if (!spaceId) return false;
 

package/server/handlers/tableToolHandlers.ts

@@ -1,8 +1,11 @@
-import serverDb, { ensureServerDbOpen } from "../../database/server/db";
+import {
+  ensureServerDbOpen,
+  getServerAuthorityStore,
+} from "../../database/server/db";
 import { metaKey, rowKey } from "../../database/keys";
 import { ulid } from "../../database/utils/ulid";
 import { DataType } from "../../create/types";
-import { handleToken } from "../../auth/server/token";
+import { readUserFromRequest } from "../../auth/server/token";
 import {
   applyRowFilters,
   formatKnownColumns,
@@ -13,6 +16,27 @@ import {
 import type { TableColumn, TableMeta } from "../../render/table/types";
 import { assertCanReadTableRows } from "./tableAccess";
 
+const getTableToolStore = () => getServerAuthorityStore();
+const serverDb = {
+  get<T = any>(key: string) {
+    return getTableToolStore().get<T>(key);
+  },
+  put(key: string, value: unknown) {
+    return getTableToolStore().put(key, value);
+  },
+  del(key: string) {
+    return getTableToolStore().del(key);
+  },
+  iterator(options?: {
+    gte?: string;
+    lte?: string;
+    lt?: string;
+    reverse?: boolean;
+  }) {
+    return getTableToolStore().iterator(options);
+  },
+};
+
 const CORS_HEADERS = {
   "Access-Control-Allow-Origin": "*",
   "Access-Control-Allow-Methods": "POST, OPTIONS",
@@ -43,12 +67,7 @@ function jsonResponse(body: unknown, status = 200) {
 }
 
 async function getAuthedUserId(req: Request): Promise<string> {
-  const authReq: any = {
-    headers: {
-      get: (name: string) => req.headers.get(name),
-    },
-  };
-  const user = await handleToken(authReq, {});
+  const user = await readUserFromRequest(req);
   const userId = user?.userId;
   if (!userId) {
     throw new Error("Unauthorized: userId not found");
@@ -60,12 +79,7 @@ async function getOptionalAuthedUserId(req: Request): Promise<string | null> {
   const authHeader = req.headers.get("Authorization");
   if (!authHeader) return null;
 
-  const authReq: any = {
-    headers: {
-      get: (name: string) => req.headers.get(name),
-    },
-  };
-  const user = await handleToken(authReq, {});
+  const user = await readUserFromRequest(req);
   const userId = user?.userId;
   return typeof userId === "string" && userId ? userId : null;
 }

package/server/handlers/userSecretsHandler.ts

@@ -11,7 +11,7 @@
 //   - 前端展示时做掩码处理（前4后4，中间替换为 ****）。
 
 import { authenticateRequest, CORS_HEADERS_AUTH } from "../../auth/utils";
-import serverDb from "../../database/server/db";
+import { getServerAuthorityStore } from "../../database/server/db";
 
 const SECRETS_KEY_PREFIX = "user-secrets-";
 const ENC_PREFIX = "enc:v1:";
@@ -81,11 +81,23 @@ function secretsKey(userId: string): string {
 
 type EncryptedSecretsMap = Record<string, string>; // values 可能是 enc:v1:... 或历史明文
 
+const getUserSecretsStore = () => getServerAuthorityStore();
+
+function isSecretsNotFoundError(error: unknown): boolean {
+  const candidate = error as { code?: string; notFound?: boolean; message?: string } | null;
+  return (
+    candidate?.code === "LEVEL_NOT_FOUND" ||
+    candidate?.notFound === true ||
+    candidate?.message === "NotFound"
+  );
+}
+
 async function loadRawSecrets(userId: string): Promise<EncryptedSecretsMap> {
+  const store = getUserSecretsStore();
   try {
-    return (await serverDb.get(secretsKey(userId))) as EncryptedSecretsMap ?? {};
+    return ((await store.get(secretsKey(userId))) as EncryptedSecretsMap) ?? {};
   } catch (e: any) {
-    if (e.code === "LEVEL_NOT_FOUND") return {};
+    if (isSecretsNotFoundError(e)) return {};
     throw e;
   }
 }
@@ -167,7 +179,7 @@ export async function handleSetUserSecret(req: Request): Promise<Response> {
 
   const raw = await loadRawSecrets(auth.userId);
   raw[key] = await encryptValue(value); // 加密后存储
-  await serverDb.put(secretsKey(auth.userId), raw);
+  await getUserSecretsStore().put(secretsKey(auth.userId), raw);
 
   return jsonOk({ success: true, key, masked: maskValue(value) });
 }
@@ -194,7 +206,7 @@ export async function handleDeleteUserSecret(req: Request): Promise<Response> {
   if (!(key in raw)) return jsonError(404, `密钥 "${key}" 不存在`, "NOT_FOUND");
 
   delete raw[key];
-  await serverDb.put(secretsKey(auth.userId), raw);
+  await getUserSecretsStore().put(secretsKey(auth.userId), raw);
 
   return jsonOk({ success: true, deleted: key });
 }
@@ -207,4 +219,3 @@ export async function getUserSecret(userId: string, key: string): Promise<string
   const secrets = await loadSecrets(userId);
   return secrets[key] ?? null;
 }
-

package/server/handlers/versionHandler.ts

@@ -20,7 +20,7 @@ import {
   type VersionEntityType,
 } from "./versionStore";
 import { saveAppCode, getAppRecord } from "./appSandboxHandler";
-import serverDb from "../../database/server/db";
+import { getServerAuthorityStore } from "../../database/server/db";
 
 const jsonOk = (data: any) =>
   new Response(JSON.stringify(data), {
@@ -36,6 +36,8 @@ const jsonError = (status: number, message: string, code?: string) =>
 
 const VALID_TYPES: VersionEntityType[] = ["app", "doc", "agent"];
 
+const getVersionHandlerStore = () => getServerAuthorityStore();
+
 async function getAuthUserId(req: Request): Promise<string | Response> {
   const tokenPayload = await authenticateRequest(req);
   if (!tokenPayload?.userId) return jsonError(401, "未登录", "UNAUTHORIZED");
@@ -49,13 +51,14 @@ async function checkOwnership(
   type: VersionEntityType,
   entityId: string
 ): Promise<Response | null> {
+  const store = getVersionHandlerStore();
   if (type === "app") {
     const record = await getAppRecord(entityId);
     if (!record) return jsonError(404, "应用不存在", "NOT_FOUND");
     if (record.userId !== userId) return jsonError(403, "无权限", "FORBIDDEN");
   } else if (type === "agent") {
     const agentKey = `agent-${userId}-${entityId}`;
-    const agentRecord = await serverDb.get(agentKey).catch(() => null);
+    const agentRecord = await store.get(agentKey).catch(() => null);
     if (!agentRecord) return jsonError(404, "Agent 不存在或无权限", "NOT_FOUND");
   }
   // doc: 前端自己知道 entityId，只要登录即可
@@ -184,16 +187,18 @@ export async function handleVersionRestore(req: Request): Promise<Response> {
   }
 
   if (type === "agent") {
+    const store = getVersionHandlerStore();
     const agentKey = `agent-${userId}-${entityId}`;
     const restored = { ...record.snapshot, updatedAt: Date.now() };
-    await serverDb.put(agentKey, restored);
+    await store.put(agentKey, restored);
     saveVersion(type, entityId, restored, { createdBy: userId, label: restoreLabel }).catch(() => {});
     return jsonOk({ success: true, message: `Agent 已恢复到版本 ${versionId}` });
   }
 
   if (type === "doc") {
+    const store = getVersionHandlerStore();
     const restored = { ...record.snapshot, updatedAt: Date.now() };
-    await serverDb.put(entityId, restored);
+    await store.put(entityId, restored);
     saveVersion(type, entityId, restored, { createdBy: userId, label: restoreLabel }).catch(() => {});
     return jsonOk({ success: true, message: `文档已恢复到版本 ${versionId}` });
   }

package/server/handlers/versionStore.ts

@@ -5,13 +5,15 @@
 // 扫描某实体的所有版本: prefix range version-{type}-{entityId}-
 // entityType: "app" | "doc" | "agent"
 
-import serverDb from "../../database/server/db";
+import { getServerAuthorityStore } from "../../database/server/db";
 import { ulid } from "ulid";
 
 export type VersionEntityType = "app" | "doc" | "agent";
 
 export const VERSION_PREFIX = "version-";
 
+const getVersionStore = () => getServerAuthorityStore();
+
 export function versionKey(type: VersionEntityType, entityId: string, versionId: string) {
   return `${VERSION_PREFIX}${type}-${entityId}-${versionId}`;
 }
@@ -50,6 +52,7 @@ export async function saveVersion(
     createdAt?: number;
   }
 ): Promise<string> {
+  const store = getVersionStore();
   const versionId = opts.versionId ?? ulid();
   const record: VersionRecord = {
     versionId,
@@ -62,7 +65,7 @@ export async function saveVersion(
     snapshot,
   };
 
-  await serverDb.put(versionKey(type, entityId, versionId), record);
+  await store.put(versionKey(type, entityId, versionId), record);
   pruneVersions(type, entityId).catch(() => {});
   return versionId;
 }
@@ -72,10 +75,11 @@ export async function listVersions(
   type: VersionEntityType,
   entityId: string
 ): Promise<Omit<VersionRecord, "snapshot">[]> {
+  const store = getVersionStore();
   const prefix = versionRangePrefix(type, entityId);
   const results: Omit<VersionRecord, "snapshot">[] = [];
 
-  for await (const [, value] of serverDb.iterator({
+  for await (const [, value] of store.iterator({
     gte: prefix,
     lte: prefix + "\xff",
     reverse: true,
@@ -94,8 +98,9 @@ export async function getVersion(
   entityId: string,
   versionId: string
 ): Promise<VersionRecord | null> {
+  const store = getVersionStore();
   try {
-    return (await serverDb.get(versionKey(type, entityId, versionId))) as VersionRecord;
+    return (await store.get(versionKey(type, entityId, versionId))) as VersionRecord;
   } catch {
     return null;
   }
@@ -106,10 +111,11 @@ export async function pruneVersions(
   type: VersionEntityType,
   entityId: string
 ): Promise<void> {
+  const store = getVersionStore();
   const prefix = versionRangePrefix(type, entityId);
   const allEntries: { key: string; pinned: boolean }[] = [];
 
-  for await (const [key, value] of serverDb.iterator({
+  for await (const [key, value] of store.iterator({
     gte: prefix,
     lte: prefix + "\xff",
   })) {
@@ -120,7 +126,7 @@ export async function pruneVersions(
   if (unpinned.length <= MAX_UNPINNED_VERSIONS) return;
 
   const toDelete = unpinned.slice(0, unpinned.length - MAX_UNPINNED_VERSIONS);
-  await Promise.all(toDelete.map((e) => serverDb.del(e.key)));
+  await Promise.all(toDelete.map((e) => store.del(e.key)));
 }
 
 // ── Pin / Unpin 版本 ──────────────────────────────────────────
@@ -130,6 +136,7 @@ export async function pinVersion(
   versionId: string,
   pinned: boolean
 ): Promise<{ ok: boolean; reason?: string }> {
+  const store = getVersionStore();
   const record = await getVersion(type, entityId, versionId);
   if (!record) return { ok: false, reason: "NOT_FOUND" };
 
@@ -142,7 +149,7 @@ export async function pinVersion(
     }
   }
 
-  await serverDb.put(versionKey(type, entityId, versionId), { ...record, pinned });
+  await store.put(versionKey(type, entityId, versionId), { ...record, pinned });
   return { ok: true };
 }
 
@@ -152,7 +159,7 @@ export async function deleteVersion(
   entityId: string,
   versionId: string
 ): Promise<void> {
-  await serverDb.del(versionKey(type, entityId, versionId));
+  await getVersionStore().del(versionKey(type, entityId, versionId));
 }
 
 // ── 删除实体所有版本（级联清理，entity 删除时调用）──────────
@@ -160,10 +167,11 @@ export async function deleteVersionsForEntity(
   type: VersionEntityType,
   entityId: string
 ): Promise<void> {
+  const store = getVersionStore();
   const prefix = versionRangePrefix(type, entityId);
   const keys: string[] = [];
 
-  for await (const [key] of serverDb.iterator({
+  for await (const [key] of store.iterator({
     gte: prefix,
     lte: prefix + "\xff",
     keys: true,
@@ -172,5 +180,5 @@ export async function deleteVersionsForEntity(
     keys.push(key as string);
   }
 
-  await Promise.all(keys.map((k) => serverDb.del(k)));
+  await Promise.all(keys.map((k) => store.del(k)));
 }

package/server/html/ssrPreload.ts

@@ -1,9 +1,9 @@
 // packages/server/html/ssrPreload.ts
 // 职责：根据当前请求路径预取 SSR 数据，并返回页面级 SEO 覆盖信息。
 
-import { createAppStore } from "../../app/store";
-import serverDb, { ensureServerDbOpen } from "../../database/server/db";
-import { upsertSSREntity } from "../../database/dbSlice";
+import { createAppStore } from "../../app/store";
+import { ensureServerDbOpen, getServerAuthorityStore } from "../../database/server/db";
+import { upsertSSREntity } from "../../database/dbSlice";
 import { fetchPublicAgents } from "../../ai/agent/server/fetchPublicAgents";
 import { setSSRPublicAgents } from "../../ai/agent/agentSlice";
 import { fetchCommunityShares } from "../../share/server/fetchCommunityShares";
@@ -15,6 +15,8 @@ import { DESKTOP_RELEASE_MANIFEST_DB_KEY } from "../../app/constants/desktopRele
 import { readDesktopReleaseManifest } from "./desktopReleaseManifest.server";
 import { noloAgentId } from "../../core/init";
 
+const serverDb = getServerAuthorityStore();
+
 const HOME_PUBLIC_AGENTS_CACHE_TTL_MS = 15 * 1000;
 let cachedHomePublicAgents:
   | {

package/server/payments/crypto/cryptoUsdcBasePaymentProvider.ts

@@ -1,8 +1,7 @@
 import { CORS_HEADERS_AUTH } from "../../../auth/utils";
-import { handleToken } from "../../../auth/server/token";
+import { readUserFromRequest } from "../../../auth/server/token";
 import { isProduction } from "../../../app/utils/env";
-import serverDb from "../../../database/server/db";
-import { createResponse } from "../../createResponse";
+import { getServerAuthorityStore } from "../../../database/server/db";
 import type { PaymentProvider } from "../paymentProvider";
 import {
   assignCryptoUsdcBaseAddress,
@@ -29,7 +28,9 @@ const jsonError = (
   details?: unknown
 ) => jsonResponse({ error: { message, code, details } }, status);
 
-const readDb = async (key: string) => serverDb.get(key).catch(() => null);
+const getCryptoUsdcBaseStore = () => getServerAuthorityStore();
+
+const readDb = async (key: string) => getCryptoUsdcBaseStore().get(key).catch(() => null);
 
 export const handleCryptoUsdcBaseConfig = async () => {
   const config = getCryptoUsdcBaseConfig();
@@ -66,16 +67,18 @@ export const handleCreateCryptoUsdcBaseOrder = async (req: Request) => {
     );
   }
 
-  const authResult = await handleToken(req, createResponse());
-  if (authResult instanceof Response) return authResult;
-  const userId = String(authResult.userId || "");
+  const authResult = await readUserFromRequest(req);
+  const userId = String(authResult?.userId || "");
+  if (!userId) {
+    return jsonError(401, "Authentication required.", "AUTH_REQUIRED");
+  }
 
   const assignment = await assignCryptoUsdcBaseAddress({
     userId,
     addressPool: config.depositAddresses,
     get: readDb,
     put: async (key, value) => {
-      await serverDb.put(key, value);
+      await getCryptoUsdcBaseStore().put(key, value);
     },
   });
   if (!assignment.ok) {

package/server/payments/crypto/cryptoUsdcBaseScanner.ts

@@ -1,5 +1,5 @@
 import { rechargeUserBalance } from "../../../auth/server/recharge";
-import serverDb from "../../../database/server/db";
+import { getServerAuthorityStore } from "../../../database/server/db";
 import {
   getCryptoUsdcBaseConfig,
   parseUsdcUnitsToCredits,
@@ -171,6 +171,8 @@ const processedEventKey = (eventId: string) =>
   `crypto-usdc-base-event-${eventId}`;
 const checkpointKey = "crypto-usdc-base-checkpoint";
 
+const getCryptoUsdcBaseScannerStore = () => getServerAuthorityStore();
+
 const rpcCall = async <T>(
   rpcUrl: string,
   method: string,
@@ -190,7 +192,7 @@ const rpcCall = async <T>(
 
 const getAssignedDepositAddresses = async () => {
   const assignments: DepositAddressAssignment[] = [];
-  const iter = serverDb.iterator({
+  const iter = getCryptoUsdcBaseScannerStore().iterator({
     gte: "crypto-usdc-base-address-",
     lt: "crypto-usdc-base-address-\xff",
   });
@@ -218,7 +220,7 @@ export const scanCryptoUsdcBaseDeposits = async () => {
   const toBlock = currentBlock - config.confirmations;
   if (toBlock <= 0) return { configured: true, fromBlock: null, toBlock, ...emptyStats() };
 
-  const checkpoint = (await serverDb.get(checkpointKey).catch(() => null)) as
+  const checkpoint = (await getCryptoUsdcBaseScannerStore().get(checkpointKey).catch(() => null)) as
     | { lastScannedBlock?: number }
     | null;
   const fromBlock = checkpoint
@@ -245,13 +247,13 @@ export const scanCryptoUsdcBaseDeposits = async () => {
     logs,
     config,
     loadAssignmentByAddress: async (address) =>
-      ((await serverDb.get(addressAssignmentKey(address)).catch(() => null)) as
+      ((await getCryptoUsdcBaseScannerStore().get(addressAssignmentKey(address)).catch(() => null)) as
         | DepositAddressAssignment
         | null),
     hasProcessedEvent: async (eventId) =>
-      Boolean(await serverDb.get(processedEventKey(eventId)).catch(() => null)),
+      Boolean(await getCryptoUsdcBaseScannerStore().get(processedEventKey(eventId)).catch(() => null)),
     recordProcessedEvent: async (event) => {
-      await serverDb.put(processedEventKey(event.eventId), event);
+      await getCryptoUsdcBaseScannerStore().put(processedEventKey(event.eventId), event);
     },
     creditUser: async (event) =>
       rechargeUserBalance(
@@ -262,6 +264,9 @@ export const scanCryptoUsdcBaseDeposits = async () => {
       ),
   });
 
-  await serverDb.put(checkpointKey, { lastScannedBlock: toBlock, updatedAt: Date.now() });
+  await getCryptoUsdcBaseScannerStore().put(checkpointKey, {
+    lastScannedBlock: toBlock,
+    updatedAt: Date.now(),
+  });
   return { configured: true, fromBlock, toBlock, ...stats };
 };

package/server/payments/crypto/cryptoUsdtTronPaymentProvider.ts

@@ -1,8 +1,7 @@
 import { CORS_HEADERS_AUTH } from "../../../auth/utils";
-import { handleToken } from "../../../auth/server/token";
+import { readUserFromRequest } from "../../../auth/server/token";
 import { isProduction } from "../../../app/utils/env";
-import serverDb from "../../../database/server/db";
-import { createResponse } from "../../createResponse";
+import { getServerAuthorityStore } from "../../../database/server/db";
 import type { PaymentProvider } from "../paymentProvider";
 import {
   assignCryptoUsdtTronAddress,
@@ -29,7 +28,9 @@ const jsonError = (
   details?: unknown
 ) => jsonResponse({ error: { message, code, details } }, status);
 
-const readDb = async (key: string) => serverDb.get(key).catch(() => null);
+const getCryptoUsdtTronStore = () => getServerAuthorityStore();
+
+const readDb = async (key: string) => getCryptoUsdtTronStore().get(key).catch(() => null);
 
 export const handleCryptoUsdtTronConfig = async () => {
   const config = getCryptoUsdtTronConfig();
@@ -65,16 +66,18 @@ export const handleCreateCryptoUsdtTronOrder = async (req: Request) => {
     );
   }
 
-  const authResult = await handleToken(req, createResponse());
-  if (authResult instanceof Response) return authResult;
-  const userId = String(authResult.userId || "");
+  const authResult = await readUserFromRequest(req);
+  const userId = String(authResult?.userId || "");
+  if (!userId) {
+    return jsonError(401, "Authentication required.", "AUTH_REQUIRED");
+  }
 
   const assignment = await assignCryptoUsdtTronAddress({
     userId,
     addressPool: config.depositAddresses,
     get: readDb,
     put: async (key, value) => {
-      await serverDb.put(key, value);
+      await getCryptoUsdtTronStore().put(key, value);
     },
   });
   if (!assignment.ok) {

package/server/payments/crypto/cryptoUsdtTronScanner.ts

@@ -1,5 +1,5 @@
 import { rechargeUserBalance } from "../../../auth/server/recharge";
-import serverDb from "../../../database/server/db";
+import { getServerAuthorityStore } from "../../../database/server/db";
 import {
   getCryptoUsdtTronConfig,
   parseUsdtUnitsToCredits,
@@ -98,6 +98,8 @@ const processedEventKey = (eventId: string) =>
   `crypto-usdt-tron-event-${eventId}`;
 const checkpointKey = "crypto-usdt-tron-checkpoint";
 
+const getCryptoUsdtTronScannerStore = () => getServerAuthorityStore();
+
 const getTransferContract = (transfer: TronTransferEvent) =>
   transfer.contract_address || transfer.token_info?.address || "";
 
@@ -186,7 +188,7 @@ export const processCryptoUsdtTronEvents = async (
 
 const getAssignedDepositAddresses = async () => {
   const assignments: DepositAddressAssignment[] = [];
-  const iter = serverDb.iterator({
+  const iter = getCryptoUsdtTronScannerStore().iterator({
     gte: "crypto-usdt-tron-address-",
     lt: "crypto-usdt-tron-address-\xff",
   });
@@ -233,7 +235,7 @@ export const scanCryptoUsdtTronDeposits = async () => {
     };
   }
 
-  const checkpoint = (await serverDb.get(checkpointKey).catch(() => null)) as
+  const checkpoint = (await getCryptoUsdtTronScannerStore().get(checkpointKey).catch(() => null)) as
     | { lastScannedTimestamp?: number }
     | null;
   const fromTimestamp = checkpoint
@@ -275,13 +277,13 @@ export const scanCryptoUsdtTronDeposits = async () => {
         events,
         config,
         loadAssignmentByAddress: async (address) =>
-          ((await serverDb.get(addressAssignmentKey(address)).catch(() => null)) as
+          ((await getCryptoUsdtTronScannerStore().get(addressAssignmentKey(address)).catch(() => null)) as
             | DepositAddressAssignment
             | null),
         hasProcessedEvent: async (eventId) =>
-          Boolean(await serverDb.get(processedEventKey(eventId)).catch(() => null)),
+          Boolean(await getCryptoUsdtTronScannerStore().get(processedEventKey(eventId)).catch(() => null)),
         recordProcessedEvent: async (event) => {
-          await serverDb.put(processedEventKey(event.eventId), event);
+          await getCryptoUsdtTronScannerStore().put(processedEventKey(event.eventId), event);
         },
         creditUser: async (event) =>
           rechargeUserBalance(
@@ -305,7 +307,7 @@ export const scanCryptoUsdtTronDeposits = async () => {
     } while (fingerprint);
   }
 
-  await serverDb.put(checkpointKey, {
+  await getCryptoUsdtTronScannerStore().put(checkpointKey, {
     lastScannedTimestamp: toTimestamp,
     updatedAt: Date.now(),
   });