@invariance/sdk 0.0.1 → 0.1.1

package/dist/index.js

@@ -36,7 +36,7 @@ import {
   pricingTypeToEnum,
   toBytes32,
   waitForReceipt
-} from "./chunk-3ONNY6AX.js";
+} from "./chunk-2JGPNHE3.js";
 import {
   InvarianceAtomicVerifierAbi,
   InvarianceCompactLedgerAbi,
@@ -74,6 +74,7 @@ var ABI_MAP = {
   atomicVerifier: InvarianceAtomicVerifierAbi,
   voting: InvarianceVotingAbi
 };
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 var ADDRESS_KEY_MAP = {
   identity: "identity",
   policy: "policy",
@@ -167,6 +168,12 @@ var ContractFactory = class {
         `Contract address not configured: ${name}`
       );
     }
+    if (addr === ZERO_ADDRESS) {
+      throw new InvarianceError(
+        ErrorCode.NETWORK_ERROR,
+        `Contract address for ${name} is the zero address. Contracts may not be deployed on this chain yet.`
+      );
+    }
     return addr;
   }
   /**
@@ -5012,7 +5019,7 @@ var AutoBatchedEventLedgerCompact = class {
     const optimistic = this.contracts.getConfirmation() === "optimistic";
     const receiptClient = this.contracts.getReceiptClient();
     const receipt = await waitForReceipt(receiptClient, txHash, { optimistic });
-    const { parseCompactEntryIdFromLogs: parseCompactEntryIdFromLogs2 } = await import("./contract-helpers-XI4NOQLS.js");
+    const { parseCompactEntryIdFromLogs: parseCompactEntryIdFromLogs2 } = await import("./contract-helpers-2XZGNKCO.js");
     const entryId = optimistic ? toBytes32(txHash) : parseCompactEntryIdFromLogs2(receipt.logs);
     const explorerBase = this.contracts.getExplorerBaseUrl();
     const result = {
@@ -8175,8 +8182,189 @@ var VotingManager = class {
   }
 };
 
+// src/modules/ledger/OffchainLedger.ts
+var OffchainLedger = class {
+  events;
+  telemetry;
+  failOpen;
+  adapter;
+  constructor(events, telemetry, options) {
+    this.events = events;
+    this.telemetry = telemetry;
+    this.adapter = options.adapter;
+    this.failOpen = options.failOpen ?? true;
+  }
+  /**
+   * Log a ledger event.
+   *
+   * @param event - Same `LedgerEventInput` used by on-chain ledger
+   * @returns The created off-chain ledger entry
+   */
+  async log(event) {
+    this.telemetry.track("offchain_ledger.log", { action: event.action });
+    const entryId = crypto.randomUUID();
+    const timestamp = Date.now();
+    const category = event.category ?? "custom";
+    const severity = event.severity ?? "info";
+    const entry = {
+      entryId,
+      action: event.action,
+      actor: event.actor,
+      category,
+      severity,
+      timestamp,
+      createdAt: new Date(timestamp).toISOString()
+    };
+    if (event.metadata) {
+      entry.metadata = event.metadata;
+    }
+    try {
+      const persisted = await this.adapter.insert(entry);
+      this.events.emit("ledger.logged", { entryId: persisted.entryId, action: persisted.action });
+      return persisted;
+    } catch (err) {
+      if (this.failOpen) {
+        this.events.emit("ledger.logged", { entryId: entry.entryId, action: entry.action });
+        return entry;
+      }
+      throw err;
+    }
+  }
+  /**
+   * Query off-chain ledger entries.
+   *
+   * @param filters - Same `LedgerQueryFilters` used by on-chain ledger
+   * @returns Matching off-chain ledger entries
+   */
+  async query(filters) {
+    this.telemetry.track("offchain_ledger.query", { action: filters.action });
+    try {
+      return await this.adapter.query(filters);
+    } catch (err) {
+      if (this.failOpen) {
+        return [];
+      }
+      throw err;
+    }
+  }
+};
+
+// src/modules/ledger/adapters/SupabaseLedgerAdapter.ts
+var TABLE_NAME = "offchain_ledger_entries";
+var SupabaseLedgerAdapter = class _SupabaseLedgerAdapter {
+  url;
+  key;
+  client = null;
+  clientPromise = null;
+  constructor(options) {
+    this.url = options.url;
+    this.key = options.key;
+  }
+  /** @internal */
+  async getClient() {
+    if (this.client) return this.client;
+    if (this.clientPromise) return this.clientPromise;
+    this.clientPromise = (async () => {
+      try {
+        const { createClient } = await import("@supabase/supabase-js");
+        this.client = createClient(this.url, this.key);
+        return this.client;
+      } catch {
+        throw new InvarianceError(
+          ErrorCode.NETWORK_ERROR,
+          "Failed to import @supabase/supabase-js. Install it with: npm install @supabase/supabase-js"
+        );
+      }
+    })();
+    return this.clientPromise;
+  }
+  /** Persist a ledger entry to Supabase. */
+  async insert(entry) {
+    const row = {
+      entry_id: entry.entryId,
+      action: entry.action,
+      actor_type: entry.actor.type,
+      actor_address: entry.actor.address,
+      category: entry.category,
+      severity: entry.severity,
+      metadata: entry.metadata ?? null,
+      timestamp: entry.timestamp
+    };
+    const client = await this.getClient();
+    const { data, error } = await client.from(TABLE_NAME).insert(row).select().single();
+    if (error) {
+      throw new InvarianceError(ErrorCode.NETWORK_ERROR, `Supabase insert failed: ${error.message}`);
+    }
+    return _SupabaseLedgerAdapter.toEntry(data);
+  }
+  /** Query ledger entries from Supabase. */
+  async query(filters) {
+    const client = await this.getClient();
+    let q = client.from(TABLE_NAME).select("*");
+    if (filters.actor) {
+      q = q.eq("actor_address", filters.actor);
+    }
+    if (filters.actorType) {
+      q = q.eq("actor_type", filters.actorType);
+    }
+    if (filters.action) {
+      if (Array.isArray(filters.action)) {
+        q = q.in("action", filters.action);
+      } else {
+        q = q.eq("action", filters.action);
+      }
+    }
+    if (filters.category) {
+      q = q.eq("category", filters.category);
+    }
+    if (filters.from !== void 0) {
+      const fromTs = typeof filters.from === "string" ? new Date(filters.from).getTime() : filters.from;
+      q = q.gte("timestamp", fromTs);
+    }
+    if (filters.to !== void 0) {
+      const toTs = typeof filters.to === "string" ? new Date(filters.to).getTime() : filters.to;
+      q = q.lte("timestamp", toTs);
+    }
+    const orderCol = filters.orderBy ?? "timestamp";
+    const ascending = (filters.order ?? "desc") === "asc";
+    q = q.order(orderCol, { ascending });
+    if (filters.limit) {
+      q = q.limit(filters.limit);
+    }
+    if (filters.offset) {
+      q = q.range(filters.offset, filters.offset + (filters.limit ?? 100) - 1);
+    }
+    const { data, error } = await q;
+    if (error) {
+      throw new InvarianceError(ErrorCode.NETWORK_ERROR, `Supabase query failed: ${error.message}`);
+    }
+    return data.map(
+      (row) => _SupabaseLedgerAdapter.toEntry(row)
+    );
+  }
+  /** Map a Supabase row to an OffchainLedgerEntry. */
+  static toEntry(row) {
+    const entry = {
+      entryId: row["entry_id"],
+      action: row["action"],
+      actor: {
+        type: row["actor_type"],
+        address: row["actor_address"]
+      },
+      category: row["category"],
+      severity: row["severity"],
+      timestamp: row["timestamp"],
+      createdAt: row["created_at"]
+    };
+    if (row["metadata"] != null) {
+      entry.metadata = row["metadata"];
+    }
+    return entry;
+  }
+};
+
 // src/core/InvarianceClient.ts
-var SDK_VERSION = "0.0.1";
+var SDK_VERSION = "0.1.1";
 var Invariance = class _Invariance {
   config;
   contracts;
@@ -8201,6 +8389,7 @@ var Invariance = class _Invariance {
   _marketplace;
   _auditTrail;
   _voting;
+  _ledgerOffchain;
   // ===========================================================================
   // Static Factory Methods
   // ===========================================================================
@@ -8579,6 +8768,39 @@ var Invariance = class _Invariance {
     }
     return this._auditTrail;
   }
+  /**
+   * Off-chain ledger module backed by a pluggable {@link LedgerAdapter}.
+   *
+   * Same `LedgerEventInput` interface as on-chain, zero gas.
+   * Resolution order: `config.ledgerAdapter` > `config.supabase` > env vars.
+   *
+   * @example
+   * ```typescript
+   * const entry = await inv.ledgerOffchain.log({
+   *   action: 'model-inference',
+   *   actor: { type: 'agent', address: '0xBot' },
+   * });
+   * ```
+   */
+  get ledgerOffchain() {
+    if (!this._ledgerOffchain) {
+      let adapter = this.config.ledgerAdapter;
+      if (!adapter) {
+        const url = this.config.supabase?.url ?? process.env["INVARIANCE_SUPABASE_URL"];
+        const key = this.config.supabase?.key ?? process.env["INVARIANCE_SUPABASE_KEY"];
+        if (!url || !key) {
+          throw new InvarianceError(
+            ErrorCode.INVALID_INPUT,
+            "Off-chain ledger requires either config.ledgerAdapter, config.supabase (url + key), or INVARIANCE_SUPABASE_URL / INVARIANCE_SUPABASE_KEY env vars."
+          );
+        }
+        adapter = new SupabaseLedgerAdapter({ url, key });
+      }
+      const failOpen = this.config.supabase?.failOpen ?? true;
+      this._ledgerOffchain = new OffchainLedger(this.events, this.telemetry, { adapter, failOpen });
+    }
+    return this._ledgerOffchain;
+  }
   /**
    * Off-chain batch voting with merkle root settlement.
    *
@@ -9143,6 +9365,59 @@ var Invariance = class _Invariance {
   }
 };
 
+// src/modules/ledger/adapters/InMemoryLedgerAdapter.ts
+var InMemoryLedgerAdapter = class {
+  /** @internal */
+  entries = [];
+  async insert(entry) {
+    this.entries.push(entry);
+    return entry;
+  }
+  async query(filters) {
+    let results = [...this.entries];
+    if (filters.actor) {
+      results = results.filter((e) => e.actor.address === filters.actor);
+    }
+    if (filters.actorType) {
+      results = results.filter((e) => e.actor.type === filters.actorType);
+    }
+    if (filters.action) {
+      if (Array.isArray(filters.action)) {
+        results = results.filter((e) => filters.action.includes(e.action));
+      } else {
+        results = results.filter((e) => e.action === filters.action);
+      }
+    }
+    if (filters.category) {
+      results = results.filter((e) => e.category === filters.category);
+    }
+    if (filters.from !== void 0) {
+      const fromTs = typeof filters.from === "string" ? new Date(filters.from).getTime() : filters.from;
+      results = results.filter((e) => e.timestamp >= fromTs);
+    }
+    if (filters.to !== void 0) {
+      const toTs = typeof filters.to === "string" ? new Date(filters.to).getTime() : filters.to;
+      results = results.filter((e) => e.timestamp <= toTs);
+    }
+    const ascending = (filters.order ?? "desc") === "asc";
+    const orderBy = filters.orderBy ?? "timestamp";
+    results.sort((a, b) => {
+      const aVal = a[orderBy];
+      const bVal = b[orderBy];
+      if (aVal < bVal) return ascending ? -1 : 1;
+      if (aVal > bVal) return ascending ? 1 : -1;
+      return 0;
+    });
+    if (filters.offset) {
+      results = results.slice(filters.offset);
+    }
+    if (filters.limit) {
+      results = results.slice(0, filters.limit);
+    }
+    return results;
+  }
+};
+
 // src/utils/webhook.ts
 import { createHmac, timingSafeEqual } from "crypto";
 function verifyWebhookSignature(body, signature, secret) {
@@ -10104,6 +10379,7 @@ export {
   GovernmentComplianceKit,
   IdentityGatekeeper,
   IdentityManager,
+  InMemoryLedgerAdapter,
   IntentProtocol,
   Invariance,
   InvarianceError,
@@ -10113,6 +10389,7 @@ export {
   MarketplaceKit,
   MarketplacePlugin,
   MultiAgentComposer,
+  OffchainLedger,
   PipelineBuilder,
   PolicyEngine,
   ReputationBridge,
@@ -10121,8 +10398,10 @@ export {
   SDK_VERSION,
   SessionContext,
   SocialGraphAdapter,
+  SupabaseLedgerAdapter,
   Telemetry,
   Verifier,
+  VotingManager,
   WalletManager,
   X402Manager,
   generatePrivateKey2 as generatePrivateKey,