@decentrys/sentinel-sdk 0.1.0

package/dist/browser/decentrys-sentinel.mjs

@@ -0,0 +1,352 @@
+// src/model.ts
+var ALERT_SEVERITIES = ["INFO", "LOW", "MEDIUM", "HIGH", "CRITICAL"];
+var TARGET_TYPES = [
+  "CONTRACT",
+  "WALLET",
+  "TREASURY",
+  "MULTISIG",
+  "LP_POOL",
+  "ORACLE",
+  "BRIDGE",
+  "GOVERNANCE"
+];
+
+// src/client.ts
+var SDK_VERSION = "0.1.0";
+var DEFAULT_BASE_URL = "https://api.decentrys.com";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var SentinelError = class extends Error {
+  constructor(status, message, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "SentinelError";
+  }
+  status;
+  code;
+};
+var Sentinel = class {
+  baseUrl;
+  apiKey;
+  timeoutMs;
+  fetchImpl;
+  constructor(config) {
+    if (!config.apiKey?.trim()) {
+      throw new Error("Sentinel: an apiKey is required. Create one at https://decentrys.com/developers.");
+    }
+    if (config.apiKey.startsWith("dk_pub_")) {
+      throw new Error(
+        "Sentinel: that is a publishable key. Monitoring is managed server-side with a secret key \u2014 a publishable key ships inside clients and cannot be trusted to configure detection."
+      );
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.fetchImpl = config.fetch ?? resolveFetch();
+  }
+  // --- Targets ------------------------------------------------------------
+  /** Watch a deployed contract. */
+  registerContract(input) {
+    return this.addTarget(input, "CONTRACT");
+  }
+  registerWallet(input) {
+    return this.addTarget(input, "WALLET");
+  }
+  registerTreasury(input) {
+    return this.addTarget(input, "TREASURY");
+  }
+  registerTarget(input, targetType) {
+    return this.addTarget(input, targetType);
+  }
+  listTargets(projectId) {
+    const query = projectId ? `?projectId=${encodeURIComponent(projectId)}` : "";
+    return this.request("GET", `/v1/monitoring/targets${query}`);
+  }
+  async setTargetEnabled(targetId, enabled) {
+    return this.request("PATCH", `/v1/monitoring/targets/${targetId}`, { enabled });
+  }
+  async removeTarget(targetId) {
+    await this.request("DELETE", `/v1/monitoring/targets/${targetId}`);
+  }
+  // --- Rules --------------------------------------------------------------
+  createRule(input) {
+    return this.request("POST", "/v1/monitoring/rules", input);
+  }
+  updateRule(ruleId, changes) {
+    return this.request("PATCH", `/v1/monitoring/rules/${ruleId}`, changes);
+  }
+  async deleteRule(ruleId) {
+    await this.request("DELETE", `/v1/monitoring/rules/${ruleId}`);
+  }
+  listRules(projectId) {
+    const query = projectId ? `?projectId=${encodeURIComponent(projectId)}` : "";
+    return this.request("GET", `/v1/monitoring/rules${query}`);
+  }
+  /**
+   * Evaluate a rule against facts without arming it.
+   *
+   * A rule that has never been tested against a fact set is a rule nobody
+   * knows the behaviour of, and finding out during an incident is the worst
+   * possible time.
+   */
+  testRule(ruleId, facts) {
+    return this.request("POST", `/v1/monitoring/rules/${ruleId}/test`, { facts });
+  }
+  /** The vocabulary rules are built from: fields, operators, actions, templates. */
+  catalog() {
+    return this.request("GET", "/v1/monitoring/catalog");
+  }
+  // --- Alerts -------------------------------------------------------------
+  listAlerts(input = {}) {
+    const params = new URLSearchParams();
+    if (input.status) params.set("status", input.status);
+    if (input.severity) params.set("severity", input.severity);
+    if (input.limit) params.set("limit", String(input.limit));
+    const query = params.toString();
+    return this.request("GET", `/v1/alerts${query ? `?${query}` : ""}`);
+  }
+  getAlert(alertId) {
+    return this.request("GET", `/v1/alerts/${alertId}`);
+  }
+  acknowledgeAlert(alertId, note) {
+    return this.request("PATCH", `/v1/alerts/${alertId}`, {
+      status: "ACKNOWLEDGED",
+      ...note ? { note } : {}
+    });
+  }
+  // --- Reporting ----------------------------------------------------------
+  /**
+   * Report an event from your own system.
+   *
+   * The one method here that never throws. It is called from a customer's hot
+   * path — a deploy script, a treasury movement, a governance execution — and
+   * a monitoring call must not be able to fail the thing it is monitoring.
+   * The boolean says whether it was recorded, so a caller who cares can check.
+   */
+  async reportEvent(event) {
+    try {
+      await this.request("POST", "/v1/monitoring/events", event);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // --- Internals ----------------------------------------------------------
+  addTarget(input, targetType) {
+    return this.request("POST", "/v1/monitoring/targets", {
+      projectId: input.projectId,
+      chainKey: input.chain,
+      address: input.address,
+      targetType,
+      ...input.label ? { label: input.label } : {}
+    });
+  }
+  async request(method, path, body) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+        method,
+        headers: {
+          "content-type": "application/json",
+          "x-api-key": this.apiKey,
+          "user-agent": `decentrys-sentinel/${SDK_VERSION}`
+        },
+        ...body === void 0 ? {} : { body: JSON.stringify(body) },
+        signal: controller.signal
+      });
+      const text = await response.text();
+      if (!response.ok) {
+        const parsed2 = safeParse(text);
+        throw new SentinelError(
+          response.status,
+          typeof parsed2?.message === "string" ? parsed2.message : `Decentrys returned HTTP ${response.status}.`,
+          typeof parsed2?.code === "string" ? parsed2.code : void 0
+        );
+      }
+      if (!text) return void 0;
+      const parsed = safeParse(text);
+      if (parsed === null) throw new SentinelError(response.status, "The response was not valid JSON.");
+      return "data" in parsed && !("total" in parsed) && !("page" in parsed) ? parsed.data : parsed;
+    } catch (error) {
+      if (error instanceof SentinelError) throw error;
+      if (controller.signal.aborted) {
+        throw new SentinelError(0, `No response within ${this.timeoutMs}ms.`);
+      }
+      throw new SentinelError(0, error instanceof Error ? error.message : "Request failed.");
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+function safeParse(text) {
+  try {
+    const parsed = JSON.parse(text);
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function resolveFetch() {
+  const candidate = globalThis.fetch;
+  if (typeof candidate !== "function") {
+    throw new Error("Sentinel: no global fetch was found. Pass one via `new Sentinel({ fetch })`.");
+  }
+  return candidate.bind(globalThis);
+}
+
+// src/from-audit.ts
+var DEFAULT_ACTIONS = [{ type: "ALERT", config: {} }];
+var RULES = {
+  UPGRADEABLE: {
+    name: "Contract logic replaced",
+    description: "The proxy now points at different code. Every finding in the audit describes the previous implementation and stops applying the moment this fires.",
+    severity: "CRITICAL",
+    triggerType: "contract.upgraded",
+    conditions: { op: "eq", field: "upgrade.changed", value: true }
+  },
+  ADMIN_CONTROL: {
+    name: "Admin address changed",
+    description: "Whoever can upgrade or configure this contract is now a different account.",
+    severity: "CRITICAL",
+    triggerType: "contract.admin_changed",
+    conditions: { op: "eq", field: "admin.changed", value: true }
+  },
+  OWNERSHIP: {
+    name: "Ownership transferred",
+    description: "Owner-only functions identified during the audit are now controlled by someone else.",
+    severity: "HIGH",
+    triggerType: "contract.ownership_transferred",
+    conditions: { op: "eq", field: "ownership.changed", value: true }
+  },
+  MINT_AUTHORITY: {
+    name: "Supply increased",
+    description: "The mint authority the audit identified was used. Legitimate for many designs \u2014 this reports it so holders are not the last to know.",
+    severity: "HIGH",
+    triggerType: "token.supply_changed",
+    conditions: {
+      op: "AND",
+      conditions: [
+        { op: "eq", field: "token.supplyIncreased", value: true },
+        // A percentage rather than an absolute: a fixed figure is meaningless
+        // across tokens with different supplies and decimals.
+        { op: "gt", field: "token.supplyChangePercent", value: 1 }
+      ]
+    }
+  },
+  PAUSABLE: {
+    name: "Pause state changed",
+    description: "The contract was paused or unpaused. Pausing is usually a defence, and knowing it happened is how you find out an incident started without you.",
+    severity: "HIGH",
+    triggerType: "contract.paused",
+    conditions: { op: "eq", field: "contract.pauseChanged", value: true }
+  },
+  BLACKLIST: {
+    name: "Transfer restriction applied",
+    description: "An address was restricted from transferring. Reported because it is invisible on-chain otherwise.",
+    severity: "MEDIUM",
+    triggerType: "contract.function_called",
+    conditions: { op: "contains", field: "event.types", value: "BLACKLIST" }
+  },
+  FORCED_BALANCE_CHANGE: {
+    name: "Balance moved without the holder acting",
+    description: "A permanent delegate or equivalent authority moved tokens from an account that did not sign for it. Legitimate for some regulated designs, and always worth knowing about.",
+    severity: "CRITICAL",
+    triggerType: "contract.function_called",
+    conditions: { op: "contains", field: "event.types", value: "FORCED_TRANSFER" }
+  },
+  GOVERNANCE: {
+    name: "Governance proposal executed",
+    description: "An executed proposal can change anything the audit assumed was fixed.",
+    severity: "HIGH",
+    triggerType: "governance.executed",
+    conditions: { op: "eq", field: "governance.executed", value: true }
+  }
+};
+var ALIASES = {
+  // The canonical names the Protect layer emits. Chain-specific spellings —
+  // Sui's TreasuryCap, Solana's mintAuthority, an EIP-1967 slot — are already
+  // normalised to these before an audit hands anything over, so mapping raw
+  // chain vocabulary here would be mapping names that never arrive.
+  UPGRADEABLE: "UPGRADEABLE",
+  DELEGATED_EXECUTION: "UPGRADEABLE",
+  MINT_AUTHORITY: "MINT_AUTHORITY",
+  PAUSABLE: "PAUSABLE",
+  ACCOUNT_FREEZE: "BLACKLIST",
+  FORCED_BALANCE_CHANGE: "FORCED_BALANCE_CHANGE",
+  GOVERNANCE: "GOVERNANCE",
+  // Accepted because an audit report may use them in prose, and rejecting a
+  // reviewer's own wording would silently drop a rule they expected.
+  PROXY: "UPGRADEABLE",
+  UPGRADE_AUTHORITY: "UPGRADEABLE",
+  ADMIN: "ADMIN_CONTROL",
+  ADMIN_CONTROL: "ADMIN_CONTROL",
+  OWNER: "OWNERSHIP",
+  OWNERSHIP: "OWNERSHIP",
+  MINT: "MINT_AUTHORITY",
+  PAUSE: "PAUSABLE",
+  FREEZE_AUTHORITY: "BLACKLIST",
+  BLACKLIST: "BLACKLIST"
+};
+function rulesFromAudit(input) {
+  const actions = input.actions?.length ? input.actions : DEFAULT_ACTIONS;
+  const seen = /* @__PURE__ */ new Set();
+  const generated = [];
+  for (const capability of input.capabilities) {
+    const key = ALIASES[capability.type.toUpperCase()];
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    const template = RULES[key];
+    if (!template) continue;
+    generated.push({
+      capability: capability.type,
+      rule: {
+        projectId: input.projectId,
+        name: template.name,
+        description: capability.grantedBy ? `${template.description} Granted by ${capability.grantedBy}, identified during the audit.` : `${template.description} Identified during the audit.`,
+        severity: template.severity,
+        triggerType: template.triggerType,
+        conditions: template.conditions,
+        actions,
+        // Five minutes. Long enough that one event in a loop does not page a
+        // team repeatedly, short enough that a second, genuinely separate
+        // occurrence still gets through.
+        cooldownSeconds: 300
+      }
+    });
+  }
+  if (typeof input.treasuryThresholdUsd === "number" && input.treasuryThresholdUsd > 0) {
+    generated.push({
+      capability: "TREASURY",
+      rule: {
+        projectId: input.projectId,
+        name: "Large treasury outflow",
+        description: `An outbound movement above $${input.treasuryThresholdUsd.toLocaleString()}, the threshold agreed during the audit.`,
+        severity: "HIGH",
+        triggerType: "treasury.transfer",
+        conditions: {
+          op: "AND",
+          conditions: [
+            { op: "eq", field: "transfer.direction", value: "OUT" },
+            { op: "gt", field: "transfer.valueUsd", value: input.treasuryThresholdUsd }
+          ]
+        },
+        actions,
+        cooldownSeconds: 300
+      }
+    });
+  }
+  return generated;
+}
+function unmappedCapabilities(capabilities) {
+  return capabilities.filter((capability) => !ALIASES[capability.type.toUpperCase()]).map((capability) => capability.type);
+}
+export {
+  ALERT_SEVERITIES,
+  SDK_VERSION,
+  Sentinel,
+  SentinelError,
+  TARGET_TYPES,
+  rulesFromAudit,
+  unmappedCapabilities
+};

package/dist/client.d.ts

@@ -0,0 +1,118 @@
+/**
+ * The Sentinel client.
+ *
+ * The contract is the opposite of Protect's, and deliberately.
+ *
+ * Protect sits between a user and a signing screen, so it never throws: a
+ * security service having a bad minute must not cost someone their
+ * transaction. Sentinel is management and reporting — you are registering a
+ * contract, writing a rule, acknowledging an alert. Swallowing a failure
+ * there would leave an operator believing they are monitored when they are
+ * not, which is the more dangerous silence of the two.
+ *
+ * So Sentinel throws. Loudly, with the API's own message.
+ *
+ * The one exception is `reportEvent`, which runs on a hot path in a
+ * customer's own system and must never be able to break it.
+ */
+import type { Alert, AlertSeverity, MonitoringRule, MonitoringTarget, RuleAction, RuleTestResult, TargetType } from './model';
+export declare const SDK_VERSION = "0.1.0";
+export type FetchLike = (url: string, init: {
+    method: string;
+    headers: Record<string, string>;
+    body?: string;
+    signal?: AbortSignal;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    text: () => Promise<string>;
+}>;
+export declare class SentinelError extends Error {
+    readonly status: number;
+    readonly code?: string | undefined;
+    constructor(status: number, message: string, code?: string | undefined);
+}
+export interface SentinelConfig {
+    apiKey: string;
+    baseUrl?: string;
+    timeoutMs?: number;
+    fetch?: FetchLike;
+}
+export interface RegisterTargetInput {
+    projectId: string;
+    chain: string;
+    address: string;
+    label?: string;
+}
+export interface CreateRuleInput {
+    projectId: string;
+    name: string;
+    description?: string;
+    severity: AlertSeverity;
+    triggerType: string;
+    conditions: Record<string, unknown>;
+    actions: RuleAction[];
+    cooldownSeconds?: number;
+}
+export interface ListAlertsInput {
+    status?: string;
+    severity?: AlertSeverity;
+    limit?: number;
+}
+export declare class Sentinel {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly timeoutMs;
+    private readonly fetchImpl;
+    constructor(config: SentinelConfig);
+    /** Watch a deployed contract. */
+    registerContract(input: RegisterTargetInput): Promise<MonitoringTarget>;
+    registerWallet(input: RegisterTargetInput): Promise<MonitoringTarget>;
+    registerTreasury(input: RegisterTargetInput): Promise<MonitoringTarget>;
+    registerTarget(input: RegisterTargetInput, targetType: TargetType): Promise<MonitoringTarget>;
+    listTargets(projectId?: string): Promise<MonitoringTarget[]>;
+    setTargetEnabled(targetId: string, enabled: boolean): Promise<MonitoringTarget>;
+    removeTarget(targetId: string): Promise<void>;
+    createRule(input: CreateRuleInput): Promise<MonitoringRule>;
+    updateRule(ruleId: string, changes: Partial<CreateRuleInput> & {
+        enabled?: boolean;
+    }): Promise<MonitoringRule>;
+    deleteRule(ruleId: string): Promise<void>;
+    listRules(projectId?: string): Promise<{
+        data: MonitoringRule[];
+    }>;
+    /**
+     * Evaluate a rule against facts without arming it.
+     *
+     * A rule that has never been tested against a fact set is a rule nobody
+     * knows the behaviour of, and finding out during an incident is the worst
+     * possible time.
+     */
+    testRule(ruleId: string, facts: Record<string, unknown>): Promise<RuleTestResult>;
+    /** The vocabulary rules are built from: fields, operators, actions, templates. */
+    catalog(): Promise<Record<string, unknown>>;
+    listAlerts(input?: ListAlertsInput): Promise<{
+        data: Alert[];
+    }>;
+    getAlert(alertId: string): Promise<Alert>;
+    acknowledgeAlert(alertId: string, note?: string): Promise<Alert>;
+    /**
+     * Report an event from your own system.
+     *
+     * The one method here that never throws. It is called from a customer's hot
+     * path — a deploy script, a treasury movement, a governance execution — and
+     * a monitoring call must not be able to fail the thing it is monitoring.
+     * The boolean says whether it was recorded, so a caller who cares can check.
+     */
+    reportEvent(event: {
+        projectId: string;
+        eventName: string;
+        chain?: string;
+        address?: string;
+        txHash?: string;
+        facts?: Record<string, unknown>;
+    }): Promise<boolean>;
+    private addTarget;
+    private request;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}