@opendatalabs/vana-sdk 3.22.0-pr.208.28eb140 → 3.22.0-pr.208.e9c19e9

package/dist/index.browser.js

@@ -31948,7 +31948,7 @@ var MAX_JOB_DEADLINE_SECONDS = 3600;
 // src/crypto/envelope/job.ts
 init_interface();
 import { sha256 as sha2565 } from "@noble/hashes/sha2";
-import { bytesToHex as bytesToHex2, fromHex as fromHex6, toHex as toHex7 } from "viem";
+import { bytesToHex as bytesToHex2, fromHex as fromHex6, isAddress, isHex, toHex as toHex7 } from "viem";
 var textDecoder = new TextDecoder();
 var textEncoder = new TextEncoder();
 var JobEnvelopeError = class extends Error {
@@ -31975,9 +31975,11 @@ function canonicalJsonBytes(value) {
   return textEncoder.encode(JSON.stringify(sortJsonKeys(value)));
 }
 function canonicalJobRequestBytes(request) {
+  validateJobRequest(request);
   return canonicalJsonBytes(request);
 }
 function requestPlaintext(envelope) {
+  validateRequestEnvelope(envelope);
   return canonicalJsonBytes(envelope);
 }
 function resultPlaintext(result) {
@@ -32010,42 +32012,99 @@ function parseObject(plaintext, kind) {
     throw new JobEnvelopeError(`Invalid ${kind}: malformed JSON`);
   }
 }
+function isPlainObject2(value) {
+  if (value === null || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function requirePlainObject(value, field, kind) {
+  if (!isPlainObject2(value)) {
+    throw new JobEnvelopeError(`Invalid ${kind}: invalid ${field}`);
+  }
+}
+function requireExactKeys(value, expectedKeys, kind) {
+  for (const key of expectedKeys) {
+    if (!Object.hasOwn(value, key) || value[key] === void 0) {
+      throw new JobEnvelopeError(`Invalid ${kind}: missing ${key}`);
+    }
+  }
+  const expected = new Set(expectedKeys);
+  for (const key of Reflect.ownKeys(value)) {
+    if (!expected.has(key)) {
+      throw new JobEnvelopeError(
+        `Invalid ${kind}: unknown field ${String(key)}`
+      );
+    }
+  }
+}
 function requireString(value, field, kind) {
   if (typeof value !== "string" || value.length === 0) {
     throw new JobEnvelopeError(`Invalid ${kind}: missing ${field}`);
   }
 }
-function validateRequestEnvelope(value) {
-  const request = value.request;
-  if (request === null || typeof request !== "object" || Array.isArray(request)) {
-    throw new JobEnvelopeError("Invalid job request envelope: missing request");
-  }
-  const fields = request;
-  if (fields.v !== 1) {
+function validateJobRequest(value) {
+  requirePlainObject(value, "request", "job request");
+  requireExactKeys(
+    value,
+    [
+      "v",
+      "jobId",
+      "owner",
+      "builder",
+      "builderPublicKey",
+      "grantId",
+      "scope",
+      "operation",
+      "pinnedVersion",
+      "deadline"
+    ],
+    "job request"
+  );
+  if (value.v !== JOB_PROTOCOL_VERSION) {
     throw new JobEnvelopeError(
-      `Unsupported job request version: ${String(fields.v)}`
+      `Unsupported job request version: ${String(value.v)}`
     );
   }
-  for (const field of [
-    "jobId",
-    "owner",
-    "builder",
-    "builderPublicKey",
-    "grantId",
-    "scope",
-    "operation",
-    "deadline"
-  ]) {
-    requireString(fields[field], field, "job request");
-  }
-  if (fields.pinnedVersion !== null && typeof fields.pinnedVersion !== "string") {
+  requireString(value.jobId, "jobId", "job request");
+  if (typeof value.owner !== "string" || !isAddress(value.owner)) {
+    throw new JobEnvelopeError("Invalid job request: invalid owner");
+  }
+  if (typeof value.builder !== "string" || !isAddress(value.builder)) {
+    throw new JobEnvelopeError("Invalid job request: invalid builder");
+  }
+  if (typeof value.builderPublicKey !== "string" || !isHex(value.builderPublicKey)) {
+    throw new JobEnvelopeError("Invalid job request: invalid builderPublicKey");
+  }
+  if (typeof value.grantId !== "string" || !isHex(value.grantId)) {
+    throw new JobEnvelopeError("Invalid job request: invalid grantId");
+  }
+  requireString(value.scope, "scope", "job request");
+  if (!JOB_OPERATIONS.includes(value.operation)) {
+    throw new JobEnvelopeError("Invalid job request: invalid operation");
+  }
+  if (value.pinnedVersion !== null && typeof value.pinnedVersion !== "string") {
     throw new JobEnvelopeError("Invalid job request: missing pinnedVersion");
   }
+  if (typeof value.deadline !== "string" || !Number.isFinite(Date.parse(value.deadline))) {
+    throw new JobEnvelopeError("Invalid job request: invalid deadline");
+  }
+  return value;
+}
+function validateRequestEnvelope(value) {
+  requirePlainObject(value, "envelope", "job request envelope");
+  requireExactKeys(value, ["request", "auth"], "job request envelope");
+  validateJobRequest(value.request);
   requireString(value.auth, "auth", "job request envelope");
   return value;
 }
 function validateResult(value) {
-  if (value.v !== 1) {
+  requirePlainObject(value, "result", "job result");
+  requireExactKeys(
+    value,
+    ["v", "jobId", "scope", "version", "contentType", "body"],
+    "job result"
+  );
+  if (value.v !== JOB_PROTOCOL_VERSION) {
     throw new JobEnvelopeError(
       `Unsupported job result version: ${String(value.v)}`
     );
@@ -32061,10 +32120,10 @@ function validateResult(value) {
   }
   return value;
 }
-async function sealJobRequest(e, enclavePublicKey, ecies) {
+async function sealJobRequest(envelope, enclavePublicKey, ecies) {
   const encrypted = await ecies.encrypt(
     fromHex6(enclavePublicKey, "bytes"),
-    requestPlaintext(e)
+    requestPlaintext(envelope)
   );
   return encryptedBytesToBase64(encrypted);
 }
@@ -32077,10 +32136,11 @@ async function openJobRequest(ciphertext, privateKey, ecies) {
     parseObject(plaintext, "job request envelope")
   );
 }
-async function sealJobResult(r, builderPublicKey, ecies) {
+async function sealJobResult(result, builderPublicKey, ecies) {
+  validateResult(result);
   const encrypted = await ecies.encrypt(
     fromHex6(builderPublicKey, "bytes"),
-    resultPlaintext(r)
+    resultPlaintext(result)
   );
   const ciphertext = encryptedBytesToBase64(encrypted);
   const bytes = fromBase64(ciphertext);
@@ -32112,7 +32172,7 @@ async function openJobResult(ciphertext, builderPrivateKey, ecies, expect) {
 
 // src/protocol/personal-server-registration.ts
 import {
-  isAddress
+  isAddress as isAddress2
 } from "viem";
 var PERSONAL_SERVER_REGISTRATION_DEFAULT_CHAIN_ID = vanaMainnet2.id;
 var PERSONAL_SERVER_REGISTRATION_DEFAULT_VERIFYING_CONTRACT = getContractAddress(
@@ -32120,7 +32180,7 @@ var PERSONAL_SERVER_REGISTRATION_DEFAULT_VERIFYING_CONTRACT = getContractAddress
   "DataPortabilityServers"
 );
 function assertAddress(value, name) {
-  if (!isAddress(value)) {
+  if (!isAddress2(value)) {
     throw new Error(`${name} must be a valid EVM address`);
   }
 }
@@ -32207,13 +32267,13 @@ var registerPersonalServerSignature = buildPersonalServerRegistrationSignature;
 
 // src/personal-server-lite/owner-binding.ts
 import {
-  isAddress as isAddress2
+  isAddress as isAddress3
 } from "viem";
 var PERSONAL_SERVER_LITE_OWNER_BINDING_VERSION = "vana.ps-lite.owner-binding.v1";
 var PERSONAL_SERVER_LITE_OWNER_BINDING_PURPOSE = "ps-lite-owner";
 var PERSONAL_SERVER_LITE_OWNER_BINDING_PREFIX = `${PERSONAL_SERVER_LITE_OWNER_BINDING_VERSION}:${PERSONAL_SERVER_LITE_OWNER_BINDING_PURPOSE}:`;
 function assertAddress2(value, name) {
-  if (!isAddress2(value)) {
+  if (!isAddress3(value)) {
     throw new Error(`${name} must be a valid EVM address`);
   }
 }
@@ -32263,7 +32323,7 @@ async function buildPersonalServerLiteOwnerBindingSignature(input) {
 var signPersonalServerLiteOwnerBinding = buildPersonalServerLiteOwnerBindingSignature;
 
 // src/account/personal-server-registration.ts
-import { isAddress as isAddress3 } from "viem";
+import { isAddress as isAddress4 } from "viem";
 var ACCOUNT_PERSONAL_SERVER_REGISTRATION_INTENT = "personal_server.server_registration.v1";
 var AccountPersonalServerRegistrationError = class extends Error {
   status;
@@ -32282,7 +32342,7 @@ function trimTrailingSlash(value) {
   return value.replace(/\/+$/, "");
 }
 function assertAddress3(value, name) {
-  if (!isAddress3(value)) {
+  if (!isAddress4(value)) {
     throw new Error(`${name} must be a valid EVM address`);
   }
 }
@@ -32808,7 +32868,7 @@ function buildMarkDataPointUnavailableRequest(config, input) {
 
 // src/protocol/data-point-deletion.ts
 import {
-  isAddress as isAddress5,
+  isAddress as isAddress6,
   keccak256 as keccak2563,
   maxUint256,
   stringToBytes as stringToBytes3
@@ -32817,7 +32877,7 @@ import {
 // src/protocol/lineage.ts
 import {
   encodeAbiParameters,
-  isAddress as isAddress4,
+  isAddress as isAddress5,
   keccak256 as keccak2562
 } from "viem";
 import { z } from "zod";
@@ -32897,7 +32957,7 @@ function isDataPointId(value) {
   return typeof value === "string" && DATA_POINT_ID_PATTERN.test(value);
 }
 function deriveDataPointId(ownerAddress, scope) {
-  if (!isAddress4(ownerAddress, { strict: false })) {
+  if (!isAddress5(ownerAddress, { strict: false })) {
     throw new Error(
       `ownerAddress is not an EVM address: ${String(ownerAddress)}`
     );
@@ -33148,7 +33208,7 @@ function tombstoneDeletedAt(value) {
   return typeof deletedAt === "string" ? deletedAt : null;
 }
 function assertAddress4(value, name) {
-  if (!isAddress5(value)) {
+  if (!isAddress6(value)) {
     throw new Error(`${name} must be a valid EVM address`);
   }
 }
@@ -33564,7 +33624,7 @@ function tryGrantPermissions(scopes) {
 
 // src/protocol/personal-server-write.ts
 import { sha256 as sha2567 } from "@noble/hashes/sha2";
-import { bytesToHex as bytesToHex4, isAddress as isAddress6 } from "viem";
+import { bytesToHex as bytesToHex4, isAddress as isAddress7 } from "viem";
 import { z as z4 } from "zod";
 
 // src/protocol/write-request.ts
@@ -33886,7 +33946,7 @@ function normalizeLineage(lineage, derivedScope) {
   for (const entry of lineage) {
     let id;
     if (isLineagePair(entry)) {
-      if (!isAddress6(entry.ownerAddress, { strict: false })) {
+      if (!isAddress7(entry.ownerAddress, { strict: false })) {
         throw new WriteRequestError(
           "lineage source ownerAddress must be an EVM address",
           { ownerAddress: entry.ownerAddress }
@@ -35182,7 +35242,7 @@ function createGatewayClient(baseUrl) {
 }
 
 // src/protocol/escrow.ts
-import { isHex } from "viem";
+import { isHex as isHex2 } from "viem";
 var GENERIC_PAYMENT_TYPES = {
   GenericPayment: [
     { name: "payerAddress", type: "address" },
@@ -35398,10 +35458,10 @@ function optionalUint256Decimal(value) {
   return value === void 0 || isUint256Decimal(value);
 }
 function isAddressHex(value) {
-  return typeof value === "string" && isHex(value, { strict: true }) && value.length === 42;
+  return typeof value === "string" && isHex2(value, { strict: true }) && value.length === 42;
 }
 function isHash(value) {
-  return typeof value === "string" && isHex(value, { strict: true }) && value.length === 66;
+  return typeof value === "string" && isHex2(value, { strict: true }) && value.length === 66;
 }
 function isUint256Decimal(value) {
   if (typeof value !== "string" || value.length === 0 || value.length > 78) {