@opendatalabs/vana-sdk 3.19.0 → 3.19.1

package/dist/index.node.cjs

@@ -1196,6 +1196,7 @@ __export(index_node_exports, {
   DataPointVersionConflictError: () => DataPointVersionConflictError,
   DerivativeComputeUnavailableError: () => DerivativeComputeUnavailableError,
   DerivativeCycleError: () => DerivativeCycleError,
+  DerivativeDerivedScopeRequiredError: () => DerivativeDerivedScopeRequiredError,
   DerivativeQuestionFailedError: () => DerivativeQuestionFailedError,
   DerivativeQuestionInvalidError: () => DerivativeQuestionInvalidError,
   DerivativeQuestionNotFoundError: () => DerivativeQuestionNotFoundError,
@@ -1655,6 +1656,17 @@ var DerivativeQuestionNotFoundError = class extends PersonalServerWriteError {
     super(message, "DERIVATIVE_QUESTION_NOT_FOUND", 404, errorCode, details);
   }
 };
+var DerivativeDerivedScopeRequiredError = class extends PersonalServerWriteError {
+  constructor(message, errorCode = null, details) {
+    super(
+      message,
+      "DERIVATIVE_DERIVED_SCOPE_REQUIRED",
+      400,
+      errorCode,
+      details
+    );
+  }
+};
 var DerivativeSourceNotGrantedError = class extends PersonalServerWriteError {
   constructor(message, errorCode = null, details) {
     super(message, "DERIVATIVE_SOURCE_NOT_GRANTED", 403, errorCode, details);
@@ -29431,6 +29443,9 @@ async function buildWeb3SignedHeader(params) {
   if (params.grantId !== void 0) {
     payload["grantId"] = params.grantId;
   }
+  if (params.nonce !== void 0) {
+    payload["nonce"] = params.nonce;
+  }
   const sortedPayload = Object.keys(payload).sort().reduce((acc, key) => {
     acc[key] = payload[key];
     return acc;
@@ -34755,6 +34770,18 @@ function nextProofIat(proofKey) {
   if (waitSec <= 0) return Promise.resolve(iat);
   return sleep2(waitSec * 1e3).then(() => iat);
 }
+function freshProofNonce() {
+  const webCrypto = globalThis.crypto;
+  if (typeof webCrypto?.randomUUID === "function") {
+    return webCrypto.randomUUID();
+  }
+  if (typeof webCrypto?.getRandomValues === "function") {
+    return (0, import_viem23.bytesToHex)(webCrypto.getRandomValues(new Uint8Array(16)));
+  }
+  throw new WriteRequestError(
+    "No secure random source available to build a proof nonce; provide a crypto global"
+  );
+}
 function proofKeyFor(parts) {
   return (0, import_viem23.bytesToHex)(
     (0, import_sha25.sha256)(
@@ -35296,12 +35323,7 @@ var DerivativeQuestionSchema = import_zod5.z.object({
 var QuestionListSchema = import_zod5.z.object({
   questions: import_zod5.z.array(DerivativeQuestionSchema)
 });
-var QuestionRecomputeResultSchema = import_zod5.z.object({
-  questionId: import_zod5.z.string().min(1),
-  derivedScope: import_zod5.z.string().min(1),
-  /** `pending` when the question was never computed, else `stale`. */
-  status: QuestionStatusSchema
-});
+var QuestionRecomputeResultSchema = DerivativeQuestionSchema;
 var QuestionDeleteResultSchema = import_zod5.z.object({
   questionId: import_zod5.z.string().min(1),
   deleted: import_zod5.z.literal(true)
@@ -35369,8 +35391,18 @@ async function resolveSession(params, resolved, force) {
   cache.set(resolved.cacheKey, session);
   return session;
 }
-async function questionErrorFromResponse(response) {
-  const { errorCode, message, details } = await readPersonalServerErrorBody(response);
+var PROOF_FAILURE_CODES = /* @__PURE__ */ new Set([
+  "WRITE_ATTRIBUTION_REQUIRED",
+  "WRITE_ATTRIBUTION_INVALID",
+  "WRITE_ATTRIBUTION_SIGNER_MISMATCH",
+  "WRITE_ATTRIBUTION_GRANT_MISMATCH",
+  "WRITE_ATTRIBUTION_REPLAY"
+]);
+function isStaleSession(errorCode) {
+  return errorCode === null || !PROOF_FAILURE_CODES.has(errorCode);
+}
+async function questionErrorFromResponse(response, body) {
+  const { errorCode, message, details } = body ?? await readPersonalServerErrorBody(response);
   const text = message ?? `Derivative question request failed: ${response.status} ${response.statusText}`;
   switch (errorCode) {
     case "DERIVATIVE_SOURCE_NOT_GRANTED":
@@ -35389,6 +35421,8 @@ async function questionErrorFromResponse(response) {
       );
     case "DERIVATIVE_QUESTION_NOT_FOUND":
       return new DerivativeQuestionNotFoundError(text, errorCode, details);
+    case "DERIVATIVE_DERIVED_SCOPE_REQUIRED":
+      return new DerivativeDerivedScopeRequiredError(text, errorCode, details);
     default:
       break;
   }
@@ -35418,7 +35452,7 @@ async function sendOnce(params, resolved, session, spec, bodyBytes) {
     proofKeyFor({
       aud: session.audience,
       method: spec.method,
-      uri: spec.path,
+      uri: spec.target,
       grantId: session.grantId,
       signedBytes: bodyBytes
     }),
@@ -35434,17 +35468,22 @@ async function sendOnce(params, resolved, session, spec, bodyBytes) {
         await buildWeb3SignedHeader({
           signMessage: session.signer.signMessage,
           aud: session.audience,
-          // The Personal Server verifies the proof against the request's
-          // path only, so the signed `uri` must not carry the query string.
-          uri: spec.path,
+          // The proof commits to the whole request target, query included:
+          // `?derivedScope=` is what the list route authorizes against, and a
+          // proof that did not cover it would authorize any other scope.
+          uri: spec.target,
           method: spec.method,
           body: bodyBytes,
           grantId: session.grantId,
+          // Fresh per attempt, so a retry after a thrown `fetch` is never the
+          // proof the server may already have consumed, and so two identical
+          // polls inside one second stay distinct.
+          nonce: freshProofNonce(),
           iat
         })
       );
       return {
-        url: `${resolved.baseUrl}${spec.path}${spec.query ?? ""}`,
+        url: `${resolved.baseUrl}${spec.target}`,
         init: {
           method: spec.method,
           headers,
@@ -35460,12 +35499,17 @@ async function sendQuestionRequest(params, spec, schema) {
   const bodyBytes = spec.body === void 0 ? void 0 : new TextEncoder().encode(JSON.stringify(spec.body));
   let session = await resolveSession(params, resolved, false);
   let response = await sendOnce(params, resolved, session, spec, bodyBytes);
+  let errorBody;
   if (response.status === 401) {
-    session = await resolveSession(params, resolved, true);
-    response = await sendOnce(params, resolved, session, spec, bodyBytes);
+    errorBody = await readPersonalServerErrorBody(response);
+    if (isStaleSession(errorBody.errorCode)) {
+      session = await resolveSession(params, resolved, true);
+      response = await sendOnce(params, resolved, session, spec, bodyBytes);
+      errorBody = void 0;
+    }
   }
   if (!response.ok) {
-    throw await questionErrorFromResponse(response);
+    throw await questionErrorFromResponse(response, errorBody);
   }
   let body;
   try {
@@ -35559,7 +35603,7 @@ async function registerQuestion(params) {
     params,
     {
       method: "POST",
-      path: DERIVATIVE_QUESTIONS_PATH,
+      target: DERIVATIVE_QUESTIONS_PATH,
       body,
       label: "Register derivative question"
     },
@@ -35567,10 +35611,10 @@ async function registerQuestion(params) {
   );
 }
 async function getQuestion(params) {
-  const path = assertQuestionId(params.questionId);
+  const target = assertQuestionId(params.questionId);
   return sendQuestionRequest(
     params,
-    { method: "GET", path, label: "Read derivative question" },
+    { method: "GET", target, label: "Read derivative question" },
     DerivativeQuestionSchema
   );
 }
@@ -35580,12 +35624,12 @@ async function listQuestions(params) {
       "derivedScope is required; a builder may only list its own questions on a scope it may write"
     );
   }
+  const target = `${DERIVATIVE_QUESTIONS_PATH}?derivedScope=${encodeURIComponent(params.derivedScope)}`;
   const { questions } = await sendQuestionRequest(
     params,
     {
       method: "GET",
-      path: DERIVATIVE_QUESTIONS_PATH,
-      query: `?derivedScope=${encodeURIComponent(params.derivedScope)}`,
+      target,
       label: "List derivative questions"
     },
     QuestionListSchema
@@ -35593,18 +35637,18 @@ async function listQuestions(params) {
   return questions;
 }
 async function recomputeQuestion(params) {
-  const path = `${assertQuestionId(params.questionId)}/recompute`;
+  const target = `${assertQuestionId(params.questionId)}/recompute`;
   return sendQuestionRequest(
     params,
-    { method: "POST", path, label: "Recompute derivative question" },
+    { method: "POST", target, label: "Recompute derivative question" },
     QuestionRecomputeResultSchema
   );
 }
 async function deleteQuestion(params) {
-  const path = assertQuestionId(params.questionId);
+  const target = assertQuestionId(params.questionId);
   return sendQuestionRequest(
     params,
-    { method: "DELETE", path, label: "Delete derivative question" },
+    { method: "DELETE", target, label: "Delete derivative question" },
     QuestionDeleteResultSchema
   );
 }
@@ -36770,6 +36814,7 @@ async function parsePSError(response) {
   DataPointVersionConflictError,
   DerivativeComputeUnavailableError,
   DerivativeCycleError,
+  DerivativeDerivedScopeRequiredError,
   DerivativeQuestionFailedError,
   DerivativeQuestionInvalidError,
   DerivativeQuestionNotFoundError,