chainlesschain 0.81.0 → 0.132.0

package/src/lib/universal-runtime.js

@@ -769,3 +769,328 @@ export function _resetState() {
     startedAt: Date.now(),
   };
 }
+
+/* ═════════════════════════════════════════════════════════ *
+ *  Phase 63 V2 — Plugin Maturity + Runtime Task Lifecycle
+ * ═════════════════════════════════════════════════════════ */
+
+export const PLUGIN_MATURITY_V2 = Object.freeze({
+  DRAFT: "draft",
+  ACTIVE: "active",
+  DEPRECATED: "deprecated",
+  RETIRED: "retired",
+});
+
+export const RUNTIME_TASK_V2 = Object.freeze({
+  QUEUED: "queued",
+  RUNNING: "running",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  CANCELED: "canceled",
+});
+
+const PLUGIN_TRANSITIONS_V2 = new Map([
+  ["draft", new Set(["active", "retired"])],
+  ["active", new Set(["deprecated", "retired"])],
+  ["deprecated", new Set(["active", "retired"])],
+]);
+const PLUGIN_TERMINALS_V2 = new Set(["retired"]);
+
+const RUNTIME_TASK_TRANSITIONS_V2 = new Map([
+  ["queued", new Set(["running", "canceled", "failed"])],
+  ["running", new Set(["completed", "failed", "canceled"])],
+]);
+const RUNTIME_TASK_TERMINALS_V2 = new Set(["completed", "failed", "canceled"]);
+
+export const RT_DEFAULT_MAX_ACTIVE_PLUGINS_PER_OWNER = 40;
+export const RT_DEFAULT_MAX_RUNNING_TASKS_PER_OWNER = 5;
+export const RT_DEFAULT_PLUGIN_IDLE_MS = 90 * 86400000; // 90d
+export const RT_DEFAULT_TASK_STUCK_MS = 4 * 3600000; // 4h
+
+let _maxActivePluginsPerOwnerV2 = RT_DEFAULT_MAX_ACTIVE_PLUGINS_PER_OWNER;
+let _maxRunningTasksPerOwnerV2 = RT_DEFAULT_MAX_RUNNING_TASKS_PER_OWNER;
+let _pluginIdleMsV2 = RT_DEFAULT_PLUGIN_IDLE_MS;
+let _taskStuckMsV2 = RT_DEFAULT_TASK_STUCK_MS;
+
+function _positiveIntV2(n, label) {
+  const v = Math.floor(Number(n));
+  if (!Number.isFinite(v) || v <= 0)
+    throw new Error(`${label} must be a positive integer`);
+  return v;
+}
+
+export function getDefaultMaxActivePluginsPerOwnerV2() {
+  return RT_DEFAULT_MAX_ACTIVE_PLUGINS_PER_OWNER;
+}
+export function getMaxActivePluginsPerOwnerV2() {
+  return _maxActivePluginsPerOwnerV2;
+}
+export function setMaxActivePluginsPerOwnerV2(n) {
+  return (_maxActivePluginsPerOwnerV2 = _positiveIntV2(
+    n,
+    "maxActivePluginsPerOwner",
+  ));
+}
+export function getDefaultMaxRunningTasksPerOwnerV2() {
+  return RT_DEFAULT_MAX_RUNNING_TASKS_PER_OWNER;
+}
+export function getMaxRunningTasksPerOwnerV2() {
+  return _maxRunningTasksPerOwnerV2;
+}
+export function setMaxRunningTasksPerOwnerV2(n) {
+  return (_maxRunningTasksPerOwnerV2 = _positiveIntV2(
+    n,
+    "maxRunningTasksPerOwner",
+  ));
+}
+export function getDefaultPluginIdleMsV2() {
+  return RT_DEFAULT_PLUGIN_IDLE_MS;
+}
+export function getPluginIdleMsV2() {
+  return _pluginIdleMsV2;
+}
+export function setPluginIdleMsV2(ms) {
+  return (_pluginIdleMsV2 = _positiveIntV2(ms, "pluginIdleMs"));
+}
+export function getDefaultTaskStuckMsV2() {
+  return RT_DEFAULT_TASK_STUCK_MS;
+}
+export function getTaskStuckMsV2() {
+  return _taskStuckMsV2;
+}
+export function setTaskStuckMsV2(ms) {
+  return (_taskStuckMsV2 = _positiveIntV2(ms, "taskStuckMs"));
+}
+
+const _pluginsV2 = new Map();
+const _runtimeTasksV2 = new Map();
+
+export function registerPluginV2(
+  _db,
+  { pluginId, ownerId, name, version, initialStatus, metadata } = {},
+) {
+  if (!pluginId) throw new Error("pluginId is required");
+  if (!ownerId) throw new Error("ownerId is required");
+  if (_pluginsV2.has(pluginId))
+    throw new Error(`Plugin ${pluginId} already exists`);
+  const status = initialStatus || PLUGIN_MATURITY_V2.DRAFT;
+  if (!Object.values(PLUGIN_MATURITY_V2).includes(status))
+    throw new Error(`Invalid initial status: ${status}`);
+  if (PLUGIN_TERMINALS_V2.has(status))
+    throw new Error(`Cannot register in terminal status: ${status}`);
+  if (status === PLUGIN_MATURITY_V2.ACTIVE) {
+    if (getActivePluginCount(ownerId) >= _maxActivePluginsPerOwnerV2)
+      throw new Error(
+        `Owner ${ownerId} reached active-plugin cap (${_maxActivePluginsPerOwnerV2})`,
+      );
+  }
+  const now = Date.now();
+  const record = {
+    pluginId,
+    ownerId,
+    name: name || "",
+    version: version || "0.0.0",
+    status,
+    metadata: metadata || {},
+    createdAt: now,
+    updatedAt: now,
+    lastInvokedAt: now,
+  };
+  _pluginsV2.set(pluginId, record);
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function getPluginV2(pluginId) {
+  const r = _pluginsV2.get(pluginId);
+  return r ? { ...r, metadata: { ...r.metadata } } : null;
+}
+
+export function setPluginMaturityV2(_db, pluginId, newStatus, patch = {}) {
+  const record = _pluginsV2.get(pluginId);
+  if (!record) throw new Error(`Unknown plugin: ${pluginId}`);
+  if (!Object.values(PLUGIN_MATURITY_V2).includes(newStatus))
+    throw new Error(`Invalid status: ${newStatus}`);
+  const allowed = PLUGIN_TRANSITIONS_V2.get(record.status) || new Set();
+  if (!allowed.has(newStatus))
+    throw new Error(`Invalid transition: ${record.status} -> ${newStatus}`);
+  if (newStatus === PLUGIN_MATURITY_V2.ACTIVE) {
+    if (getActivePluginCount(record.ownerId) >= _maxActivePluginsPerOwnerV2)
+      throw new Error(
+        `Owner ${record.ownerId} reached active-plugin cap (${_maxActivePluginsPerOwnerV2})`,
+      );
+  }
+  record.status = newStatus;
+  record.updatedAt = Date.now();
+  if (patch.reason !== undefined) record.lastReason = patch.reason;
+  if (patch.metadata)
+    record.metadata = { ...record.metadata, ...patch.metadata };
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function activatePluginV2(db, id, reason) {
+  return setPluginMaturityV2(db, id, PLUGIN_MATURITY_V2.ACTIVE, { reason });
+}
+export function deprecatePluginV2(db, id, reason) {
+  return setPluginMaturityV2(db, id, PLUGIN_MATURITY_V2.DEPRECATED, { reason });
+}
+export function retirePluginV2(db, id, reason) {
+  return setPluginMaturityV2(db, id, PLUGIN_MATURITY_V2.RETIRED, { reason });
+}
+
+export function touchPluginInvocation(pluginId) {
+  const record = _pluginsV2.get(pluginId);
+  if (!record) throw new Error(`Unknown plugin: ${pluginId}`);
+  record.lastInvokedAt = Date.now();
+  record.updatedAt = record.lastInvokedAt;
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function enqueueRuntimeTaskV2(
+  _db,
+  { taskId, ownerId, pluginId, kind, metadata } = {},
+) {
+  if (!taskId) throw new Error("taskId is required");
+  if (!ownerId) throw new Error("ownerId is required");
+  if (!pluginId) throw new Error("pluginId is required");
+  if (!kind) throw new Error("kind is required");
+  if (_runtimeTasksV2.has(taskId))
+    throw new Error(`Task ${taskId} already exists`);
+  const now = Date.now();
+  const record = {
+    taskId,
+    ownerId,
+    pluginId,
+    kind,
+    status: RUNTIME_TASK_V2.QUEUED,
+    metadata: metadata || {},
+    createdAt: now,
+    updatedAt: now,
+  };
+  _runtimeTasksV2.set(taskId, record);
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function getRuntimeTaskV2(taskId) {
+  const r = _runtimeTasksV2.get(taskId);
+  return r ? { ...r, metadata: { ...r.metadata } } : null;
+}
+
+export function setRuntimeTaskStatusV2(_db, taskId, newStatus, patch = {}) {
+  const record = _runtimeTasksV2.get(taskId);
+  if (!record) throw new Error(`Unknown task: ${taskId}`);
+  if (!Object.values(RUNTIME_TASK_V2).includes(newStatus))
+    throw new Error(`Invalid status: ${newStatus}`);
+  const allowed = RUNTIME_TASK_TRANSITIONS_V2.get(record.status) || new Set();
+  if (!allowed.has(newStatus))
+    throw new Error(`Invalid transition: ${record.status} -> ${newStatus}`);
+  if (newStatus === RUNTIME_TASK_V2.RUNNING) {
+    if (getRunningTaskCount(record.ownerId) >= _maxRunningTasksPerOwnerV2)
+      throw new Error(
+        `Owner ${record.ownerId} reached running-task cap (${_maxRunningTasksPerOwnerV2})`,
+      );
+    record.startedAt = Date.now();
+  }
+  record.status = newStatus;
+  record.updatedAt = Date.now();
+  if (patch.reason !== undefined) record.lastReason = patch.reason;
+  if (patch.metadata)
+    record.metadata = { ...record.metadata, ...patch.metadata };
+  return { ...record, metadata: { ...record.metadata } };
+}
+
+export function startRuntimeTask(db, id, reason) {
+  return setRuntimeTaskStatusV2(db, id, RUNTIME_TASK_V2.RUNNING, { reason });
+}
+export function completeRuntimeTask(db, id, reason) {
+  return setRuntimeTaskStatusV2(db, id, RUNTIME_TASK_V2.COMPLETED, { reason });
+}
+export function failRuntimeTask(db, id, reason) {
+  return setRuntimeTaskStatusV2(db, id, RUNTIME_TASK_V2.FAILED, { reason });
+}
+export function cancelRuntimeTask(db, id, reason) {
+  return setRuntimeTaskStatusV2(db, id, RUNTIME_TASK_V2.CANCELED, { reason });
+}
+
+export function getActivePluginCount(ownerId) {
+  let n = 0;
+  for (const r of _pluginsV2.values()) {
+    if (r.status !== PLUGIN_MATURITY_V2.ACTIVE) continue;
+    if (ownerId && r.ownerId !== ownerId) continue;
+    n++;
+  }
+  return n;
+}
+
+export function getRunningTaskCount(ownerId) {
+  let n = 0;
+  for (const r of _runtimeTasksV2.values()) {
+    if (r.status !== RUNTIME_TASK_V2.RUNNING) continue;
+    if (ownerId && r.ownerId !== ownerId) continue;
+    n++;
+  }
+  return n;
+}
+
+export function autoRetireIdlePlugins(_db, nowMs) {
+  const now = nowMs ?? Date.now();
+  const flipped = [];
+  for (const r of _pluginsV2.values()) {
+    if (
+      r.status === PLUGIN_MATURITY_V2.ACTIVE ||
+      r.status === PLUGIN_MATURITY_V2.DEPRECATED
+    ) {
+      if (now - r.lastInvokedAt > _pluginIdleMsV2) {
+        r.status = PLUGIN_MATURITY_V2.RETIRED;
+        r.updatedAt = now;
+        r.lastReason = "idle";
+        flipped.push(r.pluginId);
+      }
+    }
+  }
+  return { flipped, count: flipped.length };
+}
+
+export function autoFailStuckRuntimeTasks(_db, nowMs) {
+  const now = nowMs ?? Date.now();
+  const flipped = [];
+  for (const r of _runtimeTasksV2.values()) {
+    if (r.status === RUNTIME_TASK_V2.RUNNING) {
+      const anchor = r.startedAt || r.createdAt;
+      if (now - anchor > _taskStuckMsV2) {
+        r.status = RUNTIME_TASK_V2.FAILED;
+        r.updatedAt = now;
+        r.lastReason = "stuck_timeout";
+        flipped.push(r.taskId);
+      }
+    }
+  }
+  return { flipped, count: flipped.length };
+}
+
+export function getRuntimeStatsV2() {
+  const pluginsByStatus = {};
+  for (const s of Object.values(PLUGIN_MATURITY_V2)) pluginsByStatus[s] = 0;
+  const tasksByStatus = {};
+  for (const s of Object.values(RUNTIME_TASK_V2)) tasksByStatus[s] = 0;
+  for (const r of _pluginsV2.values()) pluginsByStatus[r.status]++;
+  for (const r of _runtimeTasksV2.values()) tasksByStatus[r.status]++;
+  return {
+    totalPluginsV2: _pluginsV2.size,
+    totalTasksV2: _runtimeTasksV2.size,
+    maxActivePluginsPerOwner: _maxActivePluginsPerOwnerV2,
+    maxRunningTasksPerOwner: _maxRunningTasksPerOwnerV2,
+    pluginIdleMs: _pluginIdleMsV2,
+    taskStuckMs: _taskStuckMsV2,
+    pluginsByStatus,
+    tasksByStatus,
+  };
+}
+
+export function _resetStateV2() {
+  _maxActivePluginsPerOwnerV2 = RT_DEFAULT_MAX_ACTIVE_PLUGINS_PER_OWNER;
+  _maxRunningTasksPerOwnerV2 = RT_DEFAULT_MAX_RUNNING_TASKS_PER_OWNER;
+  _pluginIdleMsV2 = RT_DEFAULT_PLUGIN_IDLE_MS;
+  _taskStuckMsV2 = RT_DEFAULT_TASK_STUCK_MS;
+  _pluginsV2.clear();
+  _runtimeTasksV2.clear();
+}

package/src/lib/wallet-manager.js

@@ -346,3 +346,329 @@ export function getWalletSummary(db) {
     transactionCount: txns?.c || 0,
   };
 }
+
+/* ═══════════════════════════════════════════════════════════════
+ * V2 Surface — In-memory wallet-maturity + transaction-lifecycle
+ * layer. Independent of the SQLite tables; tracks wallet
+ * provisioning + tx submission/settlement with caps and auto-flip.
+ * ═══════════════════════════════════════════════════════════════ */
+
+export const WALLET_MATURITY_V2 = Object.freeze({
+  PROVISIONAL: "provisional",
+  ACTIVE: "active",
+  FROZEN: "frozen",
+  RETIRED: "retired",
+});
+
+export const TX_LIFECYCLE_V2 = Object.freeze({
+  PENDING: "pending",
+  SUBMITTED: "submitted",
+  CONFIRMED: "confirmed",
+  FAILED: "failed",
+  REJECTED: "rejected",
+});
+
+const WALLET_TRANSITIONS_V2 = new Map([
+  ["provisional", new Set(["active", "retired"])],
+  ["active", new Set(["frozen", "retired"])],
+  ["frozen", new Set(["active", "retired"])],
+  ["retired", new Set()],
+]);
+const WALLET_TERMINALS_V2 = new Set(["retired"]);
+
+const TX_TRANSITIONS_V2 = new Map([
+  ["pending", new Set(["submitted", "rejected"])],
+  ["submitted", new Set(["confirmed", "failed"])],
+  ["confirmed", new Set()],
+  ["failed", new Set()],
+  ["rejected", new Set()],
+]);
+const TX_TERMINALS_V2 = new Set(["confirmed", "failed", "rejected"]);
+
+export const WALLET_DEFAULT_MAX_ACTIVE_WALLETS_PER_OWNER = 10;
+export const WALLET_DEFAULT_MAX_PENDING_TX_PER_WALLET = 25;
+export const WALLET_DEFAULT_WALLET_IDLE_MS = 1000 * 60 * 60 * 24 * 180; // 180 days
+export const WALLET_DEFAULT_TX_STUCK_MS = 1000 * 60 * 60 * 24; // 1 day
+
+const _walletsV2 = new Map();
+const _txsV2 = new Map();
+let _maxActiveWalletsPerOwnerV2 = WALLET_DEFAULT_MAX_ACTIVE_WALLETS_PER_OWNER;
+let _maxPendingTxPerWalletV2 = WALLET_DEFAULT_MAX_PENDING_TX_PER_WALLET;
+let _walletIdleMsV2 = WALLET_DEFAULT_WALLET_IDLE_MS;
+let _txStuckMsV2 = WALLET_DEFAULT_TX_STUCK_MS;
+
+function _posIntWalletV2(n, label) {
+  const v = Math.floor(Number(n));
+  if (!Number.isFinite(v) || v <= 0)
+    throw new Error(`${label} must be a positive integer`);
+  return v;
+}
+
+export function getMaxActiveWalletsPerOwnerV2() {
+  return _maxActiveWalletsPerOwnerV2;
+}
+export function setMaxActiveWalletsPerOwnerV2(n) {
+  _maxActiveWalletsPerOwnerV2 = _posIntWalletV2(n, "maxActiveWalletsPerOwner");
+}
+export function getMaxPendingTxPerWalletV2() {
+  return _maxPendingTxPerWalletV2;
+}
+export function setMaxPendingTxPerWalletV2(n) {
+  _maxPendingTxPerWalletV2 = _posIntWalletV2(n, "maxPendingTxPerWallet");
+}
+export function getWalletIdleMsV2() {
+  return _walletIdleMsV2;
+}
+export function setWalletIdleMsV2(n) {
+  _walletIdleMsV2 = _posIntWalletV2(n, "walletIdleMs");
+}
+export function getTxStuckMsV2() {
+  return _txStuckMsV2;
+}
+export function setTxStuckMsV2(n) {
+  _txStuckMsV2 = _posIntWalletV2(n, "txStuckMs");
+}
+
+export function getActiveWalletCountV2(owner) {
+  let n = 0;
+  for (const w of _walletsV2.values()) {
+    if (w.owner === owner && w.maturity === "active") n += 1;
+  }
+  return n;
+}
+
+export function getPendingTxCountV2(walletId) {
+  let n = 0;
+  for (const t of _txsV2.values()) {
+    if (
+      t.walletId === walletId &&
+      (t.status === "pending" || t.status === "submitted")
+    )
+      n += 1;
+  }
+  return n;
+}
+
+function _copyWalletV2(w) {
+  return { ...w, metadata: { ...w.metadata } };
+}
+function _copyTxV2(t) {
+  return { ...t, metadata: { ...t.metadata } };
+}
+
+export function registerWalletV2(
+  id,
+  { owner, address, metadata = {}, now = Date.now() } = {},
+) {
+  if (!id || typeof id !== "string") throw new Error("id must be a string");
+  if (!owner || typeof owner !== "string")
+    throw new Error("owner must be a string");
+  if (!address || typeof address !== "string")
+    throw new Error("address must be a string");
+  if (_walletsV2.has(id)) throw new Error(`wallet ${id} already exists`);
+  const w = {
+    id,
+    owner,
+    address,
+    maturity: "provisional",
+    createdAt: now,
+    lastSeenAt: now,
+    activatedAt: null,
+    metadata: { ...metadata },
+  };
+  _walletsV2.set(id, w);
+  return _copyWalletV2(w);
+}
+
+export function getWalletV2(id) {
+  const w = _walletsV2.get(id);
+  return w ? _copyWalletV2(w) : null;
+}
+
+export function listWalletsV2({ owner, maturity } = {}) {
+  const out = [];
+  for (const w of _walletsV2.values()) {
+    if (owner && w.owner !== owner) continue;
+    if (maturity && w.maturity !== maturity) continue;
+    out.push(_copyWalletV2(w));
+  }
+  return out;
+}
+
+export function setWalletMaturityV2(id, next, { now = Date.now() } = {}) {
+  const w = _walletsV2.get(id);
+  if (!w) throw new Error(`wallet ${id} not found`);
+  if (!WALLET_TRANSITIONS_V2.has(next))
+    throw new Error(`unknown wallet maturity: ${next}`);
+  if (WALLET_TERMINALS_V2.has(w.maturity))
+    throw new Error(`wallet ${id} is in terminal state ${w.maturity}`);
+  const allowed = WALLET_TRANSITIONS_V2.get(w.maturity);
+  if (!allowed.has(next))
+    throw new Error(`cannot transition wallet from ${w.maturity} to ${next}`);
+  if (next === "active") {
+    if (w.maturity === "provisional") {
+      const count = getActiveWalletCountV2(w.owner);
+      if (count >= _maxActiveWalletsPerOwnerV2)
+        throw new Error(
+          `owner ${w.owner} already at active-wallet cap (${_maxActiveWalletsPerOwnerV2})`,
+        );
+    }
+    if (!w.activatedAt) w.activatedAt = now;
+  }
+  w.maturity = next;
+  w.lastSeenAt = now;
+  return _copyWalletV2(w);
+}
+
+export function activateWalletV2(id, opts) {
+  return setWalletMaturityV2(id, "active", opts);
+}
+export function freezeWalletV2(id, opts) {
+  return setWalletMaturityV2(id, "frozen", opts);
+}
+export function retireWalletV2(id, opts) {
+  return setWalletMaturityV2(id, "retired", opts);
+}
+
+export function touchWalletV2(id, { now = Date.now() } = {}) {
+  const w = _walletsV2.get(id);
+  if (!w) throw new Error(`wallet ${id} not found`);
+  w.lastSeenAt = now;
+  return _copyWalletV2(w);
+}
+
+export function createTxV2(
+  id,
+  { walletId, kind, amount, metadata = {}, now = Date.now() } = {},
+) {
+  if (!id || typeof id !== "string") throw new Error("id must be a string");
+  if (!walletId || typeof walletId !== "string")
+    throw new Error("walletId must be a string");
+  if (!kind || typeof kind !== "string")
+    throw new Error("kind must be a string");
+  if (!_walletsV2.has(walletId))
+    throw new Error(`wallet ${walletId} not found`);
+  if (_txsV2.has(id)) throw new Error(`tx ${id} already exists`);
+  const count = getPendingTxCountV2(walletId);
+  if (count >= _maxPendingTxPerWalletV2)
+    throw new Error(
+      `wallet ${walletId} already at pending-tx cap (${_maxPendingTxPerWalletV2})`,
+    );
+  const t = {
+    id,
+    walletId,
+    kind,
+    amount: amount ?? null,
+    status: "pending",
+    createdAt: now,
+    lastSeenAt: now,
+    submittedAt: null,
+    settledAt: null,
+    metadata: { ...metadata },
+  };
+  _txsV2.set(id, t);
+  return _copyTxV2(t);
+}
+
+export function getTxV2(id) {
+  const t = _txsV2.get(id);
+  return t ? _copyTxV2(t) : null;
+}
+
+export function listTxsV2({ walletId, status } = {}) {
+  const out = [];
+  for (const t of _txsV2.values()) {
+    if (walletId && t.walletId !== walletId) continue;
+    if (status && t.status !== status) continue;
+    out.push(_copyTxV2(t));
+  }
+  return out;
+}
+
+export function setTxStatusV2(id, next, { now = Date.now() } = {}) {
+  const t = _txsV2.get(id);
+  if (!t) throw new Error(`tx ${id} not found`);
+  if (!TX_TRANSITIONS_V2.has(next))
+    throw new Error(`unknown tx status: ${next}`);
+  if (TX_TERMINALS_V2.has(t.status))
+    throw new Error(`tx ${id} is in terminal state ${t.status}`);
+  const allowed = TX_TRANSITIONS_V2.get(t.status);
+  if (!allowed.has(next))
+    throw new Error(`cannot transition tx from ${t.status} to ${next}`);
+  if (next === "submitted" && !t.submittedAt) t.submittedAt = now;
+  if (TX_TERMINALS_V2.has(next) && !t.settledAt) t.settledAt = now;
+  t.status = next;
+  t.lastSeenAt = now;
+  return _copyTxV2(t);
+}
+
+export function submitTxV2(id, opts) {
+  return setTxStatusV2(id, "submitted", opts);
+}
+export function confirmTxV2(id, opts) {
+  return setTxStatusV2(id, "confirmed", opts);
+}
+export function failTxV2(id, opts) {
+  return setTxStatusV2(id, "failed", opts);
+}
+export function rejectTxV2(id, opts) {
+  return setTxStatusV2(id, "rejected", opts);
+}
+
+export function autoRetireIdleWalletsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const w of _walletsV2.values()) {
+    if (w.maturity === "retired" || w.maturity === "provisional") continue;
+    if (now - w.lastSeenAt > _walletIdleMsV2) {
+      w.maturity = "retired";
+      w.lastSeenAt = now;
+      flipped.push(_copyWalletV2(w));
+    }
+  }
+  return flipped;
+}
+
+export function autoFailStuckTxV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const t of _txsV2.values()) {
+    if (t.status !== "submitted") continue;
+    const ref = t.submittedAt ?? t.lastSeenAt;
+    if (now - ref > _txStuckMsV2) {
+      t.status = "failed";
+      t.lastSeenAt = now;
+      if (!t.settledAt) t.settledAt = now;
+      flipped.push(_copyTxV2(t));
+    }
+  }
+  return flipped;
+}
+
+export function getWalletManagerStatsV2() {
+  const walletsByMaturity = {};
+  for (const v of Object.values(WALLET_MATURITY_V2)) walletsByMaturity[v] = 0;
+  for (const w of _walletsV2.values()) walletsByMaturity[w.maturity] += 1;
+
+  const txsByStatus = {};
+  for (const v of Object.values(TX_LIFECYCLE_V2)) txsByStatus[v] = 0;
+  for (const t of _txsV2.values()) txsByStatus[t.status] += 1;
+
+  return {
+    totalWalletsV2: _walletsV2.size,
+    totalTxsV2: _txsV2.size,
+    maxActiveWalletsPerOwner: _maxActiveWalletsPerOwnerV2,
+    maxPendingTxPerWallet: _maxPendingTxPerWalletV2,
+    walletIdleMs: _walletIdleMsV2,
+    txStuckMs: _txStuckMsV2,
+    walletsByMaturity,
+    txsByStatus,
+  };
+}
+
+export function _resetStateWalletManagerV2() {
+  _walletsV2.clear();
+  _txsV2.clear();
+  _maxActiveWalletsPerOwnerV2 = WALLET_DEFAULT_MAX_ACTIVE_WALLETS_PER_OWNER;
+  _maxPendingTxPerWalletV2 = WALLET_DEFAULT_MAX_PENDING_TX_PER_WALLET;
+  _walletIdleMsV2 = WALLET_DEFAULT_WALLET_IDLE_MS;
+  _txStuckMsV2 = WALLET_DEFAULT_TX_STUCK_MS;
+}