chainlesschain 0.81.0 → 0.132.0

package/src/lib/threat-intel.js

@@ -266,3 +266,338 @@ export function clearAll(db) {
   const info = db.prepare(`DELETE FROM threat_intel_indicators`).run();
   return info.changes;
 }
+
+/* ═══════════════════════════════════════════════════════════════
+ * V2 Surface — In-memory feed-maturity + indicator-lifecycle layer.
+ * Independent of the SQLite IoC catalog above; tracks feed sources
+ * and indicator lifecycle transitions with caps and auto-flip.
+ * ═══════════════════════════════════════════════════════════════ */
+
+export const FEED_MATURITY_V2 = Object.freeze({
+  PENDING: "pending",
+  TRUSTED: "trusted",
+  DEPRECATED: "deprecated",
+  RETIRED: "retired",
+});
+
+export const INDICATOR_LIFECYCLE_V2 = Object.freeze({
+  PENDING: "pending",
+  ACTIVE: "active",
+  EXPIRED: "expired",
+  REVOKED: "revoked",
+  SUPERSEDED: "superseded",
+});
+
+const FEED_TRANSITIONS_V2 = new Map([
+  ["pending", new Set(["trusted", "retired"])],
+  ["trusted", new Set(["deprecated", "retired"])],
+  ["deprecated", new Set(["trusted", "retired"])],
+  ["retired", new Set()],
+]);
+const FEED_TERMINALS_V2 = new Set(["retired"]);
+
+const INDICATOR_TRANSITIONS_V2 = new Map([
+  ["pending", new Set(["active", "revoked", "superseded"])],
+  ["active", new Set(["expired", "revoked", "superseded"])],
+  ["expired", new Set()],
+  ["revoked", new Set()],
+  ["superseded", new Set()],
+]);
+const INDICATOR_TERMINALS_V2 = new Set(["expired", "revoked", "superseded"]);
+
+export const TI_DEFAULT_MAX_ACTIVE_FEEDS_PER_OWNER = 15;
+export const TI_DEFAULT_MAX_ACTIVE_INDICATORS_PER_FEED = 500;
+export const TI_DEFAULT_FEED_IDLE_MS = 1000 * 60 * 60 * 24 * 60; // 60 days
+export const TI_DEFAULT_INDICATOR_STALE_MS = 1000 * 60 * 60 * 24 * 90; // 90 days
+
+const _feedsV2 = new Map();
+const _indicatorsV2 = new Map();
+let _maxActiveFeedsPerOwnerV2 = TI_DEFAULT_MAX_ACTIVE_FEEDS_PER_OWNER;
+let _maxActiveIndicatorsPerFeedV2 = TI_DEFAULT_MAX_ACTIVE_INDICATORS_PER_FEED;
+let _feedIdleMsV2 = TI_DEFAULT_FEED_IDLE_MS;
+let _indicatorStaleMsV2 = TI_DEFAULT_INDICATOR_STALE_MS;
+
+function _posIntV2(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 getMaxActiveFeedsPerOwnerV2() {
+  return _maxActiveFeedsPerOwnerV2;
+}
+export function setMaxActiveFeedsPerOwnerV2(n) {
+  _maxActiveFeedsPerOwnerV2 = _posIntV2(n, "maxActiveFeedsPerOwner");
+}
+export function getMaxActiveIndicatorsPerFeedV2() {
+  return _maxActiveIndicatorsPerFeedV2;
+}
+export function setMaxActiveIndicatorsPerFeedV2(n) {
+  _maxActiveIndicatorsPerFeedV2 = _posIntV2(n, "maxActiveIndicatorsPerFeed");
+}
+export function getFeedIdleMsV2() {
+  return _feedIdleMsV2;
+}
+export function setFeedIdleMsV2(n) {
+  _feedIdleMsV2 = _posIntV2(n, "feedIdleMs");
+}
+export function getIndicatorStaleMsV2() {
+  return _indicatorStaleMsV2;
+}
+export function setIndicatorStaleMsV2(n) {
+  _indicatorStaleMsV2 = _posIntV2(n, "indicatorStaleMs");
+}
+
+export function getActiveFeedCountV2(owner) {
+  let n = 0;
+  for (const f of _feedsV2.values()) {
+    if (f.owner === owner && f.maturity === "trusted") n += 1;
+  }
+  return n;
+}
+
+export function getActiveIndicatorCountV2(feedId) {
+  let n = 0;
+  for (const i of _indicatorsV2.values()) {
+    if (i.feedId === feedId && i.status === "active") n += 1;
+  }
+  return n;
+}
+
+function _copyFeedV2(f) {
+  return { ...f, metadata: { ...f.metadata } };
+}
+function _copyIndicatorV2(i) {
+  return { ...i, metadata: { ...i.metadata } };
+}
+
+export function registerFeedV2(id, { owner, name, metadata = {} } = {}) {
+  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 (!name || typeof name !== "string")
+    throw new Error("name must be a string");
+  if (_feedsV2.has(id)) throw new Error(`feed ${id} already exists`);
+  const now = Date.now();
+  const feed = {
+    id,
+    owner,
+    name,
+    maturity: "pending",
+    createdAt: now,
+    lastSeenAt: now,
+    activatedAt: null,
+    metadata: { ...metadata },
+  };
+  _feedsV2.set(id, feed);
+  return _copyFeedV2(feed);
+}
+
+export function getFeedV2(id) {
+  const f = _feedsV2.get(id);
+  return f ? _copyFeedV2(f) : null;
+}
+
+export function listFeedsV2({ owner, maturity } = {}) {
+  const out = [];
+  for (const f of _feedsV2.values()) {
+    if (owner && f.owner !== owner) continue;
+    if (maturity && f.maturity !== maturity) continue;
+    out.push(_copyFeedV2(f));
+  }
+  return out;
+}
+
+export function setFeedMaturityV2(id, next, { now = Date.now() } = {}) {
+  const f = _feedsV2.get(id);
+  if (!f) throw new Error(`feed ${id} not found`);
+  if (!FEED_TRANSITIONS_V2.has(next))
+    throw new Error(`unknown feed maturity: ${next}`);
+  if (FEED_TERMINALS_V2.has(f.maturity))
+    throw new Error(`feed ${id} is in terminal state ${f.maturity}`);
+  const allowed = FEED_TRANSITIONS_V2.get(f.maturity);
+  if (!allowed.has(next))
+    throw new Error(`cannot transition feed from ${f.maturity} to ${next}`);
+  if (next === "trusted") {
+    if (f.maturity === "pending") {
+      const count = getActiveFeedCountV2(f.owner);
+      if (count >= _maxActiveFeedsPerOwnerV2)
+        throw new Error(
+          `owner ${f.owner} already at active-feed cap (${_maxActiveFeedsPerOwnerV2})`,
+        );
+    }
+    if (!f.activatedAt) f.activatedAt = now;
+  }
+  f.maturity = next;
+  f.lastSeenAt = now;
+  return _copyFeedV2(f);
+}
+
+export function trustFeedV2(id, opts) {
+  return setFeedMaturityV2(id, "trusted", opts);
+}
+export function deprecateFeedV2(id, opts) {
+  return setFeedMaturityV2(id, "deprecated", opts);
+}
+export function retireFeedV2(id, opts) {
+  return setFeedMaturityV2(id, "retired", opts);
+}
+
+export function touchFeedV2(id, { now = Date.now() } = {}) {
+  const f = _feedsV2.get(id);
+  if (!f) throw new Error(`feed ${id} not found`);
+  f.lastSeenAt = now;
+  return _copyFeedV2(f);
+}
+
+export function createIndicatorV2(
+  id,
+  { feedId, iocType, value, metadata = {} } = {},
+) {
+  if (!id || typeof id !== "string") throw new Error("id must be a string");
+  if (!feedId || typeof feedId !== "string")
+    throw new Error("feedId must be a string");
+  if (!iocType || typeof iocType !== "string")
+    throw new Error("iocType must be a string");
+  if (!value || typeof value !== "string")
+    throw new Error("value must be a string");
+  if (!_feedsV2.has(feedId)) throw new Error(`feed ${feedId} not found`);
+  if (_indicatorsV2.has(id)) throw new Error(`indicator ${id} already exists`);
+  const now = Date.now();
+  const indicator = {
+    id,
+    feedId,
+    iocType,
+    value,
+    status: "pending",
+    createdAt: now,
+    lastSeenAt: now,
+    activatedAt: null,
+    resolvedAt: null,
+    metadata: { ...metadata },
+  };
+  _indicatorsV2.set(id, indicator);
+  return _copyIndicatorV2(indicator);
+}
+
+export function getIndicatorV2(id) {
+  const i = _indicatorsV2.get(id);
+  return i ? _copyIndicatorV2(i) : null;
+}
+
+export function listIndicatorsV2({ feedId, status } = {}) {
+  const out = [];
+  for (const i of _indicatorsV2.values()) {
+    if (feedId && i.feedId !== feedId) continue;
+    if (status && i.status !== status) continue;
+    out.push(_copyIndicatorV2(i));
+  }
+  return out;
+}
+
+export function setIndicatorStatusV2(id, next, { now = Date.now() } = {}) {
+  const i = _indicatorsV2.get(id);
+  if (!i) throw new Error(`indicator ${id} not found`);
+  if (!INDICATOR_TRANSITIONS_V2.has(next))
+    throw new Error(`unknown indicator status: ${next}`);
+  if (INDICATOR_TERMINALS_V2.has(i.status))
+    throw new Error(`indicator ${id} is in terminal state ${i.status}`);
+  const allowed = INDICATOR_TRANSITIONS_V2.get(i.status);
+  if (!allowed.has(next))
+    throw new Error(`cannot transition indicator from ${i.status} to ${next}`);
+  if (next === "active" && i.status === "pending") {
+    const count = getActiveIndicatorCountV2(i.feedId);
+    if (count >= _maxActiveIndicatorsPerFeedV2)
+      throw new Error(
+        `feed ${i.feedId} already at active-indicator cap (${_maxActiveIndicatorsPerFeedV2})`,
+      );
+    if (!i.activatedAt) i.activatedAt = now;
+  }
+  if (INDICATOR_TERMINALS_V2.has(next) && !i.resolvedAt) {
+    i.resolvedAt = now;
+  }
+  i.status = next;
+  i.lastSeenAt = now;
+  return _copyIndicatorV2(i);
+}
+
+export function activateIndicatorV2(id, opts) {
+  return setIndicatorStatusV2(id, "active", opts);
+}
+export function expireIndicatorV2(id, opts) {
+  return setIndicatorStatusV2(id, "expired", opts);
+}
+export function revokeIndicatorV2(id, opts) {
+  return setIndicatorStatusV2(id, "revoked", opts);
+}
+export function supersedeIndicatorV2(id, opts) {
+  return setIndicatorStatusV2(id, "superseded", opts);
+}
+
+export function refreshIndicatorV2(id, { now = Date.now() } = {}) {
+  const i = _indicatorsV2.get(id);
+  if (!i) throw new Error(`indicator ${id} not found`);
+  if (INDICATOR_TERMINALS_V2.has(i.status))
+    throw new Error(`indicator ${id} is in terminal state ${i.status}`);
+  i.lastSeenAt = now;
+  return _copyIndicatorV2(i);
+}
+
+export function autoDeprecateIdleFeedsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const f of _feedsV2.values()) {
+    if (f.maturity !== "trusted") continue;
+    if (now - f.lastSeenAt > _feedIdleMsV2) {
+      f.maturity = "deprecated";
+      f.lastSeenAt = now;
+      flipped.push(_copyFeedV2(f));
+    }
+  }
+  return flipped;
+}
+
+export function autoExpireStaleIndicatorsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const i of _indicatorsV2.values()) {
+    if (i.status !== "active") continue;
+    if (now - i.lastSeenAt > _indicatorStaleMsV2) {
+      i.status = "expired";
+      i.lastSeenAt = now;
+      if (!i.resolvedAt) i.resolvedAt = now;
+      flipped.push(_copyIndicatorV2(i));
+    }
+  }
+  return flipped;
+}
+
+export function getThreatIntelStatsV2() {
+  const feedsByMaturity = {};
+  for (const m of Object.values(FEED_MATURITY_V2)) feedsByMaturity[m] = 0;
+  for (const f of _feedsV2.values()) feedsByMaturity[f.maturity] += 1;
+
+  const indicatorsByStatus = {};
+  for (const s of Object.values(INDICATOR_LIFECYCLE_V2))
+    indicatorsByStatus[s] = 0;
+  for (const i of _indicatorsV2.values()) indicatorsByStatus[i.status] += 1;
+
+  return {
+    totalFeedsV2: _feedsV2.size,
+    totalIndicatorsV2: _indicatorsV2.size,
+    maxActiveFeedsPerOwner: _maxActiveFeedsPerOwnerV2,
+    maxActiveIndicatorsPerFeed: _maxActiveIndicatorsPerFeedV2,
+    feedIdleMs: _feedIdleMsV2,
+    indicatorStaleMs: _indicatorStaleMsV2,
+    feedsByMaturity,
+    indicatorsByStatus,
+  };
+}
+
+export function _resetStateThreatIntelV2() {
+  _feedsV2.clear();
+  _indicatorsV2.clear();
+  _maxActiveFeedsPerOwnerV2 = TI_DEFAULT_MAX_ACTIVE_FEEDS_PER_OWNER;
+  _maxActiveIndicatorsPerFeedV2 = TI_DEFAULT_MAX_ACTIVE_INDICATORS_PER_FEED;
+  _feedIdleMsV2 = TI_DEFAULT_FEED_IDLE_MS;
+  _indicatorStaleMsV2 = TI_DEFAULT_INDICATOR_STALE_MS;
+}

package/src/lib/token-incentive.js

@@ -511,3 +511,296 @@ export function _resetState() {
   _contributions.clear();
   _seq = 0;
 }
+
+// ═══════════════════════════════════════════════════════════════
+// Phase 66 V2 — Account + Claim lifecycle, per-user claim cap
+// ═══════════════════════════════════════════════════════════════
+
+export const ACCOUNT_STATUS_V2 = Object.freeze({
+  ACTIVE: "active",
+  FROZEN: "frozen",
+  CLOSED: "closed",
+});
+
+export const CLAIM_STATUS_V2 = Object.freeze({
+  PENDING: "pending",
+  APPROVED: "approved",
+  PAID: "paid",
+  REJECTED: "rejected",
+});
+
+export const TOKEN_DEFAULT_MAX_PENDING_CLAIMS_PER_USER = 50;
+export const TOKEN_DEFAULT_CLAIM_EXPIRY_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+export const TOKEN_DEFAULT_MAX_CLAIM_AMOUNT = 10000;
+
+let _maxPendingClaimsPerUser = TOKEN_DEFAULT_MAX_PENDING_CLAIMS_PER_USER;
+let _claimExpiryMs = TOKEN_DEFAULT_CLAIM_EXPIRY_MS;
+let _maxClaimAmount = TOKEN_DEFAULT_MAX_CLAIM_AMOUNT;
+
+const _accountStatesV2 = new Map();
+const _claimStatesV2 = new Map();
+
+const ACCOUNT_TRANSITIONS_V2 = new Map([
+  ["active", new Set(["frozen", "closed"])],
+  ["frozen", new Set(["active", "closed"])],
+]);
+const ACCOUNT_TERMINALS_V2 = new Set(["closed"]);
+
+const CLAIM_TRANSITIONS_V2 = new Map([
+  ["pending", new Set(["approved", "rejected"])],
+  ["approved", new Set(["paid", "rejected"])],
+]);
+const CLAIM_TERMINALS_V2 = new Set(["paid", "rejected"]);
+
+function _positiveInt(n, label) {
+  const v = Number(n);
+  if (!Number.isFinite(v) || v <= 0) {
+    throw new Error(`${label} must be a positive integer`);
+  }
+  return Math.floor(v);
+}
+
+export function setMaxPendingClaimsPerUser(n) {
+  _maxPendingClaimsPerUser = _positiveInt(n, "maxPendingClaimsPerUser");
+  return _maxPendingClaimsPerUser;
+}
+
+export function setClaimExpiryMs(ms) {
+  _claimExpiryMs = _positiveInt(ms, "claimExpiryMs");
+  return _claimExpiryMs;
+}
+
+export function setMaxClaimAmount(n) {
+  const v = Number(n);
+  if (!Number.isFinite(v) || v <= 0) {
+    throw new Error("maxClaimAmount must be a positive number");
+  }
+  _maxClaimAmount = v;
+  return _maxClaimAmount;
+}
+
+export function getMaxPendingClaimsPerUser() {
+  return _maxPendingClaimsPerUser;
+}
+
+export function getClaimExpiryMs() {
+  return _claimExpiryMs;
+}
+
+export function getMaxClaimAmount() {
+  return _maxClaimAmount;
+}
+
+export function getPendingClaimCount(userId) {
+  let count = 0;
+  for (const entry of _claimStatesV2.values()) {
+    if (entry.status === CLAIM_STATUS_V2.PENDING) {
+      if (!userId || entry.userId === userId) count += 1;
+    }
+  }
+  return count;
+}
+
+/* ── Account V2 ─────────────────────────────────────────────── */
+
+export function registerAccountV2(db, { accountId, metadata } = {}) {
+  if (!accountId) throw new Error("accountId is required");
+  if (_accountStatesV2.has(accountId)) {
+    throw new Error(`Account already registered: ${accountId}`);
+  }
+  const now = Date.now();
+  const entry = {
+    accountId,
+    status: ACCOUNT_STATUS_V2.ACTIVE,
+    reason: null,
+    metadata: metadata ? { ...metadata } : {},
+    createdAt: now,
+    updatedAt: now,
+  };
+  _accountStatesV2.set(accountId, entry);
+  return { ...entry };
+}
+
+export function getAccountStatusV2(accountId) {
+  const entry = _accountStatesV2.get(accountId);
+  return entry ? { ...entry } : null;
+}
+
+export function setAccountStatusV2(db, accountId, newStatus, patch = {}) {
+  const entry = _accountStatesV2.get(accountId);
+  if (!entry) throw new Error(`Account not found: ${accountId}`);
+  if (!Object.values(ACCOUNT_STATUS_V2).includes(newStatus)) {
+    throw new Error(`Invalid account status: ${newStatus}`);
+  }
+  if (ACCOUNT_TERMINALS_V2.has(entry.status)) {
+    throw new Error(`Account is terminal: ${entry.status}`);
+  }
+  const allowed = ACCOUNT_TRANSITIONS_V2.get(entry.status) || new Set();
+  if (!allowed.has(newStatus)) {
+    throw new Error(`Invalid transition: ${entry.status} → ${newStatus}`);
+  }
+  entry.status = newStatus;
+  entry.updatedAt = Date.now();
+  if (patch.reason !== undefined) entry.reason = patch.reason;
+  if (patch.metadata) entry.metadata = { ...entry.metadata, ...patch.metadata };
+  return { ...entry };
+}
+
+export function freezeAccount(db, accountId, reason) {
+  return setAccountStatusV2(db, accountId, ACCOUNT_STATUS_V2.FROZEN, {
+    reason,
+  });
+}
+
+export function unfreezeAccount(db, accountId, reason) {
+  return setAccountStatusV2(db, accountId, ACCOUNT_STATUS_V2.ACTIVE, {
+    reason,
+  });
+}
+
+export function closeAccount(db, accountId, reason) {
+  return setAccountStatusV2(db, accountId, ACCOUNT_STATUS_V2.CLOSED, {
+    reason,
+  });
+}
+
+/* ── Claim V2 ───────────────────────────────────────────────── */
+
+export function submitClaimV2(
+  db,
+  { claimId, userId, amount, contributionId, metadata } = {},
+) {
+  if (!claimId) throw new Error("claimId is required");
+  if (!userId) throw new Error("userId is required");
+  const v = Number(amount);
+  if (!Number.isFinite(v) || v <= 0) {
+    throw new Error(`Invalid amount: ${amount} (must be > 0)`);
+  }
+  if (v > _maxClaimAmount) {
+    throw new Error(`Amount exceeds maxClaimAmount: ${v} > ${_maxClaimAmount}`);
+  }
+  if (_claimStatesV2.has(claimId)) {
+    throw new Error(`Claim already registered: ${claimId}`);
+  }
+  // Reject if account exists in V2 state and is frozen/closed
+  const accountEntry = _accountStatesV2.get(userId);
+  if (accountEntry && accountEntry.status !== ACCOUNT_STATUS_V2.ACTIVE) {
+    throw new Error(`Account not active: ${accountEntry.status}`);
+  }
+  // Enforce per-user pending cap
+  const pendingCount = getPendingClaimCount(userId);
+  if (pendingCount >= _maxPendingClaimsPerUser) {
+    throw new Error(
+      `Max pending claims reached (${pendingCount}/${_maxPendingClaimsPerUser}) for user ${userId}`,
+    );
+  }
+  const now = Date.now();
+  const entry = {
+    claimId,
+    userId,
+    amount: v,
+    contributionId: contributionId || null,
+    status: CLAIM_STATUS_V2.PENDING,
+    reason: null,
+    metadata: metadata ? { ...metadata } : {},
+    createdAt: now,
+    updatedAt: now,
+    paidAt: null,
+  };
+  _claimStatesV2.set(claimId, entry);
+  return { ...entry };
+}
+
+export function getClaimStatusV2(claimId) {
+  const entry = _claimStatesV2.get(claimId);
+  return entry ? { ...entry } : null;
+}
+
+export function setClaimStatusV2(db, claimId, newStatus, patch = {}) {
+  const entry = _claimStatesV2.get(claimId);
+  if (!entry) throw new Error(`Claim not found: ${claimId}`);
+  if (!Object.values(CLAIM_STATUS_V2).includes(newStatus)) {
+    throw new Error(`Invalid claim status: ${newStatus}`);
+  }
+  if (CLAIM_TERMINALS_V2.has(entry.status)) {
+    throw new Error(`Claim is terminal: ${entry.status}`);
+  }
+  const allowed = CLAIM_TRANSITIONS_V2.get(entry.status) || new Set();
+  if (!allowed.has(newStatus)) {
+    throw new Error(`Invalid transition: ${entry.status} → ${newStatus}`);
+  }
+  entry.status = newStatus;
+  entry.updatedAt = Date.now();
+  if (newStatus === CLAIM_STATUS_V2.PAID) entry.paidAt = entry.updatedAt;
+  if (patch.reason !== undefined) entry.reason = patch.reason;
+  if (patch.metadata) entry.metadata = { ...entry.metadata, ...patch.metadata };
+  return { ...entry };
+}
+
+export function approveClaim(db, claimId, reason) {
+  return setClaimStatusV2(db, claimId, CLAIM_STATUS_V2.APPROVED, { reason });
+}
+
+export function rejectClaim(db, claimId, reason) {
+  return setClaimStatusV2(db, claimId, CLAIM_STATUS_V2.REJECTED, { reason });
+}
+
+export function payClaim(db, claimId, reason) {
+  return setClaimStatusV2(db, claimId, CLAIM_STATUS_V2.PAID, { reason });
+}
+
+export function autoExpireUnclaimedClaims(db, nowMs = Date.now()) {
+  const expired = [];
+  for (const entry of _claimStatesV2.values()) {
+    if (entry.status !== CLAIM_STATUS_V2.PENDING) continue;
+    if (nowMs - entry.createdAt > _claimExpiryMs) {
+      entry.status = CLAIM_STATUS_V2.REJECTED;
+      entry.reason = "expired";
+      entry.updatedAt = nowMs;
+      expired.push({ ...entry });
+    }
+  }
+  return expired;
+}
+
+/* ── Stats V2 ───────────────────────────────────────────────── */
+
+export function getTokenStatsV2() {
+  const accountsByStatus = { active: 0, frozen: 0, closed: 0 };
+  const claimsByStatus = { pending: 0, approved: 0, paid: 0, rejected: 0 };
+  let totalClaimedAmount = 0;
+  let totalPaidAmount = 0;
+
+  for (const entry of _accountStatesV2.values()) {
+    if (accountsByStatus[entry.status] !== undefined)
+      accountsByStatus[entry.status] += 1;
+  }
+  for (const entry of _claimStatesV2.values()) {
+    if (claimsByStatus[entry.status] !== undefined)
+      claimsByStatus[entry.status] += 1;
+    totalClaimedAmount += entry.amount;
+    if (entry.status === CLAIM_STATUS_V2.PAID) totalPaidAmount += entry.amount;
+  }
+
+  return {
+    totalAccounts: _accountStatesV2.size,
+    totalClaims: _claimStatesV2.size,
+    totalClaimedAmount: Number(totalClaimedAmount.toFixed(4)),
+    totalPaidAmount: Number(totalPaidAmount.toFixed(4)),
+    maxPendingClaimsPerUser: _maxPendingClaimsPerUser,
+    claimExpiryMs: _claimExpiryMs,
+    maxClaimAmount: _maxClaimAmount,
+    accountsByStatus,
+    claimsByStatus,
+  };
+}
+
+/* ── Reset V2 (tests) ───────────────────────────────────────── */
+
+export function _resetStateV2() {
+  _accountStatesV2.clear();
+  _claimStatesV2.clear();
+  _maxPendingClaimsPerUser = TOKEN_DEFAULT_MAX_PENDING_CLAIMS_PER_USER;
+  _claimExpiryMs = TOKEN_DEFAULT_CLAIM_EXPIRY_MS;
+  _maxClaimAmount = TOKEN_DEFAULT_MAX_CLAIM_AMOUNT;
+}