chainlesschain 0.66.0 → 0.81.0

package/src/lib/evomap-governance.js

@@ -248,3 +248,279 @@ export function _resetState() {
   _ownerships.clear();
   _proposals.clear();
 }
+
+/* ═══════════════════════════════════════════════════════════════
+ * V2 Canonical Surface (Phase 42 — EvoMap Advanced Governance)
+ *   Strictly additive; legacy exports above remain unchanged.
+ * ═══════════════════════════════════════════════════════════════ */
+
+export const PROPOSAL_STATUS_V2 = Object.freeze({
+  DRAFT: "draft",
+  ACTIVE: "active",
+  PASSED: "passed",
+  REJECTED: "rejected",
+  EXECUTED: "executed",
+  EXPIRED: "expired",
+  CANCELLED: "cancelled",
+});
+
+export const PROPOSAL_TYPE = Object.freeze({
+  STANDARD: "standard",
+  GENE_STANDARD: "gene_standard",
+  CONFIG_CHANGE: "config_change",
+  DISPUTE: "dispute",
+  FUNDING: "funding",
+});
+
+export const VOTE_DIRECTION = Object.freeze({
+  FOR: "for",
+  AGAINST: "against",
+  ABSTAIN: "abstain",
+});
+
+const _allowedProposalTransitions = new Map([
+  ["draft", new Set(["active", "cancelled"])],
+  ["active", new Set(["passed", "rejected", "expired", "cancelled"])],
+  ["passed", new Set(["executed"])],
+  ["rejected", new Set([])],
+  ["executed", new Set([])],
+  ["expired", new Set([])],
+  ["cancelled", new Set([])],
+]);
+
+export function createGovernanceProposalV2(db, options = {}) {
+  const {
+    title,
+    description,
+    proposerDid,
+    type,
+    votingDurationMs,
+    quorum,
+    threshold,
+  } = options;
+
+  if (!title) throw new Error("Title is required");
+  const proposalType = type || PROPOSAL_TYPE.STANDARD;
+  if (!Object.values(PROPOSAL_TYPE).includes(proposalType)) {
+    throw new Error(`Unknown proposal type: ${proposalType}`);
+  }
+
+  const quorumValue = typeof quorum === "number" ? quorum : 3;
+  const thresholdValue = typeof threshold === "number" ? threshold : 0.5;
+  if (quorumValue < 1) throw new Error("Quorum must be >= 1");
+  if (thresholdValue <= 0 || thresholdValue > 1) {
+    throw new Error("Threshold must be in (0, 1]");
+  }
+
+  const id = crypto.randomUUID();
+  const now = new Date().toISOString();
+  const duration = votingDurationMs || 7 * 24 * 60 * 60 * 1000;
+  const deadline = new Date(Date.now() + duration).toISOString();
+
+  const proposal = {
+    id,
+    title,
+    description: description || "",
+    proposerDid: proposerDid || "anonymous",
+    type: proposalType,
+    status: PROPOSAL_STATUS_V2.ACTIVE,
+    votesFor: 0,
+    votesAgainst: 0,
+    votesAbstain: 0,
+    weightFor: 0,
+    weightAgainst: 0,
+    weightAbstain: 0,
+    quorum: quorumValue,
+    threshold: thresholdValue,
+    votingDeadline: deadline,
+    executedAt: null,
+    createdAt: now,
+  };
+
+  _proposals.set(id, proposal);
+
+  db.prepare(
+    `INSERT INTO evomap_governance_proposals (id, title, description, proposer_did, type, status, votes_for, votes_against, quorum_reached, voting_deadline, executed_at, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    id,
+    proposal.title,
+    proposal.description,
+    proposal.proposerDid,
+    proposal.type,
+    proposal.status,
+    0,
+    0,
+    0,
+    deadline,
+    null,
+    now,
+  );
+
+  return proposal;
+}
+
+export function castVoteV2(db, options = {}) {
+  const { proposalId, voterDid, direction, weight } = options;
+  const proposal = _proposals.get(proposalId);
+  if (!proposal) throw new Error(`Proposal not found: ${proposalId}`);
+  if (proposal.status !== PROPOSAL_STATUS_V2.ACTIVE) {
+    throw new Error(`Proposal is not active: ${proposal.status}`);
+  }
+  if (!Object.values(VOTE_DIRECTION).includes(direction)) {
+    throw new Error(`Unknown vote direction: ${direction}`);
+  }
+  const weightValue = typeof weight === "number" ? weight : 1;
+  if (weightValue <= 0) throw new Error("Vote weight must be positive");
+
+  if (direction === VOTE_DIRECTION.FOR) {
+    proposal.votesFor++;
+    proposal.weightFor += weightValue;
+  } else if (direction === VOTE_DIRECTION.AGAINST) {
+    proposal.votesAgainst++;
+    proposal.weightAgainst += weightValue;
+  } else {
+    proposal.votesAbstain++;
+    proposal.weightAbstain += weightValue;
+  }
+
+  const totalVotes =
+    proposal.votesFor + proposal.votesAgainst + proposal.votesAbstain;
+  const decisiveVotes = proposal.votesFor + proposal.votesAgainst;
+  const decisiveWeight = proposal.weightFor + proposal.weightAgainst;
+
+  if (totalVotes >= proposal.quorum) {
+    const ratio =
+      decisiveWeight === 0 ? 0 : proposal.weightFor / decisiveWeight;
+    if (ratio >= proposal.threshold) {
+      proposal.status = PROPOSAL_STATUS_V2.PASSED;
+    } else {
+      proposal.status = PROPOSAL_STATUS_V2.REJECTED;
+    }
+
+    db.prepare(
+      `UPDATE evomap_governance_proposals SET votes_for = ?, votes_against = ?, quorum_reached = ?, status = ? WHERE id = ?`,
+    ).run(
+      proposal.votesFor,
+      proposal.votesAgainst,
+      1,
+      proposal.status,
+      proposalId,
+    );
+  } else {
+    db.prepare(
+      `UPDATE evomap_governance_proposals SET votes_for = ?, votes_against = ? WHERE id = ?`,
+    ).run(proposal.votesFor, proposal.votesAgainst, proposalId);
+  }
+
+  return {
+    proposalId,
+    direction,
+    weight: weightValue,
+    totalVotes,
+    decisiveVotes,
+    status: proposal.status,
+  };
+}
+
+export function setProposalStatus(db, proposalId, newStatus) {
+  const proposal = _proposals.get(proposalId);
+  if (!proposal) throw new Error(`Proposal not found: ${proposalId}`);
+  const validStatuses = Object.values(PROPOSAL_STATUS_V2);
+  if (!validStatuses.includes(newStatus)) {
+    throw new Error(`Unknown proposal status: ${newStatus}`);
+  }
+  const allowed = _allowedProposalTransitions.get(proposal.status);
+  if (!allowed || !allowed.has(newStatus)) {
+    throw new Error(
+      `Invalid proposal status transition: ${proposal.status} → ${newStatus}`,
+    );
+  }
+  proposal.status = newStatus;
+  if (newStatus === PROPOSAL_STATUS_V2.EXECUTED) {
+    proposal.executedAt = new Date().toISOString();
+  }
+  db.prepare(
+    `UPDATE evomap_governance_proposals SET status = ?, executed_at = ? WHERE id = ?`,
+  ).run(newStatus, proposal.executedAt, proposalId);
+
+  return { proposalId, status: newStatus };
+}
+
+export function executeProposal(db, proposalId) {
+  return setProposalStatus(db, proposalId, PROPOSAL_STATUS_V2.EXECUTED);
+}
+
+export function cancelProposal(db, proposalId) {
+  return setProposalStatus(db, proposalId, PROPOSAL_STATUS_V2.CANCELLED);
+}
+
+export function expireProposalsV2(db, now) {
+  const cutoff = typeof now === "number" ? now : Date.now();
+  const expired = [];
+  for (const p of _proposals.values()) {
+    if (p.status === PROPOSAL_STATUS_V2.ACTIVE) {
+      const deadlineMs = new Date(p.votingDeadline).getTime();
+      if (deadlineMs <= cutoff) {
+        p.status = PROPOSAL_STATUS_V2.EXPIRED;
+        expired.push(p.id);
+        db.prepare(
+          `UPDATE evomap_governance_proposals SET status = ? WHERE id = ?`,
+        ).run(PROPOSAL_STATUS_V2.EXPIRED, p.id);
+      }
+    }
+  }
+  return { expiredCount: expired.length, expiredIds: expired };
+}
+
+export function listProposalsV2(db, filter = {}) {
+  let proposals = [..._proposals.values()];
+  if (filter.status) {
+    proposals = proposals.filter((p) => p.status === filter.status);
+  }
+  if (filter.type) {
+    proposals = proposals.filter((p) => p.type === filter.type);
+  }
+  if (filter.proposerDid) {
+    proposals = proposals.filter((p) => p.proposerDid === filter.proposerDid);
+  }
+  const limit = filter.limit || 100;
+  return proposals.slice(0, limit);
+}
+
+export function traceContributions(geneId) {
+  return traceOwnership(geneId);
+}
+
+export function getGovernanceStatsV2() {
+  const all = [..._proposals.values()];
+
+  const byStatus = {};
+  for (const status of Object.values(PROPOSAL_STATUS_V2)) {
+    byStatus[status] = all.filter((p) => p.status === status).length;
+  }
+
+  const byType = {};
+  for (const type of Object.values(PROPOSAL_TYPE)) {
+    byType[type] = all.filter((p) => p.type === type).length;
+  }
+
+  const totalVotes = all.reduce(
+    (s, p) => s + p.votesFor + p.votesAgainst + (p.votesAbstain || 0),
+    0,
+  );
+  const totalWeight = all.reduce(
+    (s, p) =>
+      s + (p.weightFor || 0) + (p.weightAgainst || 0) + (p.weightAbstain || 0),
+    0,
+  );
+
+  return {
+    totalProposals: all.length,
+    totalOwnerships: _ownerships.size,
+    totalVotes,
+    totalWeight,
+    byStatus,
+    byType,
+  };
+}

package/src/lib/federation-hardening.js

@@ -584,4 +584,263 @@ export function _resetState() {
   _breakers.clear();
   _healthChecks.clear();
   _pools.clear();
+  _nodeStatuses.clear();
+  _failureThreshold = FED_DEFAULT_FAILURE_THRESHOLD;
+  _halfOpenCooldownMs = FED_DEFAULT_HALF_OPEN_COOLDOWN_MS;
+  _unhealthyThreshold = FED_DEFAULT_UNHEALTHY_THRESHOLD;
+  _maxActiveNodes = FED_DEFAULT_MAX_ACTIVE_NODES;
+}
+
+/* ──────────────────────────────────────────────────────────
+ *  V2 — Phase 58 surface (strictly additive)
+ * ────────────────────────────────────────────────────────── */
+
+export const CIRCUIT_STATE_V2 = CIRCUIT_STATE;
+export const HEALTH_STATUS_V2 = HEALTH_STATUS;
+export const HEALTH_METRIC_V2 = HEALTH_METRIC;
+
+export const NODE_STATUS_V2 = Object.freeze({
+  REGISTERED: "registered",
+  ACTIVE: "active",
+  ISOLATED: "isolated",
+  DECOMMISSIONED: "decommissioned",
+});
+
+export const FED_DEFAULT_FAILURE_THRESHOLD = 5;
+export const FED_DEFAULT_HALF_OPEN_COOLDOWN_MS = 60_000;
+export const FED_DEFAULT_UNHEALTHY_THRESHOLD = 3;
+export const FED_DEFAULT_MAX_ACTIVE_NODES = 50;
+
+let _nodeStatuses = new Map();
+let _failureThreshold = FED_DEFAULT_FAILURE_THRESHOLD;
+let _halfOpenCooldownMs = FED_DEFAULT_HALF_OPEN_COOLDOWN_MS;
+let _unhealthyThreshold = FED_DEFAULT_UNHEALTHY_THRESHOLD;
+let _maxActiveNodes = FED_DEFAULT_MAX_ACTIVE_NODES;
+
+const NODE_TRANSITIONS_V2 = new Map([
+  ["registered", new Set(["active", "decommissioned"])],
+  ["active", new Set(["isolated", "decommissioned"])],
+  ["isolated", new Set(["active", "decommissioned"])],
+]);
+const NODE_TERMINALS_V2 = new Set(["decommissioned"]);
+
+/* ── Config ────────────────────────────────────────────── */
+
+function _positiveInt(n, label) {
+  if (typeof n !== "number" || Number.isNaN(n) || n < 1) {
+    throw new Error(`${label} must be a positive integer`);
+  }
+  return Math.floor(n);
+}
+
+export function setFailureThreshold(n) {
+  _failureThreshold = _positiveInt(n, "failureThreshold");
+}
+export function getFailureThreshold() {
+  return _failureThreshold;
+}
+
+export function setHalfOpenCooldownMs(ms) {
+  _halfOpenCooldownMs = _positiveInt(ms, "halfOpenCooldownMs");
+}
+export function getHalfOpenCooldownMs() {
+  return _halfOpenCooldownMs;
+}
+
+export function setUnhealthyThreshold(n) {
+  _unhealthyThreshold = _positiveInt(n, "unhealthyThreshold");
+}
+export function getUnhealthyThreshold() {
+  return _unhealthyThreshold;
+}
+
+export function setMaxActiveNodes(n) {
+  _maxActiveNodes = _positiveInt(n, "maxActiveNodes");
+}
+export function getMaxActiveNodes() {
+  return _maxActiveNodes;
+}
+
+export function getActiveNodeCount() {
+  let count = 0;
+  for (const s of _nodeStatuses.values()) {
+    if (s.status === NODE_STATUS_V2.ACTIVE) count += 1;
+  }
+  return count;
+}
+
+/* ── Node Lifecycle V2 ─────────────────────────────────── */
+
+export function registerNodeV2(db, { nodeId, metadata } = {}) {
+  if (!nodeId) throw new Error("nodeId is required");
+  if (_nodeStatuses.has(nodeId)) {
+    throw new Error(`Node already registered: ${nodeId}`);
+  }
+  const now = _now();
+  const entry = {
+    node_id: nodeId,
+    status: NODE_STATUS_V2.REGISTERED,
+    metadata: metadata || null,
+    registered_at: now,
+    updated_at: now,
+  };
+  _nodeStatuses.set(nodeId, entry);
+
+  if (!_breakers.has(nodeId)) {
+    registerNode(db, nodeId, {
+      failureThreshold: _failureThreshold,
+      openTimeout: _halfOpenCooldownMs,
+      metadata: metadata || null,
+    });
+  }
+  return { ...entry };
+}
+
+export function getNodeStatusV2(nodeId) {
+  const s = _nodeStatuses.get(nodeId);
+  return s ? { ...s } : null;
+}
+
+export function setNodeStatusV2(db, nodeId, newStatus, patch = {}) {
+  const entry = _nodeStatuses.get(nodeId);
+  if (!entry) throw new Error(`Node not found: ${nodeId}`);
+  if (!Object.values(NODE_STATUS_V2).includes(newStatus)) {
+    throw new Error(`Unknown node status: ${newStatus}`);
+  }
+  if (NODE_TERMINALS_V2.has(entry.status)) {
+    throw new Error(
+      `Invalid transition: ${entry.status} → ${newStatus} (terminal)`,
+    );
+  }
+  const allowed = NODE_TRANSITIONS_V2.get(entry.status);
+  if (!allowed || !allowed.has(newStatus)) {
+    throw new Error(`Invalid transition: ${entry.status} → ${newStatus}`);
+  }
+  if (newStatus === NODE_STATUS_V2.ACTIVE) {
+    const active = getActiveNodeCount();
+    if (entry.status !== NODE_STATUS_V2.ACTIVE && active >= _maxActiveNodes) {
+      throw new Error(
+        `Max active nodes reached (${active}/${_maxActiveNodes})`,
+      );
+    }
+  }
+  entry.status = newStatus;
+  entry.updated_at = _now();
+  if (patch.metadata !== undefined) entry.metadata = patch.metadata;
+  if (patch.reason !== undefined) entry.reason = patch.reason;
+  return { ...entry };
+}
+
+/* ── Health Check V2 ───────────────────────────────────── */
+
+const VALID_METRIC_V2 = new Set(Object.values(HEALTH_METRIC_V2));
+const VALID_HEALTH_STATUS_V2 = new Set(Object.values(HEALTH_STATUS_V2));
+
+export function recordHealthCheckV2(
+  db,
+  { nodeId, checkType, status, metrics } = {},
+) {
+  if (!nodeId) throw new Error("nodeId is required");
+  if (!checkType || !VALID_METRIC_V2.has(checkType)) {
+    throw new Error(`Invalid check type: ${checkType}`);
+  }
+  if (!status || !VALID_HEALTH_STATUS_V2.has(status)) {
+    throw new Error(`Invalid status: ${status}`);
+  }
+  if (metrics && typeof metrics === "object") {
+    for (const [k, v] of Object.entries(metrics)) {
+      if (typeof v === "number" && Number.isNaN(v)) {
+        throw new Error(`Metric ${k} is NaN`);
+      }
+    }
+  }
+  const result = recordHealthCheck(db, { nodeId, checkType, status, metrics });
+  if (!result.recorded) throw new Error(`Failed to record: ${result.reason}`);
+  return { ...result };
+}
+
+/* ── Circuit V2 Shortcuts ──────────────────────────────── */
+
+export function tripCircuit(db, nodeId) {
+  const b = _breakers.get(nodeId);
+  if (!b) throw new Error(`Node not found: ${nodeId}`);
+  if (b.state === "open") {
+    throw new Error(`Circuit already open: ${nodeId}`);
+  }
+  const now = _now();
+  b.state = "open";
+  b.state_changed_at = now;
+  b.success_count = 0;
+  b.updated_at = now;
+  db.prepare(
+    `UPDATE federation_circuit_breakers
+     SET state = 'open', success_count = 0, state_changed_at = ?, updated_at = ?
+     WHERE node_id = ?`,
+  ).run(now, now, nodeId);
+  return { state: "open", nodeId };
+}
+
+/* ── Auto-Isolate ──────────────────────────────────────── */
+
+export function autoIsolateUnhealthyNodes(db) {
+  const isolated = [];
+  for (const [nodeId, nodeEntry] of _nodeStatuses.entries()) {
+    if (nodeEntry.status !== NODE_STATUS_V2.ACTIVE) continue;
+    const checks = [..._healthChecks.values()]
+      .filter((c) => c.node_id === nodeId)
+      .sort((a, b) => b.checked_at - a.checked_at)
+      .slice(0, _unhealthyThreshold);
+    if (checks.length < _unhealthyThreshold) continue;
+    const allUnhealthy = checks.every(
+      (c) => c.status === HEALTH_STATUS_V2.UNHEALTHY,
+    );
+    if (allUnhealthy) {
+      nodeEntry.status = NODE_STATUS_V2.ISOLATED;
+      nodeEntry.updated_at = _now();
+      nodeEntry.reason = `auto-isolated: ${_unhealthyThreshold} consecutive unhealthy checks`;
+      isolated.push({ ...nodeEntry });
+    }
+  }
+  return isolated;
+}
+
+/* ── V2 Stats ──────────────────────────────────────────── */
+
+export function getFederationHardeningStatsV2(db) {
+  const circuitsByState = {};
+  for (const s of Object.values(CIRCUIT_STATE_V2)) circuitsByState[s] = 0;
+  for (const b of _breakers.values()) {
+    circuitsByState[b.state] = (circuitsByState[b.state] || 0) + 1;
+  }
+
+  const nodesByStatus = {};
+  for (const s of Object.values(NODE_STATUS_V2)) nodesByStatus[s] = 0;
+  for (const n of _nodeStatuses.values()) {
+    nodesByStatus[n.status] = (nodesByStatus[n.status] || 0) + 1;
+  }
+
+  const healthByStatus = {};
+  for (const s of Object.values(HEALTH_STATUS_V2)) healthByStatus[s] = 0;
+  const healthByMetric = {};
+  for (const m of Object.values(HEALTH_METRIC_V2)) healthByMetric[m] = 0;
+  for (const c of _healthChecks.values()) {
+    healthByStatus[c.status] = (healthByStatus[c.status] || 0) + 1;
+    healthByMetric[c.check_type] = (healthByMetric[c.check_type] || 0) + 1;
+  }
+
+  return {
+    totalNodes: _nodeStatuses.size,
+    activeNodes: nodesByStatus[NODE_STATUS_V2.ACTIVE],
+    isolatedNodes: nodesByStatus[NODE_STATUS_V2.ISOLATED],
+    totalCircuits: _breakers.size,
+    totalHealthChecks: _healthChecks.size,
+    maxActiveNodes: _maxActiveNodes,
+    failureThreshold: _failureThreshold,
+    halfOpenCooldownMs: _halfOpenCooldownMs,
+    unhealthyThreshold: _unhealthyThreshold,
+    circuitsByState,
+    nodesByStatus,
+    healthByStatus,
+    healthByMetric,
+  };
 }