@proofchain/sdk 1.2.0 → 2.0.0

package/dist/index.mjs

@@ -1,347 +1,2080 @@
-// src/client.ts
-var AttestationClientError = class extends Error {
-  constructor(message, status, body) {
+// src/errors.ts
+var ProofChainError = class extends Error {
+  constructor(message, statusCode, responseBody) {
     super(message);
-    this.status = status;
-    this.body = body;
-    this.name = "AttestationClientError";
+    this.name = "ProofChainError";
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
   }
 };
-var AttestationClient = class {
-  constructor(config) {
-    this.baseUrl = config.baseUrl.replace(/\/$/, "");
-    this.accessToken = config.accessToken;
-    this.timeout = config.timeout ?? 3e4;
-  }
-  // ============ Internal Methods ============
-  async request(method, path, body, options) {
-    const url = `${this.baseUrl}${path}`;
+var AuthenticationError = class extends ProofChainError {
+  constructor(message = "Invalid or missing API key") {
+    super(message, 401);
+    this.name = "AuthenticationError";
+  }
+};
+var AuthorizationError = class extends ProofChainError {
+  constructor(message = "Access denied") {
+    super(message, 403);
+    this.name = "AuthorizationError";
+  }
+};
+var NotFoundError = class extends ProofChainError {
+  constructor(message = "Resource not found") {
+    super(message, 404);
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends ProofChainError {
+  constructor(message = "Validation error", errors = []) {
+    super(message, 422);
+    this.name = "ValidationError";
+    this.errors = errors;
+  }
+};
+var RateLimitError = class extends ProofChainError {
+  constructor(retryAfter) {
+    super("Rate limit exceeded", 429);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var ServerError = class extends ProofChainError {
+  constructor(message = "Server error", statusCode = 500) {
+    super(message, statusCode);
+    this.name = "ServerError";
+  }
+};
+var NetworkError = class extends ProofChainError {
+  constructor(message = "Network error", cause) {
+    super(message);
+    this.name = "NetworkError";
+    this.cause = cause;
+  }
+};
+var TimeoutError = class extends ProofChainError {
+  constructor(message = "Request timed out") {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+
+// src/http.ts
+var DEFAULT_BASE_URL = "https://api.proofchain.co.za";
+var DEFAULT_TIMEOUT = 3e4;
+var USER_AGENT = "proofchain-js/0.1.0";
+var HttpClient = class {
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.timeout = options.timeout || DEFAULT_TIMEOUT;
+    this.maxRetries = options.maxRetries ?? 3;
+  }
+  getHeaders() {
+    return {
+      "X-API-Key": this.apiKey,
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENT
+    };
+  }
+  async handleResponse(response) {
+    const contentType = response.headers.get("content-type");
+    const isJson = contentType?.includes("application/json");
+    if (response.ok) {
+      if (response.status === 204 || !isJson) {
+        return {};
+      }
+      return response.json();
+    }
+    const body = isJson ? await response.json().catch(() => ({})) : {};
+    const message = body.detail || body.message || `HTTP ${response.status}`;
+    switch (response.status) {
+      case 401:
+        throw new AuthenticationError(message);
+      case 403:
+        throw new AuthorizationError(message);
+      case 404:
+        throw new NotFoundError(message);
+      case 422:
+      case 400:
+        throw new ValidationError(message, body.errors);
+      case 429:
+        const retryAfter = response.headers.get("Retry-After");
+        throw new RateLimitError(retryAfter ? parseInt(retryAfter, 10) : void 0);
+      default:
+        if (response.status >= 500) {
+          throw new ServerError(message, response.status);
+        }
+        throw new ProofChainError(message, response.status, body);
+    }
+  }
+  async fetchWithRetry(url, options, retries = 0) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-    const headers = {
-      "Content-Type": "application/json",
-      ...options?.headers
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return this.handleResponse(response);
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof ProofChainError) {
+        if (error instanceof RateLimitError && retries < this.maxRetries) {
+          const delay = Math.min((error.retryAfter || 1) * 1e3, 6e4);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          return this.fetchWithRetry(url, options, retries + 1);
+        }
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new TimeoutError();
+        }
+        if (retries < this.maxRetries) {
+          await new Promise((resolve) => setTimeout(resolve, 1e3 * (retries + 1)));
+          return this.fetchWithRetry(url, options, retries + 1);
+        }
+        throw new NetworkError(error.message, error);
+      }
+      throw new NetworkError("Unknown error");
+    }
+  }
+  async request(method, path, options = {}) {
+    let url = `${this.baseUrl}${path}`;
+    if (options.params) {
+      const searchParams = new URLSearchParams();
+      for (const [key, value] of Object.entries(options.params)) {
+        if (value !== void 0) {
+          searchParams.append(key, String(value));
+        }
+      }
+      const queryString = searchParams.toString();
+      if (queryString) {
+        url += `?${queryString}`;
+      }
+    }
+    const fetchOptions = {
+      method,
+      headers: this.getHeaders()
     };
-    if (this.accessToken) {
-      headers["Authorization"] = `Bearer ${this.accessToken}`;
+    if (options.body) {
+      fetchOptions.body = JSON.stringify(options.body);
     }
+    return this.fetchWithRetry(url, fetchOptions);
+  }
+  async requestMultipart(path, formData) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "X-API-Key": this.apiKey,
+      "User-Agent": USER_AGENT
+    };
+    return this.fetchWithRetry(url, {
+      method: "POST",
+      headers,
+      body: formData
+    });
+  }
+  async getRaw(path) {
+    const url = `${this.baseUrl}${path}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
     try {
       const response = await fetch(url, {
-        method,
-        headers,
-        body: body ? JSON.stringify(body) : void 0,
-        signal: options?.signal ?? controller.signal
+        method: "GET",
+        headers: {
+          "X-API-Key": this.apiKey,
+          "User-Agent": USER_AGENT
+        },
+        signal: controller.signal
       });
       clearTimeout(timeoutId);
       if (!response.ok) {
-        const errorBody = await response.json().catch(() => null);
-        throw new AttestationClientError(
-          `Request failed: ${response.status} ${response.statusText}`,
-          response.status,
-          errorBody
-        );
+        throw new ProofChainError(`HTTP ${response.status}`, response.status);
       }
-      return response.json();
+      return response.arrayBuffer();
     } catch (error) {
       clearTimeout(timeoutId);
-      if (error instanceof AttestationClientError) throw error;
-      throw new AttestationClientError(
-        `Request failed: ${error.message}`,
-        0
-      );
+      if (error instanceof ProofChainError) throw error;
+      throw new NetworkError(error.message);
+    }
+  }
+  get(path, params) {
+    return this.request("GET", path, { params });
+  }
+  post(path, body) {
+    return this.request("POST", path, { body });
+  }
+  put(path, body) {
+    return this.request("PUT", path, { body });
+  }
+  patch(path, body) {
+    return this.request("PATCH", path, { body });
+  }
+  delete(path) {
+    return this.request("DELETE", path);
+  }
+};
+
+// src/resources/vault.ts
+var VaultResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List files and folders in the vault.
+   */
+  async list(folderId) {
+    const params = {};
+    if (folderId) params.folder_id = folderId;
+    return this.http.get("/tenant/vault", params);
+  }
+  /**
+   * Upload a file to the vault.
+   */
+  async upload(request) {
+    const formData = new FormData();
+    if (request.file instanceof Blob) {
+      formData.append("file", request.file, request.filename || "file");
+    } else if (request.file instanceof ArrayBuffer) {
+      const blob = new Blob([request.file]);
+      formData.append("file", blob, request.filename || "file");
+    } else if (typeof Buffer !== "undefined" && Buffer.isBuffer(request.file)) {
+      const uint8 = new Uint8Array(request.file);
+      const blob = new Blob([uint8]);
+      formData.append("file", blob, request.filename || "file");
     }
+    formData.append("user_id", request.userId);
+    if (request.folderId) formData.append("folder_id", request.folderId);
+    formData.append("access_mode", request.accessMode || "private");
+    return this.http.requestMultipart("/tenant/vault/upload", formData);
   }
-  // ============ Auth Methods ============
-  setAccessToken(token) {
-    this.accessToken = token;
+  /**
+   * Get file details.
+   */
+  async get(fileId) {
+    return this.http.get(`/tenant/vault/files/${fileId}`);
   }
-  clearAccessToken() {
-    this.accessToken = void 0;
+  /**
+   * Download a file.
+   */
+  async download(fileId) {
+    return this.http.getRaw(`/tenant/vault/files/${fileId}/download`);
   }
-  // ============ Health ============
-  async health() {
-    return this.request("GET", "/health");
+  /**
+   * Delete a file.
+   */
+  async delete(fileId) {
+    await this.http.delete(`/tenant/vault/files/${fileId}`);
   }
-  // ============ Authentication ============
-  async requestChallenge(walletAddress) {
-    return this.request("POST", "/auth/web3/challenge", {
-      wallet_address: walletAddress
+  /**
+   * Move a file to a folder.
+   */
+  async move(fileId, folderId) {
+    return this.http.post(`/tenant/vault/files/${fileId}/move`, {
+      folder_id: folderId
     });
   }
-  async verifySignature(walletAddress, signature, message) {
-    const response = await this.request("POST", "/auth/web3/verify", {
-      wallet_address: walletAddress,
-      signature,
-      message
+  /**
+   * Create a folder.
+   */
+  async createFolder(name, parentId) {
+    return this.http.post("/tenant/vault/folders", {
+      name,
+      parent_id: parentId
     });
-    if (response.access_token) {
-      this.setAccessToken(response.access_token);
-    }
-    return response;
   }
-  // ============ Events ============
-  async createEvent(event) {
-    return this.request("POST", "/events", event);
+  /**
+   * Delete a folder.
+   */
+  async deleteFolder(folderId) {
+    await this.http.delete(`/tenant/vault/folders/${folderId}`);
   }
-  async getEvents(userId, options) {
-    const params = new URLSearchParams();
-    if (options?.limit) params.set("limit", options.limit.toString());
-    if (options?.offset) params.set("offset", options.offset.toString());
-    if (options?.eventType) params.set("event_type", options.eventType);
-    if (options?.fetchData) params.set("fetch_data", "true");
-    const query = params.toString();
-    return this.request(
-      "GET",
-      `/data/events/${userId}${query ? `?${query}` : ""}`
-    );
+  /**
+   * Get vault statistics.
+   */
+  async stats() {
+    return this.http.get("/tenant/vault/stats");
   }
-  async queryEvents(userId, query) {
-    return this.request(
-      "POST",
-      `/data/events/${userId}/query`,
-      query
-    );
+  /**
+   * Create a shareable link.
+   */
+  async share(fileId, expiresInHours) {
+    return this.http.post("/tenant/vault/share", {
+      file_id: fileId,
+      expires_in_hours: expiresInHours
+    });
+  }
+};
+
+// src/resources/search.ts
+var SearchResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Search events with filters.
+   */
+  async query(request = {}) {
+    return this.http.post("/search", {
+      filters: request.filters,
+      offset: request.offset,
+      limit: request.limit,
+      include_data: request.includeData
+    });
+  }
+  /**
+   * Quick search across all fields.
+   */
+  async quick(query, limit = 20) {
+    return this.http.get("/search/quick", { q: query, limit });
+  }
+  /**
+   * Get events for a specific user.
+   */
+  async byUser(userId, limit, offset) {
+    return this.http.get(`/search/by-user/${userId}`, { limit, offset });
+  }
+  /**
+   * Get event by certificate ID.
+   */
+  async byCertificate(certificateId) {
+    return this.http.get(`/search/by-certificate/${certificateId}`);
+  }
+  /**
+   * Get faceted aggregations.
+   */
+  async facets(fromDate, toDate) {
+    return this.http.get("/search/facets", {
+      from_date: fromDate,
+      to_date: toDate
+    });
+  }
+  /**
+   * Get search statistics.
+   */
+  async stats() {
+    return this.http.get("/search/stats");
   }
-  // ============ Merkle Tree ============
-  async rebuildMerkleTree(userId) {
-    return this.request("POST", `/merkle/rebuild/${userId}`);
+};
+
+// src/resources/verify.ts
+var VerifyResource = class {
+  constructor(http) {
+    this.http = http;
   }
-  async getMerkleRoot(userId) {
-    return this.request("GET", `/merkle/root/${userId}`);
+  /**
+   * Verify a certificate by ID.
+   */
+  async certificate(certificateId) {
+    return this.http.get(`/verify/cert/${certificateId}`);
   }
-  async getMerkleProof(userId, ipfsHash) {
-    return this.request("GET", `/merkle/proof/${userId}/${ipfsHash}`);
+  /**
+   * Verify an event by IPFS hash.
+   */
+  async event(ipfsHash) {
+    return this.http.get(`/verify/event/${ipfsHash}`);
   }
-  async verifyMerkleProof(leaf, proof, root) {
-    return this.request("POST", "/merkle/verify", {
+  /**
+   * Verify a Merkle proof.
+   */
+  async proof(leaf, proof, root) {
+    return this.http.post("/verify/proof", {
       leaf,
       proof,
       root
     });
   }
-  // ============ Wallets ============
-  async linkWallet(request) {
-    return this.request("POST", "/wallet/link", request);
+  /**
+   * Verify a batch by ID.
+   */
+  async batch(batchId) {
+    return this.http.get(`/verify/batch/${batchId}`);
+  }
+  /**
+   * Get batch proof for an event.
+   */
+  async eventBatchProof(eventId) {
+    return this.http.get(`/verify/event/${eventId}/batch-proof`);
+  }
+  /**
+   * Batch verify multiple items.
+   */
+  async batchVerify(items) {
+    return this.http.post("/verify/batch", { items });
+  }
+};
+
+// src/resources/tenant.ts
+var TenantResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all API keys.
+   */
+  async listApiKeys() {
+    return this.http.get("/tenant/api-keys");
+  }
+  /**
+   * Create a new API key.
+   */
+  async createApiKey(request) {
+    return this.http.post("/tenant/api-keys", {
+      name: request.name,
+      permissions: request.permissions,
+      expires_in_days: request.expiresInDays
+    });
+  }
+  /**
+   * Delete an API key.
+   */
+  async deleteApiKey(keyId) {
+    await this.http.delete(`/tenant/api-keys/${keyId}`);
   }
-  async getWalletStatus(userId) {
-    return this.request("GET", `/wallet/status/${userId}`);
+  /**
+   * Get detailed usage statistics.
+   */
+  async usageDetailed(fromDate, toDate) {
+    return this.http.get("/tenant/usage/detailed", {
+      from_date: fromDate,
+      to_date: toDate
+    });
   }
-  // ============ Quests ============
   /**
-   * List available quests for a user
-   * @param userId - End user external ID
-   * @param options - Filter options
+   * Get tenant context.
    */
-  async getAvailableQuests(userId, options) {
-    const params = new URLSearchParams();
-    params.set("user_id", userId);
-    if (options?.category) params.set("category", options.category);
-    if (options?.limit) params.set("limit", options.limit.toString());
-    return this.request(
-      "GET",
-      `/quests/available?${params.toString()}`
-    );
+  async context() {
+    return this.http.get("/tenant/context");
   }
   /**
-   * Get a specific quest by ID with all steps
-   * @param questId - Quest ID
+   * Get blockchain statistics.
    */
-  async getQuest(questId) {
-    return this.request("GET", `/quests/${questId}`);
+  async blockchainStats() {
+    return this.http.get("/tenant/blockchain/stats");
   }
   /**
-   * Start a quest for a user
-   * @param questId - Quest ID
-   * @param userId - End user external ID
+   * Verify a certificate on the blockchain.
    */
-  async startQuest(questId, userId) {
-    return this.request(
-      "POST",
-      `/quests/${questId}/start?user_id=${encodeURIComponent(userId)}`,
-      {}
-    );
+  async blockchainVerify(certificateId) {
+    return this.http.get(`/tenant/blockchain/verify/${certificateId}`);
   }
   /**
-   * Get user's progress on a specific quest
-   * @param questId - Quest ID
-   * @param userId - End user external ID
+   * List blockchain certificates.
    */
-  async getQuestProgress(questId, userId) {
-    return this.request(
-      "GET",
-      `/quests/${questId}/progress/${encodeURIComponent(userId)}`
-    );
+  async blockchainCertificates(limit, offset) {
+    return this.http.get("/tenant/blockchain/certificates", {
+      limit,
+      offset
+    });
   }
   /**
-   * Get all quest progress for a user
-   * @param userId - End user external ID
-   * @param status - Optional status filter
+   * Force batch settlement.
    */
-  async getUserQuestProgress(userId, status) {
-    const params = new URLSearchParams();
-    if (status) params.set("status", status);
-    const query = params.toString();
-    return this.request(
-      "GET",
-      `/quests/user/${encodeURIComponent(userId)}/progress${query ? `?${query}` : ""}`
-    );
+  async forceBatch() {
+    return this.http.post("/tenant/events/force-batch");
   }
   /**
-   * Complete or increment a quest step
-   * @param questId - Quest ID
-   * @param userId - End user external ID
-   * @param stepIndex - Step index (0-based)
-   * @param options - Completion options
+   * Settle all pending events.
    */
-  async completeQuestStep(questId, userId, stepIndex, options) {
-    const params = new URLSearchParams();
-    if (options?.count) params.set("count", options.count.toString());
-    if (options?.value) params.set("value", options.value);
-    const query = params.toString();
-    return this.request(
-      "POST",
-      `/quests/${questId}/progress/${encodeURIComponent(userId)}/step/${stepIndex}/complete${query ? `?${query}` : ""}`,
-      {}
-    );
+  async settleAll() {
+    return this.http.post("/tenant/events/settle-all");
+  }
+  /**
+   * Settle a specific event.
+   */
+  async settleEvent(eventId) {
+    return this.http.post(`/tenant/events/${eventId}/settle`);
   }
 };
 
-// src/contract.ts
-import { ethers } from "ethers";
-var ATTESTATION_REGISTRY_ABI = [
-  // Read functions
-  "function attestationRoots(address wallet) view returns (bytes32 merkleRoot, uint256 eventCount, uint256 lastUpdated, string latestIpfsHash)",
-  "function getRoot(address wallet) view returns (bytes32 root, uint256 eventCount, uint256 lastUpdated, string latestIpfsHash)",
-  "function getHistoryCount(address wallet) view returns (uint256 count)",
-  "function getHistoricalRoot(address wallet, uint256 index) view returns (bytes32 root, uint256 eventCount, uint256 timestamp)",
-  "function verifyAttestation(address wallet, bytes32 leaf, bytes32[] proof) view returns (bool valid)",
-  "function computeLeaf(string ipfsHash, string eventType, uint256 timestamp) pure returns (bytes32 leaf)",
-  "function getWalletByIpfsHash(string ipfsHash) view returns (address wallet)",
-  "function authorizedUpdaters(address) view returns (bool)",
-  "function owner() view returns (address)",
-  // Write functions
-  "function updateRoot(address wallet, bytes32 newRoot, uint256 eventCount, string latestIpfsHash)",
-  "function batchUpdateRoots(address[] wallets, bytes32[] roots, uint256[] eventCounts, string[] ipfsHashes)",
-  "function setAuthorizedUpdater(address updater, bool authorized)",
-  // Events
-  "event RootUpdated(address indexed wallet, bytes32 indexed newRoot, bytes32 indexed previousRoot, uint256 eventCount, string latestIpfsHash)",
-  "event AttestationVerified(address indexed wallet, bytes32 indexed leaf, string ipfsHash, bool valid)",
-  "event UpdaterAuthorized(address indexed updater, bool authorized)"
-];
-var AttestationRegistryContract = class {
-  constructor(contractAddress, signerOrProvider) {
-    this.contract = new ethers.Contract(
-      contractAddress,
-      ATTESTATION_REGISTRY_ABI,
-      signerOrProvider
-    );
-    if ("getAddress" in signerOrProvider) {
-      this.signer = signerOrProvider;
-    }
+// src/passports.ts
+var PassportClient = class {
+  constructor(http) {
+    this.http = http;
   }
-  // ============ Read Functions ============
-  async getRoot(wallet) {
-    const [merkleRoot, eventCount, lastUpdated, latestIpfsHash] = await this.contract.getRoot(wallet);
-    return {
-      merkleRoot,
-      eventCount,
-      lastUpdated,
-      latestIpfsHash
-    };
+  // ---------------------------------------------------------------------------
+  // Passports
+  // ---------------------------------------------------------------------------
+  /**
+   * List all passports for the tenant
+   */
+  async list(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.append("limit", options.limit.toString());
+    if (options.offset) params.append("offset", options.offset.toString());
+    return this.http.get(`/passports?${params.toString()}`);
   }
-  async getHistoryCount(wallet) {
-    return this.contract.getHistoryCount(wallet);
+  /**
+   * Get a passport by user ID
+   */
+  async get(userId) {
+    return this.http.get(`/passports/${encodeURIComponent(userId)}`);
   }
-  async getHistoricalRoot(wallet, index) {
-    const [merkleRoot, eventCount, timestamp] = await this.contract.getHistoricalRoot(wallet, index);
-    return { merkleRoot, eventCount, timestamp };
+  /**
+   * Get a passport with all field values
+   */
+  async getWithFields(userId) {
+    const passport = await this.get(userId);
+    const fields = await this.getFieldValues(userId);
+    return { ...passport, field_values: fields };
   }
-  async verifyAttestation(wallet, leaf, proof) {
-    return this.contract.verifyAttestation(wallet, leaf, proof);
+  /**
+   * Create a new passport for a user
+   */
+  async create(data) {
+    return this.http.post("/passports", data);
   }
-  async computeLeaf(ipfsHash, eventType, timestamp) {
-    return this.contract.computeLeaf(ipfsHash, eventType, timestamp);
+  /**
+   * Update a passport
+   */
+  async update(userId, data) {
+    return this.http.put(`/passports/${encodeURIComponent(userId)}`, data);
   }
-  async getWalletByIpfsHash(ipfsHash) {
-    return this.contract.getWalletByIpfsHash(ipfsHash);
+  /**
+   * Delete a passport
+   */
+  async delete(userId) {
+    await this.http.delete(`/passports/${encodeURIComponent(userId)}`);
   }
-  async isAuthorizedUpdater(address) {
-    return this.contract.authorizedUpdaters(address);
+  /**
+   * Add points to a passport
+   */
+  async addPoints(userId, points, reason) {
+    return this.http.post(`/passports/${encodeURIComponent(userId)}/add-points`, {
+      points,
+      reason
+    });
   }
-  async owner() {
-    return this.contract.owner();
+  /**
+   * Level up a passport
+   */
+  async levelUp(userId) {
+    return this.http.post(`/passports/${encodeURIComponent(userId)}/level-up`, {});
   }
-  // ============ Write Functions ============
-  async updateRoot(wallet, newRoot, eventCount, latestIpfsHash) {
-    if (!this.signer) {
-      throw new Error("Signer required for write operations");
-    }
-    return this.contract.updateRoot(wallet, newRoot, eventCount, latestIpfsHash);
+  /**
+   * Link a wallet address to a passport
+   */
+  async linkWallet(userId, walletAddress) {
+    return this.update(userId, { wallet_address: walletAddress });
   }
-  async batchUpdateRoots(wallets, roots, eventCounts, ipfsHashes) {
-    if (!this.signer) {
-      throw new Error("Signer required for write operations");
-    }
-    return this.contract.batchUpdateRoots(wallets, roots, eventCounts, ipfsHashes);
+  // ---------------------------------------------------------------------------
+  // Field Values
+  // ---------------------------------------------------------------------------
+  /**
+   * Get all field values for a passport
+   */
+  async getFieldValues(userId) {
+    return this.http.get(`/passports/${encodeURIComponent(userId)}/fields`);
   }
-  async setAuthorizedUpdater(updater, authorized) {
-    if (!this.signer) {
-      throw new Error("Signer required for write operations");
-    }
-    return this.contract.setAuthorizedUpdater(updater, authorized);
-  }
-  // ============ Event Listeners ============
-  onRootUpdated(callback, filter) {
-    const eventFilter = this.contract.filters.RootUpdated(filter?.wallet);
-    this.contract.on(eventFilter, (wallet, newRoot, previousRoot, eventCount, latestIpfsHash) => {
-      callback({
-        wallet,
-        newRoot,
-        previousRoot,
-        eventCount,
-        latestIpfsHash
-      });
+  /**
+   * Set a field value manually
+   */
+  async setFieldValue(userId, fieldKey, value) {
+    await this.http.put(`/passports/${encodeURIComponent(userId)}/fields/${fieldKey}`, value);
+  }
+  /**
+   * Recompute all computed field values
+   */
+  async recomputeFields(userId) {
+    return this.http.post(`/passports/${encodeURIComponent(userId)}/recompute`, {});
+  }
+  /**
+   * Assign a template to a passport
+   */
+  async assignTemplate(userId, templateId) {
+    await this.http.post(`/passports/${encodeURIComponent(userId)}/assign-template/${templateId}`, {});
+  }
+  // ---------------------------------------------------------------------------
+  // Templates
+  // ---------------------------------------------------------------------------
+  /**
+   * List all passport templates
+   */
+  async listTemplates() {
+    return this.http.get("/passports/templates");
+  }
+  /**
+   * Get a template by ID
+   */
+  async getTemplate(templateId) {
+    return this.http.get(`/passports/templates/${templateId}`);
+  }
+  /**
+   * Create a new template
+   */
+  async createTemplate(data) {
+    return this.http.post("/passports/templates", data);
+  }
+  /**
+   * Add a field to a template
+   */
+  async addTemplateField(templateId, field) {
+    return this.http.post(`/passports/templates/${templateId}/fields`, field);
+  }
+  /**
+   * Delete a template
+   */
+  async deleteTemplate(templateId) {
+    await this.http.delete(`/passports/templates/${templateId}`);
+  }
+  // ---------------------------------------------------------------------------
+  // Badges
+  // ---------------------------------------------------------------------------
+  /**
+   * List all badges
+   */
+  async listBadges() {
+    return this.http.get("/passports/badges");
+  }
+  /**
+   * Create a badge
+   */
+  async createBadge(data) {
+    return this.http.post("/passports/badges", data);
+  }
+  /**
+   * Award a badge to a user
+   */
+  async awardBadge(userId, badgeId, metadata) {
+    return this.http.post(`/passports/${encodeURIComponent(userId)}/badges/${badgeId}`, {
+      metadata
     });
   }
-  removeAllListeners() {
-    this.contract.removeAllListeners();
+  /**
+   * Get badges earned by a user
+   */
+  async getUserBadges(userId) {
+    return this.http.get(`/passports/${encodeURIComponent(userId)}/badges`);
+  }
+  // ---------------------------------------------------------------------------
+  // Achievements
+  // ---------------------------------------------------------------------------
+  /**
+   * List all achievements
+   */
+  async listAchievements() {
+    return this.http.get("/passports/achievements");
+  }
+  /**
+   * Create an achievement
+   */
+  async createAchievement(data) {
+    return this.http.post("/passports/achievements", data);
+  }
+  /**
+   * Get achievements for a user
+   */
+  async getUserAchievements(userId) {
+    return this.http.get(`/passports/${encodeURIComponent(userId)}/achievements`);
+  }
+  /**
+   * Update achievement progress
+   */
+  async updateAchievementProgress(userId, achievementId, progress) {
+    return this.http.put(
+      `/passports/${encodeURIComponent(userId)}/achievements/${achievementId}`,
+      { progress }
+    );
   }
-  // ============ Utilities ============
-  static computeLeafOffchain(ipfsHash, eventType, timestamp) {
-    return ethers.keccak256(
-      ethers.solidityPacked(
-        ["string", "string", "uint256"],
-        [ipfsHash, eventType, timestamp]
-      )
+  // ---------------------------------------------------------------------------
+  // History
+  // ---------------------------------------------------------------------------
+  /**
+   * Get passport history/activity log
+   */
+  async getHistory(userId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.append("limit", options.limit.toString());
+    if (options.offset) params.append("offset", options.offset.toString());
+    return this.http.get(
+      `/passports/${encodeURIComponent(userId)}/history?${params.toString()}`
     );
   }
-  static verifyProofOffchain(leaf, proof, root) {
-    let computedHash = leaf;
-    for (const proofElement of proof) {
-      if (computedHash < proofElement) {
-        computedHash = ethers.keccak256(
-          ethers.solidityPacked(["bytes32", "bytes32"], [computedHash, proofElement])
-        );
-      } else {
-        computedHash = ethers.keccak256(
-          ethers.solidityPacked(["bytes32", "bytes32"], [proofElement, computedHash])
-        );
-      }
-    }
-    return computedHash === root;
+  // ---------------------------------------------------------------------------
+  // Passport V2 (Data View Integration)
+  // ---------------------------------------------------------------------------
+  /**
+   * Get passport data for a user using Passport V2 API.
+   * This integrates with custom data views for dynamic computation.
+   * 
+   * @param userId - The user ID
+   * @param passportId - Optional specific passport definition ID
+   * @returns Passport data with computed fields from data view
+   */
+  async getPassportV2(userId, passportId) {
+    const params = passportId ? `?passport_id=${passportId}` : "";
+    return this.http.get(`/passport-v2/users/${encodeURIComponent(userId)}${params}`);
   }
-};
-
-// src/index.ts
-function createClient(baseUrl, accessToken) {
-  return new AttestationClient({
-    baseUrl,
-    accessToken
-  });
-}
+  /**
+   * Get passport view data for a user (alias for getPassportV2).
+   * 
+   * @param userId - The user ID
+   * @param passportId - Optional specific passport definition ID
+   * @returns Passport data with computed fields from data view
+   */
+  async getPassportView(userId, passportId) {
+    return this.getPassportV2(userId, passportId);
+  }
+  /**
+   * Get user milestones from Passport V2.
+   * 
+   * @param userId - The user ID
+   * @param passportId - Optional passport ID to filter milestones
+   * @returns List of milestones achieved by the user
+   */
+  async getMilestones(userId, passportId) {
+    const params = passportId ? `?passport_id=${passportId}` : "";
+    return this.http.get(`/passport-v2/users/${encodeURIComponent(userId)}/milestones${params}`);
+  }
+  /**
+   * List available data views that can be used for passports.
+   * Includes built-in views and custom data views.
+   * 
+   * @returns List of available views with their columns
+   */
+  async listAvailableViews() {
+    return this.http.get("/passport-v2/available-views");
+  }
+  /**
+   * List passport definitions for the tenant.
+   * 
+   * @returns List of passport definitions
+   */
+  async listPassportDefinitions() {
+    return this.http.get("/passport-v2/definitions");
+  }
+  /**
+   * Create a new passport definition linked to a data view.
+   * 
+   * @param definition - The passport definition to create
+   * @returns Created passport definition
+   * 
+   * @example
+   * ```typescript
+   * const passport = await client.passports.createPassportDefinition({
+   *   name: 'Fan Engagement Passport',
+   *   description: 'Track fan engagement metrics',
+   *   data_view_id: 'builtin-fan-profile', // or custom view UUID
+   *   display_columns: ['fan_score', 'loyalty_tier', 'total_events'],
+   *   column_labels: {
+   *     fan_score: 'Engagement Score',
+   *     loyalty_tier: 'Tier',
+   *     total_events: 'Activities'
+   *   }
+   * });
+   * ```
+   */
+  async createPassportDefinition(definition) {
+    return this.http.post("/passport-v2/definitions", definition);
+  }
+};
+
+// src/wallets.ts
+var WalletClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  // ---------------------------------------------------------------------------
+  // Single Wallets
+  // ---------------------------------------------------------------------------
+  /**
+   * Create a single wallet for a user
+   */
+  async create(data) {
+    return this.http.post("/wallets", data);
+  }
+  /**
+   * Get a wallet by ID
+   */
+  async get(walletId) {
+    return this.http.get(`/wallets/${walletId}`);
+  }
+  /**
+   * List wallets for a user
+   */
+  async listByUser(userId) {
+    return this.http.get(`/wallets/user/${encodeURIComponent(userId)}`);
+  }
+  /**
+   * Get wallet statistics
+   */
+  async stats() {
+    return this.http.get("/wallets/stats");
+  }
+  // ---------------------------------------------------------------------------
+  // Dual Wallets (EOA + Smart Account)
+  // ---------------------------------------------------------------------------
+  /**
+   * Create dual wallets (EOA asset wallet + Smart Account) for a user
+   */
+  async createDual(data) {
+    return this.http.post("/wallets/dual", data);
+  }
+  /**
+   * Bulk create dual wallets for multiple users
+   */
+  async createDualBulk(userIds, network = "base-sepolia") {
+    return this.http.post("/wallets/dual/bulk", {
+      user_ids: userIds,
+      network
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Balances
+  // ---------------------------------------------------------------------------
+  /**
+   * Get wallet balance
+   */
+  async getBalance(walletId) {
+    return this.http.get(`/wallets/${walletId}/balance`);
+  }
+  /**
+   * Get comprehensive wallet information in a single call.
+   * 
+   * Returns everything about a wallet:
+   * - Basic wallet details (address, type, network)
+   * - Token balances (native + ERC20)
+   * - NFT holdings with metadata
+   * - Recent activity (swaps, transfers)
+   * 
+   * @param walletId - Wallet ID to query
+   * @param options - Control what data is included
+   */
+  async getInfo(walletId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.includeBalances !== void 0) {
+      params.set("include_balances", String(options.includeBalances));
+    }
+    if (options.includeNfts !== void 0) {
+      params.set("include_nfts", String(options.includeNfts));
+    }
+    if (options.includeActivity !== void 0) {
+      params.set("include_activity", String(options.includeActivity));
+    }
+    const query = params.toString();
+    return this.http.get(
+      `/wallets/${walletId}/info${query ? `?${query}` : ""}`
+    );
+  }
+  /**
+   * Get comprehensive summary of all wallets for a user.
+   * 
+   * Returns all wallets (EOA + Smart) with aggregated stats:
+   * - Total NFTs across all wallets
+   * - Total swaps executed
+   * - Token balances (optional)
+   * 
+   * @param userId - User ID to query
+   * @param includeBalances - Include token balances (requires Alchemy)
+   */
+  async getUserSummary(userId, includeBalances = true) {
+    return this.http.get(
+      `/wallets/user/${encodeURIComponent(userId)}/summary?include_balances=${includeBalances}`
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // Key Export
+  // ---------------------------------------------------------------------------
+  /**
+   * Export private key for an EOA wallet (requires acknowledgment)
+   */
+  async exportKey(walletId) {
+    return this.http.post(`/wallets/${walletId}/export-key`, {
+      acknowledge_warning: true
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Token Transfers
+  // ---------------------------------------------------------------------------
+  /**
+   * Transfer tokens from one address to another.
+   * 
+   * @param request - Transfer details
+   * @returns Transaction result with hash and status
+   * 
+   * @example
+   * ```typescript
+   * const result = await client.wallets.transfer({
+   *   from_address: '0x123...',
+   *   to_address: '0x456...',
+   *   amount: '0.1',
+   *   token: 'ETH',
+   *   network: 'base-sepolia',
+   * });
+   * console.log('TX Hash:', result.tx_hash);
+   * ```
+   */
+  async transfer(request) {
+    return this.http.post("/wallets/transfer", request);
+  }
+  // ---------------------------------------------------------------------------
+  // Token Swaps
+  // ---------------------------------------------------------------------------
+  /**
+   * Get a swap quote
+   */
+  async getSwapQuote(request) {
+    return this.http.post("/wallets/swaps/quote", request);
+  }
+  /**
+   * Execute a token swap
+   */
+  async executeSwap(request) {
+    return this.http.post("/wallets/swaps/execute", request);
+  }
+  // ---------------------------------------------------------------------------
+  // NFTs
+  // ---------------------------------------------------------------------------
+  /**
+   * Get NFTs for a wallet
+   */
+  async getNFTs(walletId) {
+    return this.http.get(`/wallets/${walletId}/nfts`);
+  }
+  /**
+   * Get all NFTs for a user (across all wallets)
+   */
+  async getUserNFTs(userId) {
+    return this.http.get(`/wallets/user/${encodeURIComponent(userId)}/nfts`);
+  }
+  /**
+   * Add an NFT to wallet tracking
+   */
+  async addNFT(walletId, nft) {
+    return this.http.post(`/wallets/${walletId}/nfts`, nft);
+  }
+};
+
+// src/users.ts
+var EndUsersClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List end-users with pagination and filters
+   */
+  async list(options = {}) {
+    const params = new URLSearchParams();
+    if (options.page) params.append("page", options.page.toString());
+    if (options.page_size) params.append("page_size", options.page_size.toString());
+    if (options.search) params.append("search", options.search);
+    if (options.status) params.append("status", options.status);
+    if (options.segment) params.append("segment", options.segment);
+    if (options.has_wallet !== void 0) params.append("has_wallet", options.has_wallet.toString());
+    if (options.sort_by) params.append("sort_by", options.sort_by);
+    if (options.sort_order) params.append("sort_order", options.sort_order);
+    return this.http.get(`/end-users?${params.toString()}`);
+  }
+  /**
+   * Get an end-user by ID
+   */
+  async get(userId) {
+    return this.http.get(`/end-users/${userId}`);
+  }
+  /**
+   * Get an end-user by external ID
+   */
+  async getByExternalId(externalId) {
+    return this.http.get(`/end-users/external/${encodeURIComponent(externalId)}`);
+  }
+  /**
+   * Create an end-user manually
+   */
+  async create(data) {
+    return this.http.post("/end-users", data);
+  }
+  /**
+   * Update an end-user profile
+   */
+  async update(userId, data) {
+    return this.http.patch(`/end-users/${userId}`, data);
+  }
+  /**
+   * Delete an end-user
+   */
+  async delete(userId) {
+    await this.http.delete(`/end-users/${userId}`);
+  }
+  /**
+   * Link a wallet to an end-user
+   */
+  async linkWallet(userId, request) {
+    return this.http.post(`/end-users/${userId}/wallet`, request);
+  }
+  /**
+   * Unlink wallet from an end-user
+   */
+  async unlinkWallet(userId) {
+    return this.http.delete(`/end-users/${userId}/wallet`);
+  }
+  /**
+   * Get user activity/events
+   */
+  async getActivity(userId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.page) params.append("page", options.page.toString());
+    if (options.page_size) params.append("page_size", options.page_size.toString());
+    if (options.event_type) params.append("event_type", options.event_type);
+    return this.http.get(`/end-users/${userId}/activity?${params.toString()}`);
+  }
+  /**
+   * Add points to a user
+   */
+  async addPoints(userId, points, reason) {
+    return this.http.post(`/end-users/${userId}/points`, { points, reason });
+  }
+  /**
+   * Add a segment to a user
+   */
+  async addSegment(userId, segment) {
+    return this.http.post(`/end-users/${userId}/segments`, { segment });
+  }
+  /**
+   * Remove a segment from a user
+   */
+  async removeSegment(userId, segment) {
+    return this.http.delete(`/end-users/${userId}/segments/${encodeURIComponent(segment)}`);
+  }
+  /**
+   * Merge two users (moves all data from source to target)
+   */
+  async merge(request) {
+    return this.http.post("/end-users/merge", request);
+  }
+  /**
+   * Export users as CSV
+   */
+  async export(options = {}) {
+    const params = new URLSearchParams();
+    if (options.segment) params.append("segment", options.segment);
+    if (options.format) params.append("format", options.format);
+    const response = await fetch(`/end-users/export?${params.toString()}`, {
+      headers: { "Accept": "text/csv" }
+    });
+    return response.blob();
+  }
+};
+
+// src/rewards.ts
+var RewardsClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  // ---------------------------------------------------------------------------
+  // Reward Definitions
+  // ---------------------------------------------------------------------------
+  /**
+   * List reward definitions
+   */
+  async listDefinitions(options = {}) {
+    const params = new URLSearchParams();
+    if (options.is_active !== void 0) params.append("is_active", options.is_active.toString());
+    if (options.reward_type) params.append("reward_type", options.reward_type);
+    return this.http.get(`/rewards/definitions?${params.toString()}`);
+  }
+  /**
+   * Get a reward definition by ID
+   */
+  async getDefinition(definitionId) {
+    return this.http.get(`/rewards/definitions/${definitionId}`);
+  }
+  /**
+   * Create a reward definition
+   */
+  async createDefinition(data) {
+    return this.http.post("/rewards/definitions", data);
+  }
+  /**
+   * Update a reward definition
+   */
+  async updateDefinition(definitionId, data) {
+    return this.http.patch(`/rewards/definitions/${definitionId}`, data);
+  }
+  /**
+   * Delete a reward definition
+   */
+  async deleteDefinition(definitionId) {
+    await this.http.delete(`/rewards/definitions/${definitionId}`);
+  }
+  /**
+   * Activate a reward definition
+   */
+  async activateDefinition(definitionId) {
+    return this.http.post(`/rewards/definitions/${definitionId}/activate`, {});
+  }
+  /**
+   * Deactivate a reward definition
+   */
+  async deactivateDefinition(definitionId) {
+    return this.http.post(`/rewards/definitions/${definitionId}/deactivate`, {});
+  }
+  // ---------------------------------------------------------------------------
+  // Earned Rewards
+  // ---------------------------------------------------------------------------
+  /**
+   * List earned rewards
+   */
+  async listEarned(options = {}) {
+    const params = new URLSearchParams();
+    if (options.user_id) params.append("user_id", options.user_id);
+    if (options.definition_id) params.append("definition_id", options.definition_id);
+    if (options.status) params.append("status", options.status);
+    if (options.limit) params.append("limit", options.limit.toString());
+    if (options.offset) params.append("offset", options.offset.toString());
+    return this.http.get(`/rewards/earned?${params.toString()}`);
+  }
+  /**
+   * Get earned rewards for a user
+   */
+  async getUserRewards(userId) {
+    return this.http.get(`/rewards/earned/user/${userId}`);
+  }
+  /**
+   * Manually award rewards to users
+   */
+  async awardManual(request) {
+    return this.http.post("/rewards/award", request);
+  }
+  /**
+   * Distribute pending rewards (mint NFTs, transfer tokens)
+   */
+  async distributePending(earnedRewardId) {
+    return this.http.post(`/rewards/earned/${earnedRewardId}/distribute`, {});
+  }
+  // ---------------------------------------------------------------------------
+  // Reward Assets
+  // ---------------------------------------------------------------------------
+  /**
+   * Upload an asset for a reward (image, metadata JSON)
+   */
+  async uploadAsset(definitionId, file, assetType) {
+    const formData = new FormData();
+    formData.append("file", file);
+    formData.append("asset_type", assetType);
+    return this.http.requestMultipart(
+      `/rewards/definitions/${definitionId}/assets`,
+      formData
+    );
+  }
+  /**
+   * List assets for a reward definition
+   */
+  async listAssets(definitionId) {
+    return this.http.get(`/rewards/definitions/${definitionId}/assets`);
+  }
+};
+
+// src/quests.ts
+var QuestsClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  // ---------------------------------------------------------------------------
+  // Quest CRUD
+  // ---------------------------------------------------------------------------
+  /**
+   * List quests
+   */
+  async list(options = {}) {
+    const params = new URLSearchParams();
+    if (options.status) params.append("status", options.status);
+    if (options.category) params.append("category", options.category);
+    if (options.is_public !== void 0) params.append("is_public", options.is_public.toString());
+    if (options.is_featured !== void 0) params.append("is_featured", options.is_featured.toString());
+    if (options.limit) params.append("limit", options.limit.toString());
+    if (options.offset) params.append("offset", options.offset.toString());
+    return this.http.get(`/quests?${params.toString()}`);
+  }
+  /**
+   * Get a quest by ID
+   */
+  async get(questId) {
+    return this.http.get(`/quests/${questId}`);
+  }
+  /**
+   * Get a quest by slug
+   */
+  async getBySlug(slug) {
+    return this.http.get(`/quests/slug/${encodeURIComponent(slug)}`);
+  }
+  /**
+   * Create a quest
+   */
+  async create(data) {
+    return this.http.post("/quests", data);
+  }
+  /**
+   * Update a quest
+   */
+  async update(questId, data) {
+    return this.http.put(`/quests/${questId}`, data);
+  }
+  /**
+   * Delete a quest
+   */
+  async delete(questId) {
+    await this.http.delete(`/quests/${questId}`);
+  }
+  // ---------------------------------------------------------------------------
+  // Quest Status
+  // ---------------------------------------------------------------------------
+  /**
+   * Activate a quest
+   */
+  async activate(questId) {
+    return this.http.post(`/quests/${questId}/activate`, {});
+  }
+  /**
+   * Pause a quest
+   */
+  async pause(questId) {
+    return this.http.post(`/quests/${questId}/pause`, {});
+  }
+  /**
+   * Archive a quest
+   */
+  async archive(questId) {
+    return this.http.post(`/quests/${questId}/archive`, {});
+  }
+  // ---------------------------------------------------------------------------
+  // User Progress
+  // ---------------------------------------------------------------------------
+  /**
+   * Get quest with user progress
+   */
+  async getWithProgress(questId, userId) {
+    return this.http.get(`/quests/${questId}/progress/${encodeURIComponent(userId)}`);
+  }
+  /**
+   * List quests with progress for a user
+   */
+  async listWithProgress(userId, options = {}) {
+    const params = new URLSearchParams();
+    params.append("user_id", userId);
+    if (options.status) params.append("status", options.status);
+    if (options.category) params.append("category", options.category);
+    return this.http.get(`/quests/with-progress?${params.toString()}`);
+  }
+  /**
+   * Start a quest for a user
+   */
+  async startQuest(questId, userId) {
+    return this.http.post(`/quests/${questId}/start`, { user_id: userId });
+  }
+  /**
+   * Get user's progress on a quest
+   */
+  async getUserProgress(questId, userId) {
+    return this.http.get(`/quests/${questId}/progress/${encodeURIComponent(userId)}`);
+  }
+  /**
+   * Complete a step manually
+   */
+  async completeStep(questId, userId, stepId) {
+    return this.http.post(`/quests/${questId}/steps/${stepId}/complete`, {
+      user_id: userId
+    });
+  }
+  /**
+   * Get all quest progress for a user
+   */
+  async getAllUserProgress(userId) {
+    return this.http.get(`/quests/user/${encodeURIComponent(userId)}/progress`);
+  }
+  // ---------------------------------------------------------------------------
+  // Quest Steps
+  // ---------------------------------------------------------------------------
+  /**
+   * Add a step to a quest
+   */
+  async addStep(questId, step) {
+    return this.http.post(`/quests/${questId}/steps`, step);
+  }
+  /**
+   * Update a step
+   */
+  async updateStep(questId, stepId, data) {
+    return this.http.put(`/quests/${questId}/steps/${stepId}`, data);
+  }
+  /**
+   * Delete a step
+   */
+  async deleteStep(questId, stepId) {
+    await this.http.delete(`/quests/${questId}/steps/${stepId}`);
+  }
+  /**
+   * Reorder steps
+   */
+  async reorderSteps(questId, stepIds) {
+    return this.http.post(`/quests/${questId}/steps/reorder`, { step_ids: stepIds });
+  }
+};
+
+// src/schemas.ts
+var SchemasClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List schemas
+   */
+  async list(options = {}) {
+    const params = new URLSearchParams();
+    if (options.status) params.append("status", options.status);
+    if (options.search) params.append("search", options.search);
+    if (options.limit) params.append("limit", options.limit.toString());
+    if (options.offset) params.append("offset", options.offset.toString());
+    return this.http.get(`/schemas?${params.toString()}`);
+  }
+  /**
+   * Get a schema by name and optional version
+   */
+  async get(name, version) {
+    const path = version ? `/schemas/${encodeURIComponent(name)}/${encodeURIComponent(version)}` : `/schemas/${encodeURIComponent(name)}`;
+    return this.http.get(path);
+  }
+  /**
+   * Create a schema from YAML content
+   * 
+   * Example YAML:
+   * ```yaml
+   * name: my_event
+   * version: "1.0"
+   * description: My custom event schema
+   * 
+   * fields:
+   *   user_id:
+   *     type: string
+   *     required: true
+   *   amount:
+   *     type: number
+   *     min: 0
+   *   status:
+   *     type: enum
+   *     values: [pending, completed, failed]
+   * ```
+   */
+  async create(yamlContent) {
+    return this.http.post("/schemas", { yaml_content: yamlContent });
+  }
+  /**
+   * Update a schema (creates new version)
+   */
+  async update(name, yamlContent) {
+    return this.http.put(`/schemas/${encodeURIComponent(name)}`, {
+      yaml_content: yamlContent
+    });
+  }
+  /**
+   * Delete a schema
+   */
+  async delete(name, version) {
+    const path = version ? `/schemas/${encodeURIComponent(name)}/${encodeURIComponent(version)}` : `/schemas/${encodeURIComponent(name)}`;
+    await this.http.delete(path);
+  }
+  /**
+   * Activate a schema (make it available for validation)
+   */
+  async activate(name, version) {
+    const path = version ? `/schemas/${encodeURIComponent(name)}/${encodeURIComponent(version)}/activate` : `/schemas/${encodeURIComponent(name)}/activate`;
+    return this.http.post(path, {});
+  }
+  /**
+   * Deprecate a schema
+   */
+  async deprecate(name, version) {
+    const path = version ? `/schemas/${encodeURIComponent(name)}/${encodeURIComponent(version)}/deprecate` : `/schemas/${encodeURIComponent(name)}/deprecate`;
+    return this.http.post(path, {});
+  }
+  /**
+   * Set a schema as the default for its name
+   */
+  async setDefault(name, version) {
+    return this.http.post(
+      `/schemas/${encodeURIComponent(name)}/${encodeURIComponent(version)}/set-default`,
+      {}
+    );
+  }
+  /**
+   * Validate data against a schema
+   */
+  async validate(request) {
+    return this.http.post("/schemas/validate", request);
+  }
+  /**
+   * Validate data against multiple schemas
+   */
+  async validateMultiple(schemaNames, data) {
+    return this.http.post("/schemas/validate/batch", {
+      schema_names: schemaNames,
+      data
+    });
+  }
+  /**
+   * Get schema usage statistics
+   */
+  async getUsageStats(name) {
+    return this.http.get(`/schemas/${encodeURIComponent(name)}/stats`);
+  }
+  /**
+   * Clone a schema with a new name
+   */
+  async clone(sourceName, newName, newVersion) {
+    return this.http.post(`/schemas/${encodeURIComponent(sourceName)}/clone`, {
+      new_name: newName,
+      new_version: newVersion
+    });
+  }
+};
+
+// src/dataviews.ts
+var DataViewsClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all available data views.
+   * Returns own views, public views from other tenants, and builtin views.
+   */
+  async list() {
+    return this.http.get("/data-mesh/views");
+  }
+  /**
+   * Get detailed information about a specific data view.
+   */
+  async get(viewName) {
+    return this.http.get(`/data-mesh/views/custom/${viewName}`);
+  }
+  /**
+   * Create a new custom data view.
+   * 
+   * @example
+   * ```typescript
+   * const view = await client.dataViews.create({
+   *   name: 'engagement_score',
+   *   display_name: 'User Engagement Score',
+   *   description: 'Weighted score based on user activity',
+   *   view_type: 'multi-computation',
+   *   computation: [
+   *     {
+   *       type: 'score',
+   *       name: 'activity_score',
+   *       event_types: ['page_view', 'purchase'],
+   *       event_weights: { page_view: 1, purchase: 10 },
+   *       max_score: 1000
+   *     },
+   *     {
+   *       type: 'tier',
+   *       name: 'loyalty_tier',
+   *       score_source: 'activity_score',
+   *       tiers: [
+   *         { name: 'Bronze', min: 0, max: 100 },
+   *         { name: 'Silver', min: 100, max: 500 },
+   *         { name: 'Gold', min: 500, max: 1000 }
+   *       ]
+   *     }
+   *   ]
+   * });
+   * ```
+   */
+  async create(request) {
+    return this.http.post("/data-mesh/views/custom", request);
+  }
+  /**
+   * Update an existing data view.
+   */
+  async update(viewName, request) {
+    return this.http.patch(`/data-mesh/views/custom/${viewName}`, request);
+  }
+  /**
+   * Delete a data view.
+   */
+  async delete(viewName) {
+    await this.http.delete(`/data-mesh/views/custom/${viewName}`);
+  }
+  /**
+   * Execute a data view for a specific user.
+   * 
+   * The identifier can be either:
+   * - A wallet address (0x...) - queries web3-bound events
+   * - A user_id - queries all events for that user
+   * 
+   * @example
+   * ```typescript
+   * // By user ID
+   * const result = await client.dataViews.execute('user-123', 'fan_score');
+   * 
+   * // By wallet address
+   * const result = await client.dataViews.execute('0x123...abc', 'fan_score');
+   * 
+   * console.log('Data:', result.data);
+   * console.log('Events processed:', result.total_events);
+   * ```
+   */
+  async execute(identifier, viewName) {
+    return this.http.get(
+      `/data-mesh/views/${identifier}/custom/${viewName}`
+    );
+  }
+  /**
+   * Preview a data view computation without saving it.
+   * Useful for testing computation configurations before creating a view.
+   * 
+   * @example
+   * ```typescript
+   * const preview = await client.dataViews.preview({
+   *   wallet_address: '0x123...',
+   *   computation: {
+   *     type: 'score',
+   *     event_types: ['purchase', 'login'],
+   *     event_weights: { purchase: 10, login: 1 },
+   *     max_score: 1000
+   *   },
+   *   time_window_days: 30
+   * });
+   * ```
+   */
+  async preview(request) {
+    return this.http.post("/data-mesh/views/preview", request);
+  }
+  /**
+   * Get the fan profile view for a wallet.
+   * This is a builtin view that aggregates user activity into a profile.
+   */
+  async getFanProfile(walletAddress) {
+    return this.http.get(`/data-mesh/views/${walletAddress}/fan-profile`);
+  }
+  /**
+   * Get the activity summary view for a wallet.
+   * This is a builtin view that summarizes user activity over time.
+   */
+  async getActivitySummary(walletAddress, days = 30) {
+    return this.http.get(
+      `/data-mesh/views/${walletAddress}/activity-summary`,
+      { days }
+    );
+  }
+  /**
+   * Get event metadata including available event types and their counts.
+   * Useful for building dynamic UIs that show available event types.
+   */
+  async getEventMetadata() {
+    return this.http.get("/data-mesh/event-metadata");
+  }
+  /**
+   * Get available view templates for creating new views.
+   * Templates provide pre-configured computation patterns.
+   */
+  async getTemplates() {
+    const response = await this.http.get("/data-mesh/views/templates");
+    return response.templates || [];
+  }
+};
+
+// src/client.ts
+var DocumentsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Attest a document file.
+   */
+  async attest(request) {
+    const formData = new FormData();
+    if (request.file instanceof Blob) {
+      formData.append("file", request.file, request.filename || "document");
+    } else if (request.file instanceof ArrayBuffer) {
+      const blob = new Blob([request.file]);
+      formData.append("file", blob, request.filename || "document");
+    } else if (typeof Buffer !== "undefined" && Buffer.isBuffer(request.file)) {
+      const uint8 = new Uint8Array(request.file);
+      const blob = new Blob([uint8]);
+      formData.append("file", blob, request.filename || "document");
+    }
+    formData.append("user_id", request.userId);
+    formData.append("event_type", request.eventType || "document_uploaded");
+    if (request.metadata) {
+      formData.append("metadata", JSON.stringify(request.metadata));
+    }
+    if (request.encrypt) {
+      formData.append("encrypt", "1");
+    }
+    return this.http.requestMultipart("/tenant/documents", formData);
+  }
+  /**
+   * Get a document by its IPFS hash.
+   */
+  async get(ipfsHash) {
+    return this.http.get(`/tenant/events/by-hash/${ipfsHash}`);
+  }
+};
+var EventsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new attestation event.
+   */
+  async create(request) {
+    return this.http.post("/tenant/events", {
+      event_type: request.eventType,
+      user_id: request.userId,
+      event_source: request.source || "api",
+      data: request.data || {}
+    });
+  }
+  /**
+   * Get an event by ID.
+   */
+  async get(eventId) {
+    return this.http.get(`/tenant/events/${eventId}`);
+  }
+  /**
+   * List events with optional filters.
+   */
+  async list(request = {}) {
+    const response = await this.http.get("/tenant/events", {
+      user_id: request.userId,
+      event_type: request.eventType,
+      status: request.status,
+      start_date: request.startDate,
+      end_date: request.endDate,
+      limit: request.limit,
+      offset: request.offset
+    });
+    return response.events || [];
+  }
+  /**
+   * Search events by query.
+   */
+  async search(request) {
+    return this.http.post("/search", {
+      query: request.query,
+      user_id: request.userId,
+      event_type: request.eventType,
+      start_date: request.startDate,
+      end_date: request.endDate,
+      limit: request.limit,
+      page: request.page
+    });
+  }
+  /**
+   * Get an event by its IPFS hash.
+   */
+  async byHash(ipfsHash) {
+    return this.http.get(`/tenant/events/by-hash/${ipfsHash}`);
+  }
+  /**
+   * Create multiple events in a batch.
+   * 
+   * Note: For high-throughput ingestion, use the IngestionClient instead.
+   * This method is a convenience wrapper that creates events sequentially.
+   * 
+   * @param events - Array of event requests
+   * @returns Array of created events
+   */
+  async createBatch(events) {
+    const results = [];
+    for (const event of events) {
+      const created = await this.create(event);
+      results.push(created);
+    }
+    return results;
+  }
+};
+var ChannelsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new state channel.
+   */
+  async create(request) {
+    return this.http.post("/channels", {
+      name: request.name,
+      description: request.description
+    });
+  }
+  /**
+   * Get a channel by ID.
+   */
+  async get(channelId) {
+    return this.http.get(`/channels/${channelId}`);
+  }
+  /**
+   * Get detailed status of a channel.
+   */
+  async status(channelId) {
+    return this.http.get(`/channels/${channelId}/status`);
+  }
+  /**
+   * List all channels.
+   */
+  async list(limit = 50, offset = 0) {
+    const response = await this.http.get("/channels", {
+      limit,
+      offset
+    });
+    return response.channels || [];
+  }
+  /**
+   * Stream an event to a channel.
+   */
+  async stream(channelId, request) {
+    return this.http.post(`/channels/${channelId}/stream`, {
+      event_type: request.eventType,
+      user_id: request.userId,
+      event_source: request.source || "sdk",
+      data: request.data
+    });
+  }
+  /**
+   * Stream multiple events in a single request.
+   */
+  async streamBatch(channelId, events) {
+    return this.http.post(`/channels/${channelId}/stream/batch`, {
+      events
+    });
+  }
+  /**
+   * Settle a channel on-chain.
+   */
+  async settle(channelId) {
+    return this.http.post(`/channels/${channelId}/settle`);
+  }
+  /**
+   * Close a channel.
+   */
+  async close(channelId) {
+    return this.http.post(`/channels/${channelId}/close`);
+  }
+};
+var CertificatesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Issue a new certificate.
+   */
+  async issue(request) {
+    return this.http.post("/certificates", {
+      recipient_name: request.recipientName,
+      recipient_email: request.recipientEmail,
+      title: request.title,
+      description: request.description,
+      metadata: request.metadata,
+      expires_at: request.expiresAt
+    });
+  }
+  /**
+   * Get a certificate by ID.
+   */
+  async get(certificateId) {
+    return this.http.get(`/certificates/${certificateId}`);
+  }
+  /**
+   * List certificates.
+   */
+  async list(request = {}) {
+    const response = await this.http.get(
+      "/certificates",
+      {
+        recipient_email: request.recipientEmail,
+        limit: request.limit,
+        offset: request.offset
+      }
+    );
+    return response.certificates || [];
+  }
+  /**
+   * Revoke a certificate.
+   */
+  async revoke(certificateId, reason) {
+    return this.http.post(`/certificates/${certificateId}/revoke`, {
+      reason
+    });
+  }
+  /**
+   * Verify a certificate.
+   */
+  async verify(certificateId) {
+    return this.http.get(`/verify/cert/${certificateId}`);
+  }
+};
+var WebhooksResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new webhook.
+   */
+  async create(request) {
+    return this.http.post("/webhooks", {
+      url: request.url,
+      events: request.events,
+      secret: request.secret
+    });
+  }
+  /**
+   * Get a webhook by ID.
+   */
+  async get(webhookId) {
+    return this.http.get(`/webhooks/${webhookId}`);
+  }
+  /**
+   * List all webhooks.
+   */
+  async list() {
+    const response = await this.http.get("/webhooks");
+    return response.webhooks || [];
+  }
+  /**
+   * Update a webhook.
+   */
+  async update(webhookId, request) {
+    return this.http.patch(`/webhooks/${webhookId}`, request);
+  }
+  /**
+   * Delete a webhook.
+   */
+  async delete(webhookId) {
+    await this.http.delete(`/webhooks/${webhookId}`);
+  }
+  /**
+   * Send a test event to a webhook.
+   */
+  async test(webhookId) {
+    return this.http.post(`/webhooks/${webhookId}/test`);
+  }
+};
+var ProofChain = class _ProofChain {
+  constructor(options) {
+    this.http = new HttpClient(options);
+    this.documents = new DocumentsResource(this.http);
+    this.events = new EventsResource(this.http);
+    this.channels = new ChannelsResource(this.http);
+    this.certificates = new CertificatesResource(this.http);
+    this.webhooks = new WebhooksResource(this.http);
+    this.vault = new VaultResource(this.http);
+    this.search = new SearchResource(this.http);
+    this.verifyResource = new VerifyResource(this.http);
+    this.tenant = new TenantResource(this.http);
+    this.passports = new PassportClient(this.http);
+    this.wallets = new WalletClient(this.http);
+    this.users = new EndUsersClient(this.http);
+    this.rewards = new RewardsClient(this.http);
+    this.quests = new QuestsClient(this.http);
+    this.schemas = new SchemasClient(this.http);
+    this.dataViews = new DataViewsClient(this.http);
+  }
+  /**
+   * Create a client from environment variables.
+   * Reads PROOFCHAIN_API_KEY and optionally PROOFCHAIN_BASE_URL.
+   */
+  static fromEnv() {
+    const env = typeof process !== "undefined" ? process.env : {};
+    const apiKey = env.PROOFCHAIN_API_KEY;
+    if (!apiKey) {
+      throw new Error("PROOFCHAIN_API_KEY environment variable not set");
+    }
+    return new _ProofChain({
+      apiKey,
+      baseUrl: env.PROOFCHAIN_BASE_URL
+    });
+  }
+  /**
+   * Verify a document or event by its IPFS hash.
+   */
+  async verify(ipfsHash) {
+    return this.http.get(`/verify/${ipfsHash}`);
+  }
+  /**
+   * Get information about the current tenant.
+   */
+  async tenantInfo() {
+    return this.http.get("/tenant/me");
+  }
+  /**
+   * Get API usage statistics.
+   */
+  async usage(period = "month") {
+    return this.http.get("/tenant/usage", { period });
+  }
+};
+
+// src/ingestion.ts
+var DEFAULT_INGEST_URL = "https://ingest.proofchain.co.za";
+var USER_AGENT2 = "proofchain-js/0.1.0";
+var IngestionClient = class {
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.ingestUrl = (options.ingestUrl || DEFAULT_INGEST_URL).replace(/\/$/, "");
+    this.timeout = options.timeout || 3e4;
+  }
+  getHeaders() {
+    return {
+      "X-API-Key": this.apiKey,
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENT2
+    };
+  }
+  async handleResponse(response) {
+    const contentType = response.headers.get("content-type");
+    const isJson = contentType?.includes("application/json");
+    if (response.ok) {
+      if (response.status === 204 || !isJson) {
+        return {};
+      }
+      return response.json();
+    }
+    const body = isJson ? await response.json().catch(() => ({})) : {};
+    const message = body.detail || body.message || `HTTP ${response.status}`;
+    switch (response.status) {
+      case 401:
+        throw new AuthenticationError(message);
+      case 422:
+      case 400:
+        throw new ValidationError(message, body.errors);
+      case 429:
+        const retryAfter = response.headers.get("Retry-After");
+        throw new RateLimitError(retryAfter ? parseInt(retryAfter, 10) : void 0);
+      default:
+        if (response.status >= 500) {
+          throw new ServerError(message, response.status);
+        }
+        throw new ProofChainError(message, response.status, body);
+    }
+  }
+  /**
+   * Ingest a single event using the high-performance Rust API.
+   * Events are attested immediately upon ingestion.
+   */
+  async ingest(request) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const headers = this.getHeaders();
+      if (request.schemaIds?.length) {
+        headers["X-Schemas"] = request.schemaIds.join(",");
+      }
+      const response = await fetch(`${this.ingestUrl}/events/ingest`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          user_id: request.userId,
+          event_type: request.eventType,
+          data: request.data || {},
+          event_source: request.eventSource || "sdk"
+        }),
+        signal: controller.signal
+      });
+      const result = await this.handleResponse(response);
+      return {
+        eventId: result.event_id,
+        certificateId: result.certificate_id,
+        status: result.status,
+        queuePosition: result.queue_position,
+        estimatedConfirmation: result.estimated_confirmation
+      };
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new NetworkError("Request timed out");
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Ingest multiple events in a single request (up to 1000 events).
+   * More efficient than individual calls for bulk data.
+   */
+  async ingestBatch(request) {
+    if (request.events.length > 1e3) {
+      throw new ValidationError("Batch size cannot exceed 1000 events");
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout * 2);
+    try {
+      const response = await fetch(`${this.ingestUrl}/events/ingest/batch`, {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify(
+          request.events.map((e) => ({
+            user_id: e.userId,
+            event_type: e.eventType,
+            data: e.data || {},
+            event_source: e.eventSource || "sdk"
+          }))
+        ),
+        signal: controller.signal
+      });
+      const result = await this.handleResponse(response);
+      return {
+        totalEvents: result.total_events || result.total,
+        queued: result.queued,
+        failed: result.failed,
+        results: (result.results || result.responses || []).map((r) => ({
+          eventId: r.event_id,
+          certificateId: r.certificate_id,
+          status: r.status
+        }))
+      };
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new NetworkError("Request timed out");
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Get the status of an event by ID.
+   */
+  async getEventStatus(eventId) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.ingestUrl}/events/${eventId}/status`, {
+        method: "GET",
+        headers: this.getHeaders(),
+        signal: controller.signal
+      });
+      return this.handleResponse(response);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
 export {
-  AttestationClient,
-  AttestationClientError,
-  AttestationRegistryContract,
-  createClient
+  AuthenticationError,
+  AuthorizationError,
+  CertificatesResource,
+  ChannelsResource,
+  DataViewsClient,
+  DocumentsResource,
+  EndUsersClient,
+  EventsResource,
+  IngestionClient,
+  NetworkError,
+  NotFoundError,
+  PassportClient,
+  ProofChain,
+  ProofChainError,
+  QuestsClient,
+  RateLimitError,
+  RewardsClient,
+  SchemasClient,
+  SearchResource,
+  ServerError,
+  TenantResource,
+  TimeoutError,
+  ValidationError,
+  VaultResource,
+  VerifyResource,
+  WalletClient,
+  WebhooksResource
 };