chainlesschain 0.81.0 → 0.143.0

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;
+}

package/src/lib/token-tracker.js

@@ -198,3 +198,332 @@ export function getTodayStats(db) {
     startDate: new Date().toISOString().slice(0, 10),
   });
 }
+
+/* ═══════════════════════════════════════════════════════════════
+ * V2 Surface — Token tracker governance layer.
+ * Tracks per-owner budget maturity + per-budget usage-record lifecycle
+ * independent of legacy SQLite token_usage table.
+ * ═══════════════════════════════════════════════════════════════ */
+
+export const BUDGET_MATURITY_V2 = Object.freeze({
+  PLANNING: "planning",
+  ACTIVE: "active",
+  SUSPENDED: "suspended",
+  ARCHIVED: "archived",
+});
+
+export const USAGE_RECORD_LIFECYCLE_V2 = Object.freeze({
+  PENDING: "pending",
+  RECORDED: "recorded",
+  BILLED: "billed",
+  REJECTED: "rejected",
+  REFUNDED: "refunded",
+});
+
+const BUDGET_TRANSITIONS_V2 = new Map([
+  ["planning", new Set(["active", "archived"])],
+  ["active", new Set(["suspended", "archived"])],
+  ["suspended", new Set(["active", "archived"])],
+  ["archived", new Set()],
+]);
+const BUDGET_TERMINALS_V2 = new Set(["archived"]);
+
+const RECORD_TRANSITIONS_V2 = new Map([
+  ["pending", new Set(["recorded", "rejected"])],
+  ["recorded", new Set(["billed", "rejected", "refunded"])],
+  ["billed", new Set()],
+  ["rejected", new Set()],
+  ["refunded", new Set()],
+]);
+const RECORD_TERMINALS_V2 = new Set(["billed", "rejected", "refunded"]);
+
+export const TOKEN_DEFAULT_MAX_ACTIVE_BUDGETS_PER_OWNER = 10;
+export const TOKEN_DEFAULT_MAX_PENDING_RECORDS_PER_BUDGET = 500;
+export const TOKEN_DEFAULT_BUDGET_IDLE_MS = 1000 * 60 * 60 * 24 * 30; // 30 days
+export const TOKEN_DEFAULT_RECORD_STUCK_MS = 1000 * 60 * 60; // 1 hour
+
+const _budgetsV2 = new Map();
+const _recordsV2 = new Map();
+let _maxActiveBudgetsPerOwnerV2 = TOKEN_DEFAULT_MAX_ACTIVE_BUDGETS_PER_OWNER;
+let _maxPendingRecordsPerBudgetV2 =
+  TOKEN_DEFAULT_MAX_PENDING_RECORDS_PER_BUDGET;
+let _budgetIdleMsV2 = TOKEN_DEFAULT_BUDGET_IDLE_MS;
+let _recordStuckMsV2 = TOKEN_DEFAULT_RECORD_STUCK_MS;
+
+function _posIntTokenV2(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 getMaxActiveBudgetsPerOwnerV2() {
+  return _maxActiveBudgetsPerOwnerV2;
+}
+export function setMaxActiveBudgetsPerOwnerV2(n) {
+  _maxActiveBudgetsPerOwnerV2 = _posIntTokenV2(n, "maxActiveBudgetsPerOwner");
+}
+export function getMaxPendingRecordsPerBudgetV2() {
+  return _maxPendingRecordsPerBudgetV2;
+}
+export function setMaxPendingRecordsPerBudgetV2(n) {
+  _maxPendingRecordsPerBudgetV2 = _posIntTokenV2(
+    n,
+    "maxPendingRecordsPerBudget",
+  );
+}
+export function getBudgetIdleMsV2() {
+  return _budgetIdleMsV2;
+}
+export function setBudgetIdleMsV2(n) {
+  _budgetIdleMsV2 = _posIntTokenV2(n, "budgetIdleMs");
+}
+export function getRecordStuckMsV2() {
+  return _recordStuckMsV2;
+}
+export function setRecordStuckMsV2(n) {
+  _recordStuckMsV2 = _posIntTokenV2(n, "recordStuckMs");
+}
+
+export function getActiveBudgetCountV2(ownerId) {
+  let n = 0;
+  for (const b of _budgetsV2.values()) {
+    if (b.ownerId === ownerId && b.status === "active") n += 1;
+  }
+  return n;
+}
+
+export function getPendingRecordCountV2(budgetId) {
+  let n = 0;
+  for (const r of _recordsV2.values()) {
+    if (
+      r.budgetId === budgetId &&
+      (r.status === "pending" || r.status === "recorded")
+    )
+      n += 1;
+  }
+  return n;
+}
+
+function _copyBudgetV2(b) {
+  return { ...b, metadata: { ...b.metadata } };
+}
+function _copyRecordV2(r) {
+  return { ...r, metadata: { ...r.metadata } };
+}
+
+export function registerBudgetV2(
+  id,
+  { ownerId, label, metadata = {}, now = Date.now() } = {},
+) {
+  if (!id || typeof id !== "string") throw new Error("id must be a string");
+  if (!ownerId || typeof ownerId !== "string")
+    throw new Error("ownerId must be a string");
+  if (!label || typeof label !== "string")
+    throw new Error("label must be a string");
+  if (_budgetsV2.has(id)) throw new Error(`budget ${id} already exists`);
+  const b = {
+    id,
+    ownerId,
+    label,
+    status: "planning",
+    createdAt: now,
+    lastSeenAt: now,
+    activatedAt: null,
+    archivedAt: null,
+    metadata: { ...metadata },
+  };
+  _budgetsV2.set(id, b);
+  return _copyBudgetV2(b);
+}
+
+export function getBudgetV2(id) {
+  const b = _budgetsV2.get(id);
+  return b ? _copyBudgetV2(b) : null;
+}
+
+export function listBudgetsV2({ ownerId, status } = {}) {
+  const out = [];
+  for (const b of _budgetsV2.values()) {
+    if (ownerId && b.ownerId !== ownerId) continue;
+    if (status && b.status !== status) continue;
+    out.push(_copyBudgetV2(b));
+  }
+  return out;
+}
+
+export function setBudgetStatusV2(id, next, { now = Date.now() } = {}) {
+  const b = _budgetsV2.get(id);
+  if (!b) throw new Error(`budget ${id} not found`);
+  if (!BUDGET_TRANSITIONS_V2.has(next))
+    throw new Error(`unknown budget status: ${next}`);
+  if (BUDGET_TERMINALS_V2.has(b.status))
+    throw new Error(`budget ${id} is in terminal state ${b.status}`);
+  const allowed = BUDGET_TRANSITIONS_V2.get(b.status);
+  if (!allowed.has(next))
+    throw new Error(`cannot transition budget from ${b.status} to ${next}`);
+  if (next === "active") {
+    if (b.status === "planning") {
+      const count = getActiveBudgetCountV2(b.ownerId);
+      if (count >= _maxActiveBudgetsPerOwnerV2)
+        throw new Error(
+          `owner ${b.ownerId} already at active-budget cap (${_maxActiveBudgetsPerOwnerV2})`,
+        );
+    }
+    if (!b.activatedAt) b.activatedAt = now;
+  }
+  if (next === "archived" && !b.archivedAt) b.archivedAt = now;
+  b.status = next;
+  b.lastSeenAt = now;
+  return _copyBudgetV2(b);
+}
+
+export function activateBudgetV2(id, opts) {
+  return setBudgetStatusV2(id, "active", opts);
+}
+export function suspendBudgetV2(id, opts) {
+  return setBudgetStatusV2(id, "suspended", opts);
+}
+export function archiveBudgetV2(id, opts) {
+  return setBudgetStatusV2(id, "archived", opts);
+}
+
+export function touchBudgetV2(id, { now = Date.now() } = {}) {
+  const b = _budgetsV2.get(id);
+  if (!b) throw new Error(`budget ${id} not found`);
+  b.lastSeenAt = now;
+  return _copyBudgetV2(b);
+}
+
+export function createUsageRecordV2(
+  id,
+  { budgetId, units, metadata = {}, now = Date.now() } = {},
+) {
+  if (!id || typeof id !== "string") throw new Error("id must be a string");
+  if (!budgetId || typeof budgetId !== "string")
+    throw new Error("budgetId must be a string");
+  if (!Number.isFinite(units) || units < 0)
+    throw new Error("units must be a non-negative finite number");
+  if (_recordsV2.has(id)) throw new Error(`record ${id} already exists`);
+  const count = getPendingRecordCountV2(budgetId);
+  if (count >= _maxPendingRecordsPerBudgetV2)
+    throw new Error(
+      `budget ${budgetId} already at pending-record cap (${_maxPendingRecordsPerBudgetV2})`,
+    );
+  const r = {
+    id,
+    budgetId,
+    units,
+    status: "pending",
+    createdAt: now,
+    lastSeenAt: now,
+    recordedAt: null,
+    settledAt: null,
+    metadata: { ...metadata },
+  };
+  _recordsV2.set(id, r);
+  return _copyRecordV2(r);
+}
+
+export function getUsageRecordV2(id) {
+  const r = _recordsV2.get(id);
+  return r ? _copyRecordV2(r) : null;
+}
+
+export function listUsageRecordsV2({ budgetId, status } = {}) {
+  const out = [];
+  for (const r of _recordsV2.values()) {
+    if (budgetId && r.budgetId !== budgetId) continue;
+    if (status && r.status !== status) continue;
+    out.push(_copyRecordV2(r));
+  }
+  return out;
+}
+
+export function setUsageRecordStatusV2(id, next, { now = Date.now() } = {}) {
+  const r = _recordsV2.get(id);
+  if (!r) throw new Error(`record ${id} not found`);
+  if (!RECORD_TRANSITIONS_V2.has(next))
+    throw new Error(`unknown record status: ${next}`);
+  if (RECORD_TERMINALS_V2.has(r.status))
+    throw new Error(`record ${id} is in terminal state ${r.status}`);
+  const allowed = RECORD_TRANSITIONS_V2.get(r.status);
+  if (!allowed.has(next))
+    throw new Error(`cannot transition record from ${r.status} to ${next}`);
+  if (next === "recorded" && !r.recordedAt) r.recordedAt = now;
+  if (RECORD_TERMINALS_V2.has(next) && !r.settledAt) r.settledAt = now;
+  r.status = next;
+  r.lastSeenAt = now;
+  return _copyRecordV2(r);
+}
+
+export function recordUsageV2(id, opts) {
+  return setUsageRecordStatusV2(id, "recorded", opts);
+}
+export function billUsageV2(id, opts) {
+  return setUsageRecordStatusV2(id, "billed", opts);
+}
+export function rejectUsageV2(id, opts) {
+  return setUsageRecordStatusV2(id, "rejected", opts);
+}
+export function refundUsageV2(id, opts) {
+  return setUsageRecordStatusV2(id, "refunded", opts);
+}
+
+export function autoSuspendIdleBudgetsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const b of _budgetsV2.values()) {
+    if (b.status !== "active") continue;
+    if (now - b.lastSeenAt > _budgetIdleMsV2) {
+      b.status = "suspended";
+      b.lastSeenAt = now;
+      flipped.push(_copyBudgetV2(b));
+    }
+  }
+  return flipped;
+}
+
+export function autoRejectStaleRecordsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const r of _recordsV2.values()) {
+    if (r.status !== "pending" && r.status !== "recorded") continue;
+    if (now - r.lastSeenAt > _recordStuckMsV2) {
+      r.status = "rejected";
+      r.lastSeenAt = now;
+      if (!r.settledAt) r.settledAt = now;
+      flipped.push(_copyRecordV2(r));
+    }
+  }
+  return flipped;
+}
+
+export function getTokenTrackerStatsV2() {
+  const budgetsByStatus = {};
+  for (const v of Object.values(BUDGET_MATURITY_V2)) budgetsByStatus[v] = 0;
+  for (const b of _budgetsV2.values()) budgetsByStatus[b.status] += 1;
+
+  const recordsByStatus = {};
+  for (const v of Object.values(USAGE_RECORD_LIFECYCLE_V2))
+    recordsByStatus[v] = 0;
+  for (const r of _recordsV2.values()) recordsByStatus[r.status] += 1;
+
+  return {
+    totalBudgetsV2: _budgetsV2.size,
+    totalRecordsV2: _recordsV2.size,
+    maxActiveBudgetsPerOwner: _maxActiveBudgetsPerOwnerV2,
+    maxPendingRecordsPerBudget: _maxPendingRecordsPerBudgetV2,
+    budgetIdleMs: _budgetIdleMsV2,
+    recordStuckMs: _recordStuckMsV2,
+    budgetsByStatus,
+    recordsByStatus,
+  };
+}
+
+export function _resetStateTokenTrackerV2() {
+  _budgetsV2.clear();
+  _recordsV2.clear();
+  _maxActiveBudgetsPerOwnerV2 = TOKEN_DEFAULT_MAX_ACTIVE_BUDGETS_PER_OWNER;
+  _maxPendingRecordsPerBudgetV2 = TOKEN_DEFAULT_MAX_PENDING_RECORDS_PER_BUDGET;
+  _budgetIdleMsV2 = TOKEN_DEFAULT_BUDGET_IDLE_MS;
+  _recordStuckMsV2 = TOKEN_DEFAULT_RECORD_STUCK_MS;
+}