@bind-protocol/sdk 0.8.0 → 0.10.0

package/dist/index.cjs

@@ -100,33 +100,42 @@ var BindClient = class {
    * @throws {InsufficientCreditsError} If there aren't enough credits
    */
   async submitProveJob(circuitId, inputs, options) {
-    const response = await this.fetch("/api/prove", {
-      method: "POST",
-      body: JSON.stringify({
-        circuitId,
-        inputs,
-        verificationMode: options?.verificationMode
-      })
-    });
-    const result = await response.json();
-    if (!result.success && result.requiredCredits !== void 0 && result.availableCredits !== void 0) {
-      throw new InsufficientCreditsError(result.requiredCredits, result.availableCredits);
+    try {
+      return await this.fetchJson("/api/prove", {
+        method: "POST",
+        body: JSON.stringify({
+          circuitId,
+          inputs,
+          verificationMode: options?.verificationMode
+        })
+      });
+    } catch (err) {
+      if (err instanceof ApiError && err.response) {
+        const body = err.response;
+        if (body.requiredCredits !== void 0 && body.availableCredits !== void 0) {
+          throw new InsufficientCreditsError(
+            body.requiredCredits,
+            body.availableCredits
+          );
+        }
+      }
+      throw err;
     }
-    return result;
   }
   /**
    * Get the status and results of a prove job
    * @param jobId - The unique job identifier
    * @returns The job details including status and outputs
+   * @throws {ApiError} If the API request fails
    */
   async getProveJob(jobId) {
-    const response = await this.fetch(`/api/prove/${encodeURIComponent(jobId)}`);
-    return response.json();
+    return this.fetchJson(`/api/prove/${encodeURIComponent(jobId)}`);
   }
   /**
    * List prove jobs for the authenticated organization
    * @param options - Optional filters for status, limit, and offset
    * @returns Paginated list of prove jobs
+   * @throws {ApiError} If the API request fails
    */
   async listProveJobs(options = {}) {
     const params = new URLSearchParams();
@@ -135,8 +144,7 @@ var BindClient = class {
     if (options.offset !== void 0) params.set("offset", options.offset.toString());
     const queryString = params.toString();
     const path = queryString ? `/api/prove?${queryString}` : "/api/prove";
-    const response = await this.fetch(path);
-    return response.json();
+    return this.fetchJson(path);
   }
   /**
    * Poll for prove job completion
@@ -144,21 +152,14 @@ var BindClient = class {
    * @param options - Polling options
    * @returns The completed or failed job
    * @throws {TimeoutError} If the job doesn't complete within the timeout
+   * @throws {ApiError} If the API request fails
    */
   async waitForProveJob(jobId, options = {}) {
     const intervalMs = options.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const startTime = Date.now();
     while (Date.now() - startTime < timeoutMs) {
-      const result = await this.getProveJob(jobId);
-      if (!result.success || !result.data) {
-        throw new ApiError(
-          result.error || "Failed to get prove job",
-          500,
-          result
-        );
-      }
-      const job = result.data;
+      const job = await this.getProveJob(jobId);
       if (options.onProgress) {
         options.onProgress(job);
       }
@@ -178,41 +179,28 @@ var BindClient = class {
   /**
    * List all available public policies
    * @returns Array of public policy specifications
+   * @throws {ApiError} If the API request fails
    */
   async listPolicies() {
-    const response = await fetch(`${this.baseUrl}/api/policies`, {
-      method: "GET"
-    });
-    if (!response.ok) {
-      throw new ApiError(
-        `Failed to fetch policies: ${response.statusText}`,
-        response.status
-      );
-    }
-    const json = await response.json();
-    return json.data ?? json;
+    return this.fetchJson("/api/policies");
   }
   /**
    * Get a specific policy by ID
    * @param policyId - The unique policy identifier
    * @returns The public policy specification, or null if not found
+   * @throws {ApiError} If the API request fails (except 404)
    */
   async getPolicy(policyId) {
-    const response = await fetch(
-      `${this.baseUrl}/api/policies/${encodeURIComponent(policyId)}`,
-      { method: "GET" }
-    );
-    if (response.status === 404) {
-      return null;
-    }
-    if (!response.ok) {
-      throw new ApiError(
-        `Failed to fetch policy: ${response.statusText}`,
-        response.status
+    try {
+      return await this.fetchJson(
+        `/api/policies/${encodeURIComponent(policyId)}`
       );
+    } catch (err) {
+      if (err instanceof ApiError && err.status === 404) {
+        return null;
+      }
+      throw err;
     }
-    const json = await response.json();
-    return json.data ?? json;
   }
   // ==========================================================================
   // zkTLS Methods
@@ -220,49 +208,49 @@ var BindClient = class {
   /**
    * List available zkTLS extractors (data sources)
    * @returns Array of available extractors
+   * @throws {ApiError} If the API request fails
    */
   async listExtractors() {
-    const response = await this.fetch("/api/zktls/extractors");
-    return response.json();
+    return this.fetchJson("/api/zktls/extractors");
   }
   /**
    * List zkTLS attestations for the authenticated organization
    * @returns Array of attestations
+   * @throws {ApiError} If the API request fails
    */
   async listAttestations() {
-    const response = await this.fetch("/api/zktls/attestations");
-    return response.json();
+    return this.fetchJson("/api/zktls/attestations");
   }
   /**
    * Get a specific attestation by ID
    * @param attestationId - The attestation UUID
-   * @returns The attestation or null if not found
+   * @returns The attestation details
+   * @throws {ApiError} If the API request fails
    */
   async getAttestation(attestationId) {
-    const response = await this.fetch(`/api/zktls/attestations/${encodeURIComponent(attestationId)}`);
-    return response.json();
+    return this.fetchJson(`/api/zktls/attestations/${encodeURIComponent(attestationId)}`);
   }
   /**
    * Create a new zkTLS session for data attestation
    * @param extractorId - The extractor to use (e.g., "coinbase")
    * @param callbackUrl - URL to redirect to after authentication
    * @returns Session ID and auth URL to redirect user to
+   * @throws {ApiError} If the API request fails
    */
   async createZkTlsSession(extractorId, callbackUrl) {
-    const response = await this.fetch("/api/zktls/sessions", {
+    return this.fetchJson("/api/zktls/sessions", {
       method: "POST",
       body: JSON.stringify({ extractor: extractorId, callbackUrl })
     });
-    return response.json();
   }
   /**
    * Get the status of a zkTLS session
    * @param sessionId - The session UUID
    * @returns Session status and attestation if completed
+   * @throws {ApiError} If the API request fails
    */
   async getZkTlsSession(sessionId) {
-    const response = await this.fetch(`/api/zktls/sessions/${encodeURIComponent(sessionId)}`);
-    return response.json();
+    return this.fetchJson(`/api/zktls/sessions/${encodeURIComponent(sessionId)}`);
   }
   /**
    * Wait for a zkTLS session to complete
@@ -272,21 +260,14 @@ var BindClient = class {
    * @throws {ZkTlsSessionExpiredError} If session expires
    * @throws {ZkTlsSessionFailedError} If session fails
    * @throws {TimeoutError} If timeout is reached
+   * @throws {ApiError} If the API request fails
    */
   async waitForZkTlsSession(sessionId, options = {}) {
     const intervalMs = options.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const startTime = Date.now();
     while (Date.now() - startTime < timeoutMs) {
-      const result = await this.getZkTlsSession(sessionId);
-      if (!result.success || !result.data) {
-        throw new ApiError(
-          result.error || "Failed to get zkTLS session",
-          500,
-          result
-        );
-      }
-      const session = result.data;
+      const session = await this.getZkTlsSession(sessionId);
       if (options.onProgress) {
         options.onProgress(session);
       }
@@ -313,6 +294,7 @@ var BindClient = class {
    * List available circuits
    * @param options - Optional filters
    * @returns Array of circuits
+   * @throws {ApiError} If the API request fails
    */
   async listCircuits(options = {}) {
     const params = new URLSearchParams();
@@ -320,28 +302,27 @@ var BindClient = class {
     if (options.policyId) params.set("policyId", options.policyId);
     const queryString = params.toString();
     const path = queryString ? `/api/circuits?${queryString}` : "/api/circuits";
-    const response = await this.fetch(path);
-    return response.json();
+    return this.fetchJson(path);
   }
   /**
    * Get a specific circuit by ID
    * @param circuitId - The circuit identifier
-   * @returns The circuit details or null if not found
+   * @returns The circuit details
+   * @throws {ApiError} If the API request fails
    */
   async getCircuit(circuitId) {
-    const response = await this.fetch(`/api/circuits/${encodeURIComponent(circuitId)}`);
-    return response.json();
+    return this.fetchJson(`/api/circuits/${encodeURIComponent(circuitId)}`);
   }
   /**
    * Activate a circuit (requires validation to have passed)
    * @param circuitId - The circuit identifier to activate
    * @returns The activation result
+   * @throws {ApiError} If the API request fails
    */
   async activateCircuit(circuitId) {
-    const response = await this.fetch(`/api/circuits/${encodeURIComponent(circuitId)}/activate`, {
+    return this.fetchJson(`/api/circuits/${encodeURIComponent(circuitId)}/activate`, {
       method: "POST"
     });
-    return response.json();
   }
   // ==========================================================================
   // Shared Proof Methods
@@ -350,18 +331,19 @@ var BindClient = class {
    * Share a completed proof with a verifier organization
    * @param request - Share proof request with proveJobId and verifierOrgId
    * @returns The created shared proof
+   * @throws {ApiError} If the API request fails
    */
   async shareProof(request) {
-    const response = await this.fetch("/api/shared-proofs", {
+    return this.fetchJson("/api/shared-proofs", {
       method: "POST",
       body: JSON.stringify(request)
     });
-    return response.json();
   }
   /**
    * List shared proofs (outgoing or incoming)
    * @param options - Filter by direction, pagination, and inclusion options
    * @returns Paginated list of shared proofs
+   * @throws {ApiError} If the API request fails
    */
   async listSharedProofs(options = {}) {
     const params = new URLSearchParams();
@@ -372,28 +354,27 @@ var BindClient = class {
     if (options.includeRevoked) params.set("includeRevoked", "true");
     const queryString = params.toString();
     const path = queryString ? `/api/shared-proofs?${queryString}` : "/api/shared-proofs";
-    const response = await this.fetch(path);
-    return response.json();
+    return this.fetchJson(path);
   }
   /**
    * Get a specific shared proof by ID
    * @param sharedProofId - The shared proof ID
    * @returns The shared proof details
+   * @throws {ApiError} If the API request fails
    */
   async getSharedProof(sharedProofId) {
-    const response = await this.fetch(`/api/shared-proofs/${encodeURIComponent(sharedProofId)}`);
-    return response.json();
+    return this.fetchJson(`/api/shared-proofs/${encodeURIComponent(sharedProofId)}`);
   }
   /**
    * Revoke a shared proof. Only the sharing organization can revoke.
    * @param sharedProofId - The shared proof ID to revoke
    * @returns The revocation result
+   * @throws {ApiError} If the API request fails
    */
   async revokeSharedProof(sharedProofId) {
-    const response = await this.fetch(`/api/shared-proofs/${encodeURIComponent(sharedProofId)}`, {
+    return this.fetchJson(`/api/shared-proofs/${encodeURIComponent(sharedProofId)}`, {
       method: "DELETE"
     });
-    return response.json();
   }
   // ==========================================================================
   // Verification Methods
@@ -407,84 +388,70 @@ var BindClient = class {
    * @param sharedProofId - The shared proof ID to verify
    * @param options - Optional polling configuration
    * @returns The verification result
+   * @throws {ApiError} If the API request fails
+   * @throws {TimeoutError} If verification doesn't complete within the timeout
    */
   async verifySharedProof(sharedProofId, options) {
-    const pollIntervalMs = options?.pollIntervalMs ?? 1e3;
-    const maxWaitMs = options?.maxWaitMs ?? 12e4;
-    const queueResponse = await this.fetch(`/api/verify/shared/${encodeURIComponent(sharedProofId)}`, {
+    const intervalMs = options?.intervalMs ?? 1e3;
+    const timeoutMs = options?.timeoutMs ?? 12e4;
+    const queueResult = await this.fetchJson(`/api/verify/shared/${encodeURIComponent(sharedProofId)}`, {
       method: "POST"
     });
-    const queueResult = await queueResponse.json();
-    if (!queueResult.success || !queueResult.data?.jobId) {
-      return {
-        success: false,
-        error: queueResult.error ?? "Failed to queue verification job"
-      };
-    }
-    const jobId = queueResult.data.jobId;
+    const jobId = queueResult.jobId;
     const startTime = Date.now();
-    while (Date.now() - startTime < maxWaitMs) {
+    while (Date.now() - startTime < timeoutMs) {
       const statusResult = await this.getVerifyJobStatus(jobId);
-      if (!statusResult.success) {
+      if (statusResult.status === "completed" || statusResult.status === "failed") {
         return {
-          success: false,
-          error: statusResult.error ?? "Failed to get verification status"
+          isValid: statusResult.isValid ?? false,
+          error: statusResult.error,
+          verificationTimeMs: statusResult.verificationTimeMs ?? 0,
+          creditsCharged: statusResult.creditsCharged ?? queueResult.creditsCharged,
+          verificationResultId: statusResult.verificationResultId ?? jobId,
+          publicInputs: statusResult.publicInputs
         };
       }
-      const status = statusResult.data?.status;
-      if (status === "completed" || status === "failed") {
-        return {
-          success: true,
-          data: {
-            isValid: statusResult.data?.isValid ?? false,
-            error: statusResult.data?.error,
-            verificationTimeMs: statusResult.data?.verificationTimeMs ?? 0,
-            creditsCharged: statusResult.data?.creditsCharged ?? queueResult.data.creditsCharged,
-            verificationResultId: statusResult.data?.verificationResultId ?? jobId,
-            publicInputs: statusResult.data?.publicInputs
-          }
-        };
-      }
-      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+      await this.sleep(intervalMs);
     }
-    return {
-      success: false,
-      error: `Verification timed out after ${maxWaitMs}ms. Job ID: ${jobId}`
-    };
+    throw new TimeoutError(
+      `Verification timed out after ${timeoutMs}ms. Job ID: ${jobId}`,
+      timeoutMs
+    );
   }
   /**
    * Get the status of a verification job
    * @param jobId - The verification job ID
-   * @returns The job status
+   * @returns The job status data
+   * @throws {ApiError} If the API request fails
    */
   async getVerifyJobStatus(jobId) {
-    const response = await this.fetch(`/api/verify/jobs/${encodeURIComponent(jobId)}`);
-    return response.json();
+    return this.fetchJson(`/api/verify/jobs/${encodeURIComponent(jobId)}`);
   }
   /**
    * Verify an uploaded proof
    * @param proofBuffer - The proof binary as ArrayBuffer, Uint8Array, or Buffer
    * @param vkBuffer - The verification key binary as ArrayBuffer, Uint8Array, or Buffer
    * @returns The verification result
+   * @throws {ApiError} If the API request fails
    */
   async verifyUploadedProof(proofBuffer, vkBuffer) {
     const proofBytes = proofBuffer instanceof Uint8Array ? proofBuffer : new Uint8Array(proofBuffer);
     const vkBytes = vkBuffer instanceof Uint8Array ? vkBuffer : new Uint8Array(vkBuffer);
     const proofBase64 = typeof Buffer !== "undefined" ? Buffer.from(proofBytes).toString("base64") : btoa(String.fromCharCode(...proofBytes));
     const vkBase64 = typeof Buffer !== "undefined" ? Buffer.from(vkBytes).toString("base64") : btoa(String.fromCharCode(...vkBytes));
-    const response = await this.fetch("/api/verify/upload", {
+    return this.fetchJson("/api/verify/upload", {
       method: "POST",
       body: JSON.stringify({
         proof: proofBase64,
         vk: vkBase64
       })
     });
-    return response.json();
   }
   /**
    * Get verification history for the authenticated organization
    * @param options - Pagination options
    * @returns Paginated list of verification results
+   * @throws {ApiError} If the API request fails
    */
   async getVerificationHistory(options = {}) {
     const params = new URLSearchParams();
@@ -492,8 +459,7 @@ var BindClient = class {
     if (options.offset !== void 0) params.set("offset", options.offset.toString());
     const queryString = params.toString();
     const path = queryString ? `/api/verify/history?${queryString}` : "/api/verify/history";
-    const response = await this.fetch(path);
-    return response.json();
+    return this.fetchJson(path);
   }
   // ==========================================================================
   // Private Helpers
@@ -509,8 +475,24 @@ var BindClient = class {
     if (response.status === 401) {
       throw new AuthenticationError();
     }
+    if (!response.ok) {
+      const body = await response.json().catch(() => ({}));
+      throw new ApiError(
+        body.error || `HTTP ${response.status}: ${response.statusText}`,
+        response.status,
+        body
+      );
+    }
     return response;
   }
+  async fetchJson(path, init) {
+    const response = await this.fetch(path, init);
+    const json = await response.json();
+    if (json.success === false) {
+      throw new ApiError(json.error || "Request failed", response.status, json);
+    }
+    return json.data ?? json;
+  }
   sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
@@ -525,12 +507,9 @@ function buildTelemetryQuery(vehicleTokenId, from, to) {
     from: ${from},
     to: ${to}
   ) {
-    powertrainTransmissionTravelledDistance(agg: AVG)
-    speed(agg: AVG)
-    powertrainCombustionEngineSpeed(agg: AVG)
-    obdEngineLoad(agg: AVG)
-    obdDTCList(agg: UNIQUE)
-    obdRunTime(agg: AVG)
+    powertrainTransmissionTravelledDistance(agg: SUM)
+    isIgnitionOn(agg: COUNT)
+    speed(agg: MAX)
     timestamp
   }
 }`;
@@ -557,7 +536,7 @@ ${signalLines}
 
 // src/adapters/dimo/adapter.ts
 var SUPPORTED_CIRCUITS = [
-  "bind.mobility.riskband.v1"
+  "bind.dimo.riskband.v0_1_0"
 ];
 var DimoAdapter = class {
   id = "dimo";
@@ -590,7 +569,7 @@ var DimoAdapter = class {
       );
     }
     switch (circuitId) {
-      case "bind.mobility.riskband.v1":
+      case "bind.dimo.riskband.v0_1_0":
         return this.toRiskBandInputs(data);
       default:
         throw new Error(`No input transformer for circuit: ${circuitId}`);
@@ -605,10 +584,29 @@ var DimoAdapter = class {
   // ===========================================================================
   // Private transformers
   // ===========================================================================
+  /**
+   * Aggregate hourly telemetry rows into the three circuit inputs
+   * required by bind.mobility.basicriskband:
+   *
+   *   mileage_90d  (u32) — SUM of powertrainTransmissionTravelledDistance
+   *   data_points  (u32) — COUNT of isIgnitionOn (sum of per-hour counts)
+   *   speed_max    (u16) — MAX of speed
+   */
   toRiskBandInputs(data) {
+    let mileageSum = 0;
+    let dataPointsSum = 0;
+    let speedMax = 0;
+    for (const row of data.signals) {
+      mileageSum += row.powertrainTransmissionTravelledDistance ?? 0;
+      dataPointsSum += row.isIgnitionOn ?? 0;
+      if ((row.speed ?? 0) > speedMax) {
+        speedMax = row.speed;
+      }
+    }
     return {
-      signals: JSON.stringify(data.signals),
-      timestamp: data.timestamp
+      mileage_90d: String(Math.round(mileageSum)),
+      data_points: String(Math.round(dataPointsSum)),
+      speed_max: String(Math.round(speedMax))
     };
   }
 };
@@ -648,11 +646,7 @@ var ZkTlsAdapter = class {
    * Client should redirect user to this URL
    */
   async createSession(callbackUrl) {
-    const result = await this.client.createZkTlsSession(this.extractorId, callbackUrl);
-    if (!result.success || !result.data) {
-      throw new Error(result.error || "Failed to create zkTLS session");
-    }
-    return result.data;
+    return this.client.createZkTlsSession(this.extractorId, callbackUrl);
   }
   /**
    * Wait for session completion and return attestation
@@ -663,7 +657,7 @@ var ZkTlsAdapter = class {
       throw new Error("Session completed but no attestation found");
     }
     const extractors = await this.client.listExtractors();
-    const extractor = extractors.data?.find((e) => e.id === this.extractorId);
+    const extractor = extractors.find((e) => e.id === this.extractorId);
     if (!extractor) {
       throw new Error(`Extractor not found: ${this.extractorId}`);
     }
@@ -676,17 +670,14 @@ var ZkTlsAdapter = class {
   // Protected helpers
   // ===========================================================================
   async fetchExistingAttestation(attestationId) {
-    const result = await this.client.getAttestation(attestationId);
-    if (!result.success || !result.data) {
-      throw new Error(result.error || "Attestation not found");
-    }
+    const attestation = await this.client.getAttestation(attestationId);
     const extractors = await this.client.listExtractors();
-    const extractor = extractors.data?.find((e) => e.id === result.data.extractor);
+    const extractor = extractors.find((e) => e.id === attestation.extractor);
     if (!extractor) {
-      throw new Error(`Extractor not found: ${result.data.extractor}`);
+      throw new Error(`Extractor not found: ${attestation.extractor}`);
     }
     return {
-      attestation: result.data,
+      attestation,
       extractor
     };
   }