@invariance/sdk 0.0.1 → 0.1.1

package/dist/index.cjs

@@ -7804,7 +7804,7 @@ var require_main = __commonJS({
     var fs = require("fs");
     var path = require("path");
     var os = require("os");
-    var crypto = require("crypto");
+    var crypto2 = require("crypto");
     var packageJson = require_package();
     var version = packageJson.version;
     var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
@@ -8023,7 +8023,7 @@ var require_main = __commonJS({
       const authTag = ciphertext.subarray(-16);
       ciphertext = ciphertext.subarray(12, -16);
       try {
-        const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+        const aesgcm = crypto2.createDecipheriv("aes-256-gcm", key, nonce);
         aesgcm.setAuthTag(authTag);
         return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
       } catch (error) {
@@ -8849,6 +8849,7 @@ __export(index_exports, {
   GovernmentComplianceKit: () => GovernmentComplianceKit,
   IdentityGatekeeper: () => IdentityGatekeeper,
   IdentityManager: () => IdentityManager,
+  InMemoryLedgerAdapter: () => InMemoryLedgerAdapter,
   IntentProtocol: () => IntentProtocol,
   Invariance: () => Invariance,
   InvarianceError: () => InvarianceError,
@@ -8858,6 +8859,7 @@ __export(index_exports, {
   MarketplaceKit: () => MarketplaceKit,
   MarketplacePlugin: () => MarketplacePlugin,
   MultiAgentComposer: () => MultiAgentComposer,
+  OffchainLedger: () => OffchainLedger,
   PipelineBuilder: () => PipelineBuilder,
   PolicyEngine: () => PolicyEngine,
   ReputationBridge: () => ReputationBridge,
@@ -8866,8 +8868,10 @@ __export(index_exports, {
   SDK_VERSION: () => SDK_VERSION,
   SessionContext: () => SessionContext,
   SocialGraphAdapter: () => SocialGraphAdapter,
+  SupabaseLedgerAdapter: () => SupabaseLedgerAdapter,
   Telemetry: () => Telemetry,
   Verifier: () => Verifier,
+  VotingManager: () => VotingManager,
   WalletManager: () => WalletManager,
   X402Manager: () => X402Manager,
   generatePrivateKey: () => import_accounts3.generatePrivateKey,
@@ -8880,6 +8884,8 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/core/InvarianceClient.ts
+init_dist();
+init_InvarianceError();
 var import_chains2 = require("viem/chains");
 var import_accounts2 = require("viem/accounts");
 
@@ -8904,6 +8910,7 @@ var ABI_MAP = {
   atomicVerifier: InvarianceAtomicVerifierAbi,
   voting: InvarianceVotingAbi
 };
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 var ADDRESS_KEY_MAP = {
   identity: "identity",
   policy: "policy",
@@ -8997,6 +9004,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;
   }
   /**
@@ -17063,8 +17076,191 @@ 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
+init_dist();
+init_InvarianceError();
+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;
@@ -17089,6 +17285,7 @@ var Invariance = class _Invariance {
   _marketplace;
   _auditTrail;
   _voting;
+  _ledgerOffchain;
   // ===========================================================================
   // Static Factory Methods
   // ===========================================================================
@@ -17467,6 +17664,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.
    *
@@ -18035,6 +18265,59 @@ var Invariance = class _Invariance {
 init_InvarianceError();
 init_dist();
 
+// 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
 var import_crypto = require("crypto");
 function verifyWebhookSignature(body, signature, secret) {
@@ -18997,6 +19280,7 @@ var import_accounts3 = require("viem/accounts");
   GovernmentComplianceKit,
   IdentityGatekeeper,
   IdentityManager,
+  InMemoryLedgerAdapter,
   IntentProtocol,
   Invariance,
   InvarianceError,
@@ -19006,6 +19290,7 @@ var import_accounts3 = require("viem/accounts");
   MarketplaceKit,
   MarketplacePlugin,
   MultiAgentComposer,
+  OffchainLedger,
   PipelineBuilder,
   PolicyEngine,
   ReputationBridge,
@@ -19014,8 +19299,10 @@ var import_accounts3 = require("viem/accounts");
   SDK_VERSION,
   SessionContext,
   SocialGraphAdapter,
+  SupabaseLedgerAdapter,
   Telemetry,
   Verifier,
+  VotingManager,
   WalletManager,
   X402Manager,
   generatePrivateKey,