@chaoschain/sdk 0.3.1 → 0.3.2

package/CHANGELOG.md

@@ -5,6 +5,21 @@ All notable changes to the ChaosChain TypeScript SDK will be documented in this
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.2] - 2026-03-23
+
+### Added
+
+- **Subpath package exports** for edge/serverless: `@chaoschain/sdk/session` and `@chaoschain/sdk/gateway` (lightweight bundles; no ethers / IPFS / heavy Node deps in those entry points)
+- **`src/gateway/index.ts`** — re-exports `GatewayClient`, selected gateway types, and gateway-related exceptions
+
+### Changed
+
+- **`src/types.ts`** — `import type` for `ethers` where only types are needed (no runtime change)
+
+### Documentation
+
+- README **Edge Runtime / Serverless Usage**: caveat that `GatewayClient.submitWork()` uses `Buffer`; read/poll APIs are safe on strict V8 isolates; binary `submitWork` needs Node compat or a Buffer polyfill
+
 ## [0.3.1] - 2026-03-22
 
 ### Added

package/README.md

@@ -52,6 +52,55 @@ Storage backends are optional and intended for development/testing. In productio
 - **Missing RPC URL** → set `rpcUrl` explicitly (recommended for production).
 - **Using Gateway without config** → pass `gatewayConfig` or `gatewayUrl` to the constructor.
 
+## Edge Runtime / Serverless Usage
+
+The main entry point (`@chaoschain/sdk`) includes ethers, IPFS, and Node.js-only dependencies that break in edge runtimes. If you are deploying to **Cloudflare Workers**, **Vercel Edge Functions**, **Deno Deploy**, or any V8 isolate environment, use the lightweight subpath imports instead:
+
+```typescript
+import { SessionClient } from '@chaoschain/sdk/session';  // 6.59 KB
+import { GatewayClient } from '@chaoschain/sdk/gateway';   // 20 KB
+```
+
+> **Note:** `GatewayClient.submitWork()` uses `Buffer` internally for binary encoding.
+> For read-only and polling operations (`getWorkflow`, `getPendingWork`, `getWorkEvidence`),
+> the gateway subpath works in all V8 isolate environments.
+> For `submitWork` with binary content, use Node.js compat mode or a Buffer polyfill.
+
+| Entry point | Size | What's included |
+|---|---|---|
+| `@chaoschain/sdk` | 490 KB | Everything: ethers, storage backends, IPFS, all modules |
+| `@chaoschain/sdk/session` | 6.59 KB | `SessionClient`, `Session`, session types |
+| `@chaoschain/sdk/gateway` | 20 KB | `GatewayClient`, workflow types, gateway exceptions |
+
+Both subpaths are free of ethers, StorageBackends, form-data, and Node.js built-in dependencies. Use them when you only need to interact with the gateway via HTTP (sessions, score submission, workflow polling).
+
+**Example: Cloudflare Worker**
+
+```typescript
+import { SessionClient } from '@chaoschain/sdk/session';
+import { GatewayClient } from '@chaoschain/sdk/gateway';
+
+export default {
+  async fetch(request: Request, env: Env) {
+    const client = new SessionClient({
+      gatewayUrl: env.GATEWAY_URL,
+      apiKey: env.CHAOSCHAIN_API_KEY,
+    });
+
+    const session = await client.start({
+      studio_address: env.STUDIO_ADDRESS,
+      agent_address: env.AGENT_ADDRESS,
+      task_type: 'feature',
+    });
+
+    await session.step('implementing', 'Built feature X');
+    const { workflow_id, data_hash } = await session.complete();
+
+    return Response.json({ workflow_id, data_hash });
+  },
+};
+```
+
 ## Engineering Studio — Session SDK
 
 The Session SDK enables AI agents to capture their work sessions without manually constructing event schemas or DAGs. Sessions automatically build a verifiable Evidence DAG that produces trust profiles for reputation and scoring.

package/dist/{IPFSLocal-B4hnMEfS.d.ts → IPFSLocal-B_Sgmd_Q.d.ts}

@@ -1,4 +1,4 @@
-import { n as StorageProvider, U as UploadOptions, i as UploadResult } from './types-BBVtx_jV.js';
+import { S as StorageProvider, U as UploadOptions, a as UploadResult } from './types-C0Ay90UI.js';
 
 /**
  * Local IPFS Storage Provider

package/dist/{IPFSLocal-zRj6kG8e.d.cts → IPFSLocal-DjFddwHD.d.cts}

@@ -1,4 +1,4 @@
-import { n as StorageProvider, U as UploadOptions, i as UploadResult } from './types-BBVtx_jV.cjs';
+import { S as StorageProvider, U as UploadOptions, a as UploadResult } from './types-C0Ay90UI.cjs';
 
 /**
  * Local IPFS Storage Provider

package/dist/gateway/index.cjs

@@ -0,0 +1,591 @@
+'use strict';
+
+var axios = require('axios');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+
+// src/GatewayClient.ts
+
+// src/exceptions.ts
+var ChaosChainSDKError = class _ChaosChainSDKError extends Error {
+  details;
+  constructor(message, details = {}) {
+    super(message);
+    this.name = "ChaosChainSDKError";
+    this.details = details;
+    Object.setPrototypeOf(this, _ChaosChainSDKError.prototype);
+  }
+  toString() {
+    if (Object.keys(this.details).length > 0) {
+      return `${this.message} | Details: ${JSON.stringify(this.details)}`;
+    }
+    return this.message;
+  }
+};
+var GatewayError = class _GatewayError extends ChaosChainSDKError {
+  statusCode;
+  response;
+  category;
+  retryable;
+  constructor(message, details) {
+    super(message, details || {});
+    this.name = "GatewayError";
+    this.statusCode = details?.statusCode;
+    this.response = details?.response;
+    this.category = details?.category;
+    this.retryable = details?.retryable;
+    Object.setPrototypeOf(this, _GatewayError.prototype);
+  }
+};
+var GatewayConnectionError = class _GatewayConnectionError extends GatewayError {
+  constructor(message) {
+    super(message);
+    this.name = "GatewayConnectionError";
+    Object.setPrototypeOf(this, _GatewayConnectionError.prototype);
+  }
+};
+var GatewayTimeoutError = class _GatewayTimeoutError extends GatewayError {
+  workflowId;
+  lastStatus;
+  constructor(workflowId, message, lastStatus) {
+    super(message);
+    this.name = "GatewayTimeoutError";
+    this.workflowId = workflowId;
+    this.lastStatus = lastStatus;
+    Object.setPrototypeOf(this, _GatewayTimeoutError.prototype);
+  }
+};
+var WorkflowFailedError = class _WorkflowFailedError extends GatewayError {
+  workflowId;
+  workflowError;
+  constructor(workflowId, error) {
+    super(`Workflow ${workflowId} failed at step ${error.step}: ${error.message}`);
+    this.name = "WorkflowFailedError";
+    this.workflowId = workflowId;
+    this.workflowError = error;
+    Object.setPrototypeOf(this, _WorkflowFailedError.prototype);
+  }
+};
+
+// src/GatewayClient.ts
+var GatewayClient = class {
+  gatewayUrl;
+  timeout;
+  maxPollTime;
+  pollInterval;
+  defaultHeaders;
+  auth;
+  retryConfig;
+  constructor(config) {
+    const rawBaseUrl = config.baseUrl ?? config.gatewayUrl ?? "https://gateway.chaoscha.in";
+    let parsed;
+    try {
+      parsed = new URL(rawBaseUrl);
+    } catch {
+      throw new Error(
+        `Invalid gateway baseUrl "${rawBaseUrl}". Provide a valid absolute URL, e.g. https://gateway.chaoscha.in`
+      );
+    }
+    if (!["http:", "https:"].includes(parsed.protocol)) {
+      throw new Error(
+        `Invalid gateway baseUrl protocol "${parsed.protocol}". Only http/https are supported.`
+      );
+    }
+    this.gatewayUrl = parsed.toString().replace(/\/$/, "");
+    this.timeout = this._resolveTimeout(
+      config.timeoutMs,
+      config.timeoutSeconds,
+      config.timeout,
+      3e4
+    );
+    this.maxPollTime = this._resolveTimeout(
+      config.maxPollTimeMs,
+      config.maxPollTimeSeconds,
+      config.maxPollTime,
+      6e5
+    );
+    this.pollInterval = this._resolveTimeout(
+      config.pollIntervalMs,
+      config.pollIntervalSeconds,
+      config.pollInterval,
+      2e3
+    );
+    this.defaultHeaders = config.headers;
+    this.auth = config.auth;
+    this.retryConfig = config.retry;
+  }
+  // ===========================================================================
+  // Private: HTTP Request
+  // ===========================================================================
+  // Resolve timeout with explicit ms taking precedence, then seconds, then legacy ms.
+  _resolveTimeout(timeoutMs, timeoutSeconds, legacyTimeoutMs, defaultMs) {
+    if (typeof timeoutMs === "number") return timeoutMs;
+    if (typeof timeoutSeconds === "number") return timeoutSeconds * 1e3;
+    if (typeof legacyTimeoutMs === "number") return legacyTimeoutMs;
+    return defaultMs ?? 0;
+  }
+  _resolveAuthMode() {
+    if (!this.auth) return void 0;
+    if (this.auth.authMode) return this.auth.authMode;
+    if (this.auth.apiKey) return "apiKey";
+    if (this.auth.signature) return "signature";
+    return void 0;
+  }
+  _buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.defaultHeaders) {
+      Object.assign(headers, this.defaultHeaders);
+    }
+    const authMode = this._resolveAuthMode();
+    if (authMode === "apiKey" && this.auth?.apiKey) {
+      headers["X-API-Key"] = this.auth.apiKey;
+    }
+    if (authMode === "signature" && this.auth?.signature) {
+      const timestamp = this.auth.signature.timestamp ?? Date.now();
+      headers["X-Signature"] = this.auth.signature.signature;
+      headers["X-Timestamp"] = `${timestamp}`;
+      headers["X-Address"] = this.auth.signature.address;
+    }
+    if (!headers["Content-Type"]) {
+      headers["Content-Type"] = "application/json";
+    }
+    return headers;
+  }
+  _classifyStatusCode(statusCode) {
+    if (statusCode === 401 || statusCode === 403) {
+      return { statusCode, category: "auth", retryable: false };
+    }
+    if (statusCode === 408 || statusCode === 429 || statusCode !== void 0 && statusCode >= 500) {
+      return { statusCode, category: "transient", retryable: true };
+    }
+    if (statusCode !== void 0 && statusCode >= 400) {
+      return { statusCode, category: "permanent", retryable: false };
+    }
+    return { statusCode, category: "unknown", retryable: false };
+  }
+  _normalizeError(error) {
+    if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND") {
+      const connectionError = new GatewayConnectionError(
+        `Failed to connect to Gateway at ${this.gatewayUrl}`
+      );
+      connectionError.details.category = "transient";
+      connectionError.details.retryable = true;
+      connectionError.category = "transient";
+      connectionError.retryable = true;
+      return connectionError;
+    }
+    if (error.code === "ETIMEDOUT" || error.code === "ECONNABORTED") {
+      const timeoutError = new GatewayTimeoutError(
+        "timeout",
+        `request to Gateway timed out: ${error.message}`
+      );
+      timeoutError.details.category = "transient";
+      timeoutError.details.retryable = true;
+      timeoutError.category = "transient";
+      timeoutError.retryable = true;
+      return timeoutError;
+    }
+    if (error.response) {
+      const data = error.response.data;
+      const message = data?.error || data?.message || "Unknown error from Gateway";
+      const classification2 = this._classifyStatusCode(error.response.status);
+      return new GatewayError(`Gateway returned error: ${message}`, {
+        statusCode: error.response.status,
+        response: data,
+        category: classification2.category,
+        retryable: classification2.retryable
+      });
+    }
+    const classification = this._classifyStatusCode(void 0);
+    return new GatewayError(`Gateway request failed: ${error.message}`, {
+      category: classification.category,
+      retryable: classification.retryable
+    });
+  }
+  _getRetryDelayMs(attempt) {
+    const initialDelayMs = this.retryConfig?.initialDelayMs ?? 500;
+    const backoffFactor = this.retryConfig?.backoffFactor ?? 2;
+    const maxDelayMs = this.retryConfig?.maxDelayMs ?? 8e3;
+    const jitterEnabled = this.retryConfig?.jitter ?? true;
+    const jitterRatio = this.retryConfig?.jitterRatio ?? 0.2;
+    let delay = Math.min(maxDelayMs, initialDelayMs * Math.pow(backoffFactor, attempt));
+    if (jitterEnabled) {
+      const delta = delay * jitterRatio;
+      delay = delay + (Math.random() * 2 - 1) * delta;
+      delay = Math.max(0, delay);
+    }
+    return Math.round(delay);
+  }
+  async _sleep(durationMs) {
+    await new Promise((resolve) => setTimeout(resolve, durationMs));
+  }
+  /**
+   * Make HTTP request to Gateway.
+   * Handles errors and transforms them to Gateway exceptions.
+   */
+  async _request(method, path, data) {
+    const url = `${this.gatewayUrl}${path}`;
+    const maxRetries = this.retryConfig?.maxRetries ?? 3;
+    const retriesEnabled = this.retryConfig?.enabled === true;
+    let attempt = 0;
+    while (true) {
+      try {
+        const response = await axios__default.default({
+          method,
+          url,
+          data,
+          timeout: this.timeout,
+          headers: this._buildHeaders()
+        });
+        return response.data;
+      } catch (error) {
+        const normalizedError = this._normalizeError(error);
+        const category = normalizedError.category;
+        const retryable = normalizedError.retryable;
+        const shouldRetry = retriesEnabled === true && category === "transient" && retryable === true && attempt < maxRetries;
+        if (!shouldRetry) {
+          throw normalizedError;
+        }
+        const delay = this._getRetryDelayMs(attempt);
+        attempt += 1;
+        await this._sleep(delay);
+      }
+    }
+  }
+  /**
+   * Parse workflow status from API response.
+   */
+  _parseWorkflowStatus(data) {
+    const progress = {
+      arweaveTxId: data.progress?.arweave_tx_id,
+      arweaveConfirmed: data.progress?.arweave_confirmed,
+      onchainTxHash: data.progress?.onchain_tx_hash,
+      onchainConfirmed: data.progress?.onchain_confirmed,
+      onchainBlock: data.progress?.onchain_block,
+      scoreTxHash: data.progress?.score_tx_hash,
+      commitTxHash: data.progress?.commit_tx_hash,
+      revealTxHash: data.progress?.reveal_tx_hash
+    };
+    const error = data.error ? {
+      step: data.error.step || "",
+      message: data.error.message || "",
+      code: data.error.code
+    } : void 0;
+    return {
+      workflowId: data.id,
+      workflowType: data.type,
+      state: data.state,
+      step: data.step,
+      createdAt: data.created_at,
+      updatedAt: data.updated_at,
+      progress,
+      error
+    };
+  }
+  // ===========================================================================
+  // Health Check
+  // ===========================================================================
+  async healthCheck() {
+    return this._request("GET", "/health");
+  }
+  async isHealthy() {
+    try {
+      const result = await this.healthCheck();
+      return result.status === "ok";
+    } catch (error) {
+      return false;
+    }
+  }
+  // ===========================================================================
+  // Workflow Submission
+  // ===========================================================================
+  /**
+   * Create a work submission workflow.
+   * POST /workflows/work-submission
+   *
+   * SDK prepares inputs; Gateway handles:
+   * - Evidence upload to Arweave
+   * - Transaction submission
+   * - Confirmation waiting
+   *
+   * @param studioAddress - Ethereum address of the studio
+   * @param epoch - Epoch number
+   * @param agentAddress - Ethereum address of the submitting agent
+   * @param dataHash - Bytes32 hash of the work (as hex string)
+   * @param threadRoot - Bytes32 DKG thread root (as hex string)
+   * @param evidenceRoot - Bytes32 evidence Merkle root (as hex string)
+   * @param evidenceContent - Raw evidence bytes (will be base64 encoded)
+   * @param signerAddress - Ethereum address of the signer (must be registered in Gateway)
+   * @returns WorkflowStatus - Initial status of the created workflow
+   */
+  async submitWork(studioAddress, epoch, agentAddress, dataHash, threadRoot, evidenceRoot, evidenceContent, signerAddress) {
+    const evidenceContentBase64 = Buffer.isBuffer(evidenceContent) ? evidenceContent.toString("base64") : Buffer.from(evidenceContent, "utf-8").toString("base64");
+    const payload = {
+      studio_address: studioAddress,
+      epoch,
+      agent_address: agentAddress,
+      data_hash: dataHash,
+      thread_root: threadRoot,
+      evidence_root: evidenceRoot,
+      evidence_content: evidenceContentBase64,
+      signer_address: signerAddress
+    };
+    const result = await this._request(
+      "POST",
+      "/workflows/work-submission",
+      payload
+    );
+    return this._parseWorkflowStatus(result);
+  }
+  /**
+   * Create a score submission workflow.
+   * POST /workflows/score-submission
+   *
+   * Supports two modes:
+   * - DIRECT (default): Simple direct scoring, requires workerAddress
+   * - COMMIT_REVEAL: Commit-reveal pattern, requires salt
+   *
+   * @param studioAddress - Ethereum address of the studio
+   * @param epoch - Epoch number
+   * @param validatorAddress - Ethereum address of the validator
+   * @param dataHash - Bytes32 hash of the work being scored (as hex string)
+   * @param scores - Array of dimension scores (0-10000 basis points)
+   * @param signerAddress - Ethereum address of the signer
+   * @param options - Additional options (workerAddress, salt, mode)
+   */
+  async submitScore(studioAddress, epoch, validatorAddress, dataHash, scores, signerAddress, options) {
+    const mode = options?.mode ?? "direct" /* DIRECT */;
+    if (mode === "direct" /* DIRECT */ && !options?.workerAddress) {
+      throw new Error("workerAddress is required for DIRECT score scoring mode");
+    }
+    if (mode === "commit_reveal" /* COMMIT_REVEAL */ && !options?.salt) {
+      throw new Error("salt is required for COMMIT_REVEAL score scoring mode");
+    }
+    const payload = {
+      studio_address: studioAddress,
+      epoch,
+      validator_address: validatorAddress,
+      data_hash: dataHash,
+      scores,
+      signer_address: signerAddress,
+      mode,
+      salt: options?.salt ?? "0x" + "0".repeat(64)
+    };
+    if (options?.workerAddress) {
+      payload.worker_address = options.workerAddress;
+    }
+    const result = await this._request(
+      "POST",
+      "/workflows/score-submission",
+      payload
+    );
+    return this._parseWorkflowStatus(result);
+  }
+  /**
+   * Create a close epoch workflow.
+   * POST /workflows/close-epoch
+   *
+   * This is economically final — cannot be undone.
+   *
+   * @param studioAddress - Ethereum address of the studio
+   * @param epoch - Epoch number to close
+   * @param signerAddress - Ethereum address of the signer
+   */
+  async closeEpoch(studioAddress, epoch, signerAddress) {
+    const payload = {
+      studio_address: studioAddress,
+      epoch,
+      signer_address: signerAddress
+    };
+    const result = await this._request(
+      "POST",
+      "/workflows/close-epoch",
+      payload
+    );
+    return this._parseWorkflowStatus(result);
+  }
+  // ===========================================================================
+  // Workflow Status
+  // ===========================================================================
+  /**
+   * Get workflow status by ID.
+   * GET /workflows/{id}
+   */
+  async getWorkflow(workflowId) {
+    const result = await this._request("GET", `/workflows/${workflowId}`);
+    return this._parseWorkflowStatus(result);
+  }
+  /**
+   * List workflows with optional filters.
+   * GET /workflows?studio=&state=&type=
+   */
+  async listWorkflows(options) {
+    const params = [];
+    if (options?.studio) params.push(`studio=${options.studio}`);
+    if (options?.state) params.push(`state=${options.state}`);
+    if (options?.workflowType) params.push(`type=${options.workflowType}`);
+    const queryString = params.length > 0 ? `?${params.join("&")}` : "";
+    const result = await this._request(
+      "GET",
+      `/workflows${queryString}`
+    );
+    return (result.workflows || []).map((w) => this._parseWorkflowStatus(w));
+  }
+  // ===========================================================================
+  // Polling and Waiting
+  // ===========================================================================
+  /**
+   * Poll workflow until it reaches a terminal state.
+   *
+   * @param workflowId - UUID of the workflow
+   * @param options - Polling options
+   * @throws WorkflowFailedError - If workflow reaches FAILED state
+   * @throws GatewayTimeoutError - If maxWait exceeded
+   */
+  async waitForCompletion(workflowId, options) {
+    const maxWait = options?.maxWait || this.maxPollTime;
+    const pollInterval = options?.pollInterval || this.pollInterval;
+    const startTime = Date.now();
+    while (true) {
+      const status = await this.getWorkflow(workflowId);
+      if (options?.onProgress) {
+        options.onProgress(status);
+      }
+      if (status.state === "COMPLETED" /* COMPLETED */) {
+        return status;
+      }
+      if (status.state === "FAILED" /* FAILED */) {
+        throw new WorkflowFailedError(workflowId, status.error);
+      }
+      const elapsed = Date.now() - startTime;
+      if (elapsed >= maxWait) {
+        throw new GatewayTimeoutError(
+          workflowId,
+          `Workflow ${workflowId} did not complete within ${maxWait} ms.Current state: ${status.state}, step: ${status.step}`,
+          status
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+  }
+  // ===========================================================================
+  // Convenience Methods (submit + wait)
+  // ===========================================================================
+  /**
+   * Submit work and wait for completion.
+   */
+  async submitWorkAndWait(studioAddress, epoch, agentAddress, dataHash, threadRoot, evidenceRoot, evidenceContent, signerAddress, options) {
+    const workflow = await this.submitWork(
+      studioAddress,
+      epoch,
+      agentAddress,
+      dataHash,
+      threadRoot,
+      evidenceRoot,
+      evidenceContent,
+      signerAddress
+    );
+    return this.waitForCompletion(workflow.workflowId, options);
+  }
+  /**
+   * Submit score and wait for completion.
+   */
+  async submitScoreAndWait(studioAddress, epoch, validatorAddress, dataHash, scores, signerAddress, options) {
+    const workerAddress = options?.workerAddress ?? options?.workAddress;
+    const workflow = await this.submitScore(
+      studioAddress,
+      epoch,
+      validatorAddress,
+      dataHash,
+      scores,
+      signerAddress,
+      {
+        workerAddress,
+        salt: options?.salt,
+        mode: options?.mode
+      }
+    );
+    return this.waitForCompletion(workflow.workflowId, { onProgress: options?.onProgress });
+  }
+  /**
+   * Close epoch and wait for completion.
+   */
+  async closeEpochAndWait(studioAddress, epoch, signerAddress, options) {
+    const workflow = await this.closeEpoch(studioAddress, epoch, signerAddress);
+    return this.waitForCompletion(workflow.workflowId, options);
+  }
+  // ===========================================================================
+  // Read API — Studio Work Discovery
+  // ===========================================================================
+  /**
+   * Fetch pending (unfinalized) work for a studio from the gateway.
+   *
+   * @param studioAddress - 0x-prefixed studio contract address
+   * @param options - Optional limit/offset for pagination
+   * @returns Typed pending work response
+   */
+  async getPendingWork(studioAddress, options) {
+    const limit = options?.limit ?? 20;
+    const offset = options?.offset ?? 0;
+    const url = `${this.gatewayUrl}/v1/studio/${studioAddress}/work?status=pending&limit=${limit}&offset=${offset}`;
+    try {
+      const response = await axios__default.default.get(url, {
+        timeout: this.timeout,
+        headers: this._buildHeaders()
+      });
+      return response.data;
+    } catch (error) {
+      const axiosErr = error;
+      if (axiosErr.code === "ECONNREFUSED" || axiosErr.code === "ENOTFOUND" || !axiosErr.response) {
+        throw new GatewayConnectionError(
+          `ChaosChain gateway unreachable at ${this.gatewayUrl}. Check GATEWAY_URL.`
+        );
+      }
+      if (axiosErr.response) {
+        throw new GatewayError(
+          `Gateway returned ${axiosErr.response.status}: ${JSON.stringify(axiosErr.response.data)}`
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * Fetch full evidence graph for a work submission.
+   * Endpoint: GET /v1/work/{hash}/evidence
+   */
+  async getWorkEvidence(workHash) {
+    const url = `${this.gatewayUrl}/v1/work/${workHash}/evidence`;
+    try {
+      const response = await axios__default.default.get(url, {
+        timeout: this.timeout,
+        headers: this._buildHeaders()
+      });
+      return response.data;
+    } catch (error) {
+      const axiosErr = error;
+      if (axiosErr.code === "ECONNREFUSED" || axiosErr.code === "ENOTFOUND" || !axiosErr.response) {
+        throw new GatewayConnectionError(
+          `ChaosChain gateway unreachable at ${this.gatewayUrl}. Check GATEWAY_URL.`
+        );
+      }
+      if (axiosErr.response) {
+        throw new GatewayError(
+          `Gateway returned ${axiosErr.response.status}: ${JSON.stringify(axiosErr.response.data)}`
+        );
+      }
+      throw error;
+    }
+  }
+};
+
+exports.GatewayClient = GatewayClient;
+exports.GatewayConnectionError = GatewayConnectionError;
+exports.GatewayError = GatewayError;
+exports.GatewayTimeoutError = GatewayTimeoutError;
+exports.WorkflowFailedError = WorkflowFailedError;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map