@bind-protocol/sdk 0.10.0 → 0.11.0

package/dist/index.cjs

@@ -434,18 +434,40 @@ var BindClient = class {
    * @returns The verification result
    * @throws {ApiError} If the API request fails
    */
-  async verifyUploadedProof(proofBuffer, vkBuffer) {
+  async verifyUploadedProof(proofBuffer, vkBuffer, options) {
+    const intervalMs = options?.intervalMs ?? 1e3;
+    const timeoutMs = options?.timeoutMs ?? 12e4;
     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));
-    return this.fetchJson("/api/verify/upload", {
+    const queueResult = await this.fetchJson("/api/verify/upload", {
       method: "POST",
       body: JSON.stringify({
         proof: proofBase64,
         vk: vkBase64
       })
     });
+    const jobId = queueResult.jobId;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      const statusResult = await this.getVerifyJobStatus(jobId);
+      if (statusResult.status === "completed" || statusResult.status === "failed") {
+        return {
+          isValid: statusResult.isValid ?? false,
+          error: statusResult.error,
+          verificationTimeMs: statusResult.verificationTimeMs ?? 0,
+          creditsCharged: statusResult.creditsCharged ?? queueResult.creditsCharged,
+          verificationResultId: statusResult.verificationResultId ?? jobId,
+          publicInputs: statusResult.publicInputs
+        };
+      }
+      await this.sleep(intervalMs);
+    }
+    throw new TimeoutError(
+      `Verification timed out after ${timeoutMs}ms. Job ID: ${jobId}`,
+      timeoutMs
+    );
   }
   /**
    * Get verification history for the authenticated organization
@@ -614,6 +636,40 @@ function createDimoAdapter(config) {
   return new DimoAdapter(config);
 }
 
+// src/adapters/dimo/fetcher.ts
+var DimoSourceFetcher = class {
+  kind = "dimo";
+  adapter;
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  async fetchSignals(_source, window, signals, context) {
+    const vehicleTokenId = context.subject["vehicleTokenId"];
+    if (!vehicleTokenId) {
+      throw new Error(
+        'DimoSourceFetcher requires "vehicleTokenId" in context.subject'
+      );
+    }
+    const result = await this.adapter.fetchData({
+      vehicleTokenId,
+      from: window.from,
+      to: window.to
+    });
+    return result.signals.map((row) => {
+      const signal = {
+        timestamp: row.timestamp ?? result.timestamp
+      };
+      for (const key of signals) {
+        const value = row[key];
+        if (value !== void 0) {
+          signal[key] = value;
+        }
+      }
+      return signal;
+    });
+  }
+};
+
 // src/adapters/zktls/adapter.ts
 var ZkTlsAdapter = class {
   client;
@@ -694,6 +750,38 @@ var ZkTlsAdapter = class {
   }
 };
 
+// src/adapters/zktls/fetcher.ts
+var ZkTlsSourceFetcher = class {
+  kind = "zktls";
+  adapter;
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  async fetchSignals(_source, _window, signals, context) {
+    const attestationId = context.subject["attestationId"] ?? context.adapterContext?.["zktls"]?.["attestationId"];
+    const callbackUrl = context.adapterContext?.["zktls"]?.["callbackUrl"];
+    if (!attestationId && !callbackUrl) {
+      throw new Error(
+        'ZkTlsSourceFetcher requires "attestationId" in context.subject or "attestationId"/"callbackUrl" in context.adapterContext.zktls'
+      );
+    }
+    const data = await this.adapter.fetchData({
+      attestationId,
+      callbackUrl
+    });
+    const claims = data.attestation.claims;
+    const timestamp = new Date(data.attestation.createdAt).toISOString();
+    const signal = { timestamp };
+    for (const key of signals) {
+      const value = claims[key];
+      if (value !== void 0) {
+        signal[key] = value;
+      }
+    }
+    return [signal];
+  }
+};
+
 // src/adapters/zktls/coinbase.ts
 var SUPPORTED_CIRCUITS2 = [
   "bind.identity.kyc.v1",
@@ -757,23 +845,318 @@ function createCoinbaseAdapter(config) {
   return new CoinbaseAdapter(config);
 }
 
+// src/resolver/timeWindow.ts
+var UNIT_MS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5,
+  w: 6048e5
+};
+function parseDuration(d) {
+  const match = /^(\d+(?:\.\d+)?)(ms|s|m|h|d|w)$/.exec(d);
+  if (!match) {
+    throw new Error(`Invalid duration: "${d}". Expected format like "30d", "1h", "500ms".`);
+  }
+  const value = Number(match[1]);
+  const unit = match[2];
+  const multiplier = UNIT_MS[unit];
+  if (multiplier === void 0) {
+    throw new Error(`Unknown duration unit: "${unit}"`);
+  }
+  return value * multiplier;
+}
+function resolveTimeWindow(spec, now) {
+  switch (spec.mode) {
+    case "point":
+      return { from: spec.at, to: spec.at };
+    case "range":
+      return { from: spec.start, to: spec.end };
+    case "relative": {
+      const nowMs = (now ?? /* @__PURE__ */ new Date()).getTime();
+      const endOffsetMs = spec.endOffset ? parseDuration(spec.endOffset) : 0;
+      const toMs = nowMs - endOffsetMs;
+      const fromMs = toMs - parseDuration(spec.lookback);
+      return {
+        from: new Date(fromMs).toISOString(),
+        to: new Date(toMs).toISOString()
+      };
+    }
+  }
+}
+
+// src/resolver/aggregate.ts
+function aggregate(signals, signalKey, spec) {
+  switch (spec.op) {
+    case "latest":
+      return aggregateLatest(signals, signalKey);
+    case "sum":
+      return aggregateSum(signals, signalKey);
+    case "avg":
+      return aggregateAvg(signals, signalKey);
+    case "min":
+      return aggregateMin(signals, signalKey);
+    case "max":
+      return aggregateMax(signals, signalKey);
+    case "count":
+      return aggregateCount(signals, signalKey);
+    case "distinctCount":
+      return aggregateDistinctCount(signals, signalKey);
+    case "p50":
+    case "p90":
+    case "p95":
+    case "p99":
+      return aggregatePercentile(signals, signalKey, spec.op);
+    case "windowedRate":
+      return aggregateWindowedRate(signals, signalKey, spec.per);
+  }
+}
+function extractNumericValues(signals, key) {
+  const values = [];
+  for (const s of signals) {
+    const v = s[key];
+    if (v != null && typeof v === "number") {
+      values.push(v);
+    } else if (v != null && typeof v === "string") {
+      const n = Number(v);
+      if (!Number.isNaN(n)) values.push(n);
+    }
+  }
+  return values;
+}
+function aggregateLatest(signals, key) {
+  const sorted = [...signals].sort(
+    (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+  );
+  for (const s of sorted) {
+    const v = s[key];
+    if (v != null) return v;
+  }
+  throw new Error(`No non-null values found for signal "${key}" with op "latest"`);
+}
+function aggregateSum(signals, key) {
+  const values = extractNumericValues(signals, key);
+  let sum = 0;
+  for (const v of values) sum += v;
+  return sum;
+}
+function aggregateAvg(signals, key) {
+  const values = extractNumericValues(signals, key);
+  if (values.length === 0) return 0;
+  let sum = 0;
+  for (const v of values) sum += v;
+  return sum / values.length;
+}
+function aggregateMin(signals, key) {
+  const values = extractNumericValues(signals, key);
+  if (values.length === 0) return 0;
+  let min = values[0];
+  for (let i = 1; i < values.length; i++) {
+    if (values[i] < min) min = values[i];
+  }
+  return min;
+}
+function aggregateMax(signals, key) {
+  const values = extractNumericValues(signals, key);
+  if (values.length === 0) return 0;
+  let max = values[0];
+  for (let i = 1; i < values.length; i++) {
+    if (values[i] > max) max = values[i];
+  }
+  return max;
+}
+function aggregateCount(signals, key) {
+  let count = 0;
+  for (const s of signals) {
+    if (s[key] != null) count++;
+  }
+  return count;
+}
+function aggregateDistinctCount(signals, key) {
+  const unique = /* @__PURE__ */ new Set();
+  for (const s of signals) {
+    const v = s[key];
+    if (v != null && !Array.isArray(v)) unique.add(v);
+  }
+  return unique.size;
+}
+var PERCENTILE_MAP = {
+  p50: 0.5,
+  p90: 0.9,
+  p95: 0.95,
+  p99: 0.99
+};
+function aggregatePercentile(signals, key, op) {
+  const values = extractNumericValues(signals, key);
+  if (values.length === 0) return 0;
+  values.sort((a, b) => a - b);
+  const p = PERCENTILE_MAP[op];
+  const index = Math.ceil(p * values.length) - 1;
+  return values[Math.max(0, index)];
+}
+function aggregateWindowedRate(signals, key, per) {
+  if (signals.length === 0) return 0;
+  let count = 0;
+  for (const s of signals) {
+    if (s[key] != null) count++;
+  }
+  const timestamps = signals.map((s) => new Date(s.timestamp).getTime()).filter((t) => !Number.isNaN(t));
+  if (timestamps.length < 2) return count;
+  const minTs = Math.min(...timestamps);
+  const maxTs = Math.max(...timestamps);
+  const spanMs = maxTs - minTs;
+  if (spanMs === 0) return count;
+  const perMs = parseDuration(per);
+  return count / (spanMs / perMs);
+}
+
+// src/resolver/InputResolver.ts
+function defaultStringify(value) {
+  if (typeof value === "number") return String(Math.round(value));
+  return String(value);
+}
+function buildGroupKey(spec, window) {
+  return JSON.stringify({
+    kind: spec.source.kind,
+    ref: spec.source.ref ?? null,
+    config: spec.source.config ?? null,
+    from: window.from,
+    to: window.to
+  });
+}
+var InputResolver = class {
+  fetchers;
+  stringify;
+  constructor(config) {
+    this.fetchers = /* @__PURE__ */ new Map();
+    for (const f of config.fetchers) {
+      this.fetchers.set(f.kind, f);
+    }
+    this.stringify = config.stringify ?? ((v) => defaultStringify(v));
+  }
+  /**
+   * Main entry point — resolves all inputs and returns Record<string, string>
+   * ready for submitProveJob().
+   */
+  async resolveInputs(inputSpecs, context) {
+    const resolved = await this.resolveAll(inputSpecs, context);
+    const result = {};
+    for (const r of resolved) {
+      result[r.id] = r.rawValue;
+    }
+    return result;
+  }
+  /**
+   * Detailed resolution — returns full ResolvedInput[] for debugging/inspection.
+   */
+  async resolveAll(inputSpecs, context) {
+    const groups = this.groupInputs(inputSpecs, context);
+    const signalsByGroup = await this.fetchAllGroups(groups, context);
+    return this.aggregateAll(groups, signalsByGroup, inputSpecs);
+  }
+  /**
+   * Group inputs by (source + time window) for batched fetching.
+   */
+  groupInputs(inputSpecs, context) {
+    const groupMap = /* @__PURE__ */ new Map();
+    for (const spec of inputSpecs) {
+      const window = resolveTimeWindow(spec.time, context.now);
+      const key = buildGroupKey(spec, window);
+      let group = groupMap.get(key);
+      if (!group) {
+        group = {
+          key,
+          sourceKind: spec.source.kind,
+          source: spec.source,
+          window,
+          inputs: [],
+          signals: []
+        };
+        groupMap.set(key, group);
+      }
+      group.inputs.push(spec);
+      if (!group.signals.includes(spec.signal)) {
+        group.signals.push(spec.signal);
+      }
+    }
+    return Array.from(groupMap.values());
+  }
+  /**
+   * Fetch signals for all groups in parallel.
+   */
+  async fetchAllGroups(groups, context) {
+    const results = /* @__PURE__ */ new Map();
+    const fetches = groups.map(async (group) => {
+      const fetcher = this.fetchers.get(group.sourceKind);
+      if (!fetcher) {
+        const registered = Array.from(this.fetchers.keys());
+        throw new Error(
+          `No SourceFetcher registered for kind "${group.sourceKind}". Registered kinds: [${registered.join(", ")}]`
+        );
+      }
+      const signals = await fetcher.fetchSignals(
+        group.source,
+        group.window,
+        group.signals,
+        context
+      );
+      results.set(group.key, signals);
+    });
+    await Promise.all(fetches);
+    return results;
+  }
+  /**
+   * Apply aggregation to each input using the fetched signals.
+   */
+  aggregateAll(groups, signalsByGroup, inputSpecs) {
+    const specMap = /* @__PURE__ */ new Map();
+    for (const spec of inputSpecs) {
+      specMap.set(spec.id, spec);
+    }
+    const resolved = [];
+    for (const group of groups) {
+      const signals = signalsByGroup.get(group.key) ?? [];
+      for (const input of group.inputs) {
+        const value = aggregate(signals, input.signal, input.aggregation);
+        const spec = specMap.get(input.id);
+        resolved.push({
+          id: input.id,
+          value,
+          rawValue: this.stringify(value, spec),
+          signal: input.signal,
+          aggregationOp: input.aggregation.op,
+          timeWindow: group.window
+        });
+      }
+    }
+    return resolved;
+  }
+};
+
 exports.ApiError = ApiError;
 exports.AuthenticationError = AuthenticationError;
 exports.BindClient = BindClient;
 exports.BindError = BindError;
 exports.CoinbaseAdapter = CoinbaseAdapter;
 exports.DimoAdapter = DimoAdapter;
+exports.DimoSourceFetcher = DimoSourceFetcher;
+exports.InputResolver = InputResolver;
 exports.InsufficientCreditsError = InsufficientCreditsError;
 exports.TimeoutError = TimeoutError;
 exports.ZkTlsAdapter = ZkTlsAdapter;
 exports.ZkTlsExtractorError = ZkTlsExtractorError;
 exports.ZkTlsSessionExpiredError = ZkTlsSessionExpiredError;
 exports.ZkTlsSessionFailedError = ZkTlsSessionFailedError;
+exports.ZkTlsSourceFetcher = ZkTlsSourceFetcher;
+exports.aggregate = aggregate;
 exports.buildCustomTelemetryQuery = buildCustomTelemetryQuery;
 exports.buildTelemetryQuery = buildTelemetryQuery;
 exports.createCoinbaseAdapter = createCoinbaseAdapter;
 exports.createDimoAdapter = createDimoAdapter;
 exports.default = BindClient;
 exports.deriveCircuitId = deriveCircuitId;
+exports.parseDuration = parseDuration;
+exports.resolveTimeWindow = resolveTimeWindow;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map