@opendatalabs/vana-sdk 0.1.0-alpha.170e27e → 0.1.0-alpha.18ba63a

package/dist/index.browser.js

@@ -428,8 +428,10 @@ var init_dataSchema_schema = __esm({
 // src/utils/schemaValidation.ts
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
-function validateDataSchema(schema) {
-  return schemaValidator.validateDataSchema(schema);
+function validateDataSchemaAgainstMetaSchema(schema) {
+  const validator = schemaValidator;
+  validator.validateDataSchemaAgainstMetaSchema(schema);
+  return schema;
 }
 function validateDataAgainstSchema(data, schema) {
   return schemaValidator.validateDataAgainstSchema(data, schema);
@@ -462,9 +464,9 @@ var init_schemaValidation = __esm({
         this.dataSchemaValidator = this.ajv.compile(dataSchema_schema_default);
       }
       /**
-       * Validates a data schema against the Vana meta-schema
+       * Validates a data schema definition against the Vana meta-schema
        *
-       * @param schema - The data schema to validate
+       * @param schema - The data schema definition to validate
        * @throws SchemaValidationError if invalid
        * @example
        * ```typescript
@@ -483,10 +485,10 @@ var init_schemaValidation = __esm({
        *   }
        * };
        *
-       * validator.validateDataSchema(schema); // throws if invalid
+       * validator.validateDataSchemaAgainstMetaSchema(schema); // throws if invalid
        * ```
        */
-      validateDataSchema(schema) {
+      validateDataSchemaAgainstMetaSchema(schema) {
         const isValid = this.dataSchemaValidator(schema);
         if (!isValid) {
           const errors = this.dataSchemaValidator.errors || [];
@@ -506,10 +508,10 @@ var init_schemaValidation = __esm({
         }
       }
       /**
-       * Validates data against a JSON Schema from a schema
+       * Validates data against a JSON Schema
        *
        * @param data - The data to validate
-       * @param schema - The schema containing the validation rules (DataSchema or Schema)
+       * @param schema - The schema containing the validation rules (must have been validated or fetched from chain)
        * @throws SchemaValidationError if invalid
        * @example
        * ```typescript
@@ -519,25 +521,22 @@ var init_schemaValidation = __esm({
        * const schema = await vana.schemas.get(1);
        * validator.validateDataAgainstSchema(userData, schema);
        *
-       * // Also works with DataSchema object
-       * const dataSchema: DataSchema = {
+       * // Also works with pre-validated DataSchema object
+       * const dataSchema = validator.validateDataSchemaAgainstMetaSchema({
        *   name: "User Profile",
        *   version: "1.0.0",
        *   dialect: "json",
        *   schema: { type: "object", properties: { name: { type: "string" } } }
-       * };
+       * });
        * validator.validateDataAgainstSchema(userData, dataSchema);
        * ```
        */
       validateDataAgainstSchema(data, schema) {
-        if (!("id" in schema)) {
-          this.validateDataSchema(schema);
-        }
         if (schema.dialect !== "json") {
-          throw new SchemaValidationError(
-            `Data validation only supported for JSON dialect, got: ${schema.dialect}`,
-            []
+          console.warn(
+            `[SchemaValidator] Data validation skipped: dialect '${schema.dialect}' does not support data validation. Only JSON schemas can validate data structure.`
           );
+          return;
         }
         if (typeof schema.schema !== "object") {
           throw new SchemaValidationError(
@@ -603,9 +602,9 @@ var init_schemaValidation = __esm({
         }
       }
       /**
-       * Fetches and validates a schema from a URL
+       * Fetches and validates a data schema from a URL
        *
-       * @param url - The URL to fetch the schema from
+       * @param url - The URL to fetch the data schema from
        * @returns The validated data schema
        * @throws SchemaValidationError if invalid or fetch fails
        * @example
@@ -621,7 +620,7 @@ var init_schemaValidation = __esm({
             throw new Error(`HTTP ${response.status}: ${response.statusText}`);
           }
           const schema = await response.json();
-          this.validateDataSchema(schema);
+          this.validateDataSchemaAgainstMetaSchema(schema);
           if (schema.dialect === "sqlite" && typeof schema.schema === "string") {
             this.validateSQLiteDDL(schema.schema, schema.dialectVersion);
           }
@@ -1270,19 +1269,19 @@ var init_eventMappings = __esm({
       // DataRegistry operations
       addFile: {
         contract: "DataRegistry",
-        event: "FileAdded"
+        event: "FileAddedV2"
       },
       addFileWithPermissionsAndSchema: {
         contract: "DataRegistry",
-        event: "FileAdded"
+        event: "FileAddedV2"
       },
       addFileWithSchema: {
         contract: "DataRegistry",
-        event: "FileAdded"
+        event: "FileAddedV2"
       },
       addFileWithPermissions: {
         contract: "DataRegistry",
-        event: "FileAdded"
+        event: "FileAddedV2"
       },
       addRefinement: {
         contract: "DataRegistry",
@@ -2769,6 +2768,37 @@ var init_DataRegistryImplementation = __esm({
         name: "FileAdded",
         type: "event"
       },
+      {
+        anonymous: false,
+        inputs: [
+          {
+            indexed: true,
+            internalType: "uint256",
+            name: "fileId",
+            type: "uint256"
+          },
+          {
+            indexed: true,
+            internalType: "address",
+            name: "ownerAddress",
+            type: "address"
+          },
+          {
+            indexed: false,
+            internalType: "string",
+            name: "url",
+            type: "string"
+          },
+          {
+            indexed: false,
+            internalType: "uint256",
+            name: "schemaId",
+            type: "uint256"
+          }
+        ],
+        name: "FileAddedV2",
+        type: "event"
+      },
       {
         anonymous: false,
         inputs: [
@@ -3008,6 +3038,19 @@ var init_DataRegistryImplementation = __esm({
         name: "Upgraded",
         type: "event"
       },
+      {
+        inputs: [],
+        name: "DATA_PORTABILITY_ROLE",
+        outputs: [
+          {
+            internalType: "bytes32",
+            name: "",
+            type: "bytes32"
+          }
+        ],
+        stateMutability: "view",
+        type: "function"
+      },
       {
         inputs: [],
         name: "DEFAULT_ADMIN_ROLE",
@@ -3102,6 +3145,41 @@ var init_DataRegistryImplementation = __esm({
         stateMutability: "nonpayable",
         type: "function"
       },
+      {
+        inputs: [
+          {
+            internalType: "uint256",
+            name: "fileId",
+            type: "uint256"
+          },
+          {
+            components: [
+              {
+                internalType: "address",
+                name: "account",
+                type: "address"
+              },
+              {
+                internalType: "string",
+                name: "key",
+                type: "string"
+              }
+            ],
+            internalType: "struct IDataRegistry.Permission[]",
+            name: "permissions",
+            type: "tuple[]"
+          },
+          {
+            internalType: "uint256",
+            name: "schemaId",
+            type: "uint256"
+          }
+        ],
+        name: "addFilePermissionsAndSchema",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
+      },
       {
         inputs: [
           {
@@ -3316,6 +3394,19 @@ var init_DataRegistryImplementation = __esm({
         stateMutability: "view",
         type: "function"
       },
+      {
+        inputs: [],
+        name: "emitLegacyEvents",
+        outputs: [
+          {
+            internalType: "bool",
+            name: "",
+            type: "bool"
+          }
+        ],
+        stateMutability: "view",
+        type: "function"
+      },
       {
         inputs: [
           {
@@ -3473,6 +3564,11 @@ var init_DataRegistryImplementation = __esm({
                 name: "url",
                 type: "string"
               },
+              {
+                internalType: "uint256",
+                name: "schemaId",
+                type: "uint256"
+              },
               {
                 internalType: "uint256",
                 name: "addedAtBlock",
@@ -3756,6 +3852,19 @@ var init_DataRegistryImplementation = __esm({
         stateMutability: "nonpayable",
         type: "function"
       },
+      {
+        inputs: [
+          {
+            internalType: "bool",
+            name: "newEmitLegacyEvents",
+            type: "bool"
+          }
+        ],
+        name: "updateEmitLegacyEvents",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
+      },
       {
         inputs: [
           {
@@ -36561,7 +36670,7 @@ var init_schemas = __esm({
             dialect,
             schema: schemaDefinition
           };
-          validateDataSchema(dataSchema);
+          validateDataSchemaAgainstMetaSchema(dataSchema);
           if (!this.context.storageManager) {
             if (this.context.validateStorageRequired) {
               this.context.validateStorageRequired();
@@ -36670,7 +36779,7 @@ var init_schemas = __esm({
             `Invalid schema definition format for schema ${schemaId}`
           );
         }
-        validateDataSchema(definition);
+        validateDataSchemaAgainstMetaSchema(definition);
         const dataSchema = definition;
         if (dataSchema.name !== metadata.name) {
           throw new Error(
@@ -37005,7 +37114,7 @@ var init_schemas = __esm({
             try {
               const definition = await fetchFromUrl(schema.definitionUrl);
               if (definition && typeof definition === "object") {
-                validateDataSchema(definition);
+                validateDataSchemaAgainstMetaSchema(definition);
                 const dataSchema = definition;
                 schema.version = dataSchema.version;
                 schema.description = dataSchema.description;
@@ -41878,6 +41987,29 @@ var DataController = class {
       const userFiles = Array.from(fileMap.values()).sort(
         (a, b) => Number((b.addedAtTimestamp || 0n) - (a.addedAtTimestamp || 0n))
       );
+      if (userFiles.length > 0) {
+        try {
+          const fileIds = userFiles.map((f) => f.id);
+          let proofMap;
+          try {
+            proofMap = await this._fetchProofsFromSubgraph(fileIds, endpoint);
+          } catch (subgraphError) {
+            console.debug(
+              "Failed to fetch proofs from subgraph, trying chain:",
+              subgraphError
+            );
+            proofMap = await this._fetchProofsFromChain(fileIds);
+          }
+          for (const file of userFiles) {
+            const dlpIds = proofMap.get(file.id);
+            if (dlpIds && dlpIds.length > 0) {
+              file.dlpIds = dlpIds;
+            }
+          }
+        } catch (error) {
+          console.warn("Failed to fetch proof data for files:", error);
+        }
+      }
       return userFiles;
     } catch (error) {
       console.error("Failed to fetch user files from subgraph:", error);
@@ -41886,6 +42018,349 @@ var DataController = class {
       );
     }
   }
+  /**
+   * Fetches proof data for multiple files from the subgraph.
+   *
+   * @private
+   * @param fileIds - Array of file IDs to fetch proofs for
+   * @param subgraphUrl - The subgraph endpoint URL
+   * @returns Map of file IDs to their associated DLP IDs
+   */
+  async _fetchProofsFromSubgraph(fileIds, subgraphUrl) {
+    const query = `
+      query GetFileProofs($fileIds: [BigInt!]!) {
+        dataRegistryProofs(where: { fileId_in: $fileIds }) {
+          fileId
+          dlp {
+            id
+          }
+        }
+      }
+    `;
+    const response = await fetch(subgraphUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        query,
+        variables: {
+          fileIds: fileIds.map((id) => id.toString())
+        }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Subgraph request failed: ${response.status} ${response.statusText}`
+      );
+    }
+    const result = await response.json();
+    if (result.errors) {
+      throw new Error(
+        `Subgraph errors: ${result.errors.map((e) => e.message).join(", ")}`
+      );
+    }
+    const proofMap = /* @__PURE__ */ new Map();
+    if (result.data?.dataRegistryProofs) {
+      for (const proof of result.data.dataRegistryProofs) {
+        if (proof.dlp?.id) {
+          const fileId = parseInt(proof.fileId);
+          const dlpId = parseInt(proof.dlp.id);
+          if (!proofMap.has(fileId)) {
+            proofMap.set(fileId, []);
+          }
+          const dlpIds = proofMap.get(fileId);
+          if (!dlpIds.includes(dlpId)) {
+            dlpIds.push(dlpId);
+          }
+        }
+      }
+    }
+    return proofMap;
+  }
+  /**
+   * Fetches proof data for multiple files from the blockchain.
+   * Falls back to this when subgraph is unavailable.
+   *
+   * @private
+   * @param fileIds - Array of file IDs to fetch proofs for
+   * @returns Map of file IDs to their associated DLP IDs
+   */
+  async _fetchProofsFromChain(fileIds) {
+    const chainId = this.context.walletClient.chain?.id;
+    if (!chainId) {
+      throw new Error("Chain ID not available");
+    }
+    const dataRegistryAddress = getContractAddress(chainId, "DataRegistry");
+    const dataRegistryAbi = getAbi("DataRegistry");
+    const proofMap = /* @__PURE__ */ new Map();
+    for (const fileId of fileIds) {
+      const dlpIds = [];
+      let proofIndex = 0;
+      let hasMoreProofs = true;
+      while (hasMoreProofs) {
+        try {
+          const proof = await this.context.publicClient.readContract({
+            address: dataRegistryAddress,
+            abi: dataRegistryAbi,
+            functionName: "fileProofs",
+            args: [BigInt(fileId), BigInt(proofIndex)]
+          });
+          if (proof?.data?.dlpId) {
+            const dlpId = Number(proof.data.dlpId);
+            if (!dlpIds.includes(dlpId)) {
+              dlpIds.push(dlpId);
+            }
+          }
+          proofIndex++;
+        } catch {
+          hasMoreProofs = false;
+        }
+      }
+      if (dlpIds.length > 0) {
+        proofMap.set(fileId, dlpIds);
+      }
+    }
+    return proofMap;
+  }
+  /**
+   * Retrieves information about a specific Data Liquidity Pool (DLP).
+   *
+   * @remarks
+   * DLPs are entities that process and verify data files in the Vana network.
+   * This method fetches DLP metadata including name, status, and performance rating.
+   * Uses subgraph first for efficiency, falls back to chain if unavailable.
+   *
+   * @param dlpId - The unique identifier of the DLP
+   * @param options - Optional parameters
+   * @param options.subgraphUrl - Custom subgraph URL to override default
+   * @returns Promise resolving to DLP information
+   * @throws {Error} When DLP cannot be found - "DLP not found: {dlpId}"
+   * @throws {Error} When query fails - "Failed to fetch DLP: {error}"
+   * @example
+   * ```typescript
+   * const dlp = await vana.data.getDLP(26);
+   * console.log(`DLP ${dlp.name}: ${dlp.status}`);
+   * ```
+   */
+  async getDLP(dlpId, options = {}) {
+    const subgraphUrl = options.subgraphUrl || this.context.subgraphUrl;
+    if (subgraphUrl) {
+      try {
+        const query = `
+          query GetDLP($id: ID!) {
+            dlp(id: $id) {
+              id
+              name
+              metadata
+              status
+              address
+              owner
+            }
+          }
+        `;
+        const response = await fetch(subgraphUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            query,
+            variables: {
+              id: dlpId.toString()
+            }
+          })
+        });
+        if (!response.ok) {
+          throw new Error(
+            `Subgraph request failed: ${response.status} ${response.statusText}`
+          );
+        }
+        const result = await response.json();
+        if (result.errors) {
+          throw new Error(
+            `Subgraph errors: ${result.errors.map((e) => e.message).join(", ")}`
+          );
+        }
+        if (!result.data?.dlp) {
+          throw new Error(`DLP not found: ${dlpId}`);
+        }
+        return {
+          id: parseInt(result.data.dlp.id),
+          name: result.data.dlp.name || "",
+          metadata: result.data.dlp.metadata,
+          status: result.data.dlp.status ? parseInt(result.data.dlp.status) : void 0,
+          address: result.data.dlp.address,
+          owner: result.data.dlp.owner
+        };
+      } catch (error) {
+        console.debug("Subgraph query failed, falling back to chain:", error);
+      }
+    }
+    try {
+      const chainId = this.context.walletClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dlpRegistryAddress = getContractAddress(chainId, "DLPRegistry");
+      const dlpRegistryAbi = getAbi("DLPRegistry");
+      const dlpData = await this.context.publicClient.readContract({
+        address: dlpRegistryAddress,
+        abi: dlpRegistryAbi,
+        functionName: "dlps",
+        args: [BigInt(dlpId)]
+      });
+      if (!dlpData || !dlpData.name) {
+        throw new Error(`DLP not found: ${dlpId}`);
+      }
+      return {
+        id: dlpId,
+        name: dlpData.name,
+        metadata: dlpData.metadata,
+        status: dlpData.status,
+        address: dlpData.dlpAddress,
+        owner: dlpData.ownerAddress
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to fetch DLP: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Lists all Data Liquidity Pools (DLPs) with optional pagination.
+   *
+   * @remarks
+   * Fetches a paginated list of all DLPs registered in the network.
+   * Uses subgraph for efficient querying with fallback to chain multicall.
+   *
+   * @param options - Optional parameters for pagination and filtering
+   * @param options.limit - Maximum number of DLPs to return (default: 100)
+   * @param options.offset - Number of DLPs to skip (default: 0)
+   * @param options.subgraphUrl - Custom subgraph URL to override default
+   * @returns Promise resolving to array of DLP information
+   * @throws {Error} When query fails - "Failed to list DLPs: {error}"
+   * @example
+   * ```typescript
+   * // Get first 10 DLPs
+   * const dlps = await vana.data.listDLPs({ limit: 10 });
+   * dlps.forEach(dlp => console.log(`${dlp.id}: ${dlp.name}`));
+   *
+   * // Get next page
+   * const nextPage = await vana.data.listDLPs({ limit: 10, offset: 10 });
+   * ```
+   */
+  async listDLPs(options = {}) {
+    const { limit = 100, offset = 0 } = options;
+    const subgraphUrl = options.subgraphUrl || this.context.subgraphUrl;
+    if (subgraphUrl) {
+      try {
+        const query = `
+          query ListDLPs($first: Int!, $skip: Int!) {
+            dlps(first: $first, skip: $skip, orderBy: id) {
+              id
+              name
+              metadata
+              status
+              address
+              owner
+            }
+          }
+        `;
+        const response = await fetch(subgraphUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            query,
+            variables: {
+              first: limit,
+              skip: offset
+            }
+          })
+        });
+        if (!response.ok) {
+          throw new Error(
+            `Subgraph request failed: ${response.status} ${response.statusText}`
+          );
+        }
+        const result = await response.json();
+        if (result.errors) {
+          throw new Error(
+            `Subgraph errors: ${result.errors.map((e) => e.message).join(", ")}`
+          );
+        }
+        const dlps = result.data?.dlps || [];
+        return dlps.map((dlp) => ({
+          id: parseInt(dlp.id),
+          name: dlp.name || "",
+          metadata: dlp.metadata,
+          status: dlp.status ? parseInt(dlp.status) : void 0,
+          address: dlp.address,
+          owner: dlp.owner
+        }));
+      } catch (error) {
+        console.debug("Subgraph query failed, falling back to chain:", error);
+      }
+    }
+    try {
+      const chainId = this.context.walletClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dlpRegistryAddress = getContractAddress(chainId, "DLPRegistry");
+      const dlpRegistryAbi = getAbi("DLPRegistry");
+      const dlpCount = await this.context.publicClient.readContract({
+        address: dlpRegistryAddress,
+        abi: dlpRegistryAbi,
+        functionName: "dlpsCount",
+        args: []
+      });
+      const totalCount = Number(dlpCount);
+      const start = offset;
+      const end = Math.min(start + limit, totalCount);
+      if (end <= start) {
+        return [];
+      }
+      const calls = [];
+      for (let i = start + 1; i <= end; i++) {
+        calls.push({
+          address: dlpRegistryAddress,
+          abi: dlpRegistryAbi,
+          functionName: "dlps",
+          args: [BigInt(i)]
+        });
+      }
+      const results = await gasAwareMulticall(this.context.publicClient, {
+        contracts: calls,
+        allowFailure: true,
+        batchSize: 50
+      });
+      const dlps = [];
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        if (result.status === "success" && result.result) {
+          const dlpData = result.result;
+          if (dlpData.name) {
+            dlps.push({
+              id: start + i + 1,
+              name: dlpData.name,
+              metadata: dlpData.metadata,
+              status: dlpData.status,
+              address: dlpData.dlpAddress,
+              owner: dlpData.ownerAddress
+            });
+          }
+        }
+      }
+      return dlps;
+    } catch (error) {
+      throw new Error(
+        `Failed to list DLPs: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
   /**
    * Retrieves a list of permissions granted by a user.
    *
@@ -43016,19 +43491,31 @@ var DataController = class {
     return await this.submitFilePermission(fileId, account, publicKey);
   }
   /**
-   * Submits a file permission transaction and returns the transaction hash immediately.
+   * Submits a file permission transaction to the blockchain.
    *
-   * This is the lower-level method that provides maximum control over transaction timing.
+   * @remarks
+   * This method supports gasless transactions via relayer callbacks when configured.
+   * It encrypts the user's encryption key with the recipient's public key before submission.
    * Use this when you want to handle transaction confirmation and event parsing separately.
    *
-   * @param fileId - The ID of the file to add permissions for
-   * @param account - The address of the account to grant permission to
-   * @param publicKey - The public key to encrypt the user's encryption key with
-   * @returns Promise resolving to the transaction hash
+   * @param fileId - The ID of the file to grant permission for
+   * @param account - The recipient's wallet address that will access the file
+   * @param publicKey - The recipient's public key for encryption.
+   *   Obtain via `vana.server.getIdentity(account).public_key`
+   * @returns Promise resolving to TransactionHandle for tracking the transaction
+   * @throws {Error} When chain ID is not available
+   * @throws {Error} When encryption key generation fails
+   * @throws {Error} When public key encryption fails
+   *
    * @example
    * ```typescript
-   * const txHash = await vana.data.submitFilePermission(fileId, account, publicKey);
-   * console.log(`Transaction submitted: ${txHash}`);
+   * const tx = await vana.data.submitFilePermission(
+   *   fileId,
+   *   "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
+   *   recipientPublicKey
+   * );
+   * const result = await tx.waitForEvents();
+   * console.log(`Permission granted with ID: ${result.permissionId}`);
    * ```
    */
   async submitFilePermission(fileId, account, publicKey) {
@@ -43312,10 +43799,10 @@ var DataController = class {
     );
   }
   /**
-   * Validates a data schema against the Vana meta-schema.
+   * Validates a data schema definition against the Vana meta-schema.
    *
-   * @param schema - The data schema to validate
-   * @returns Assertion that schema is valid (throws if invalid)
+   * @param schema - The data schema definition to validate
+   * @returns The validated DataSchema
    * @throws SchemaValidationError if invalid
    * @example
    * ```typescript
@@ -43332,11 +43819,11 @@ var DataController = class {
    *   }
    * };
    *
-   * vana.data.validateDataSchema(schema);
+   * const validatedSchema = vana.data.validateDataSchemaAgainstMetaSchema(schema);
    * ```
    */
-  validateDataSchema(schema) {
-    return validateDataSchema(schema);
+  validateDataSchemaAgainstMetaSchema(schema) {
+    return validateDataSchemaAgainstMetaSchema(schema);
   }
   /**
    * Validates data against a JSON Schema from a data schema.
@@ -43369,9 +43856,9 @@ var DataController = class {
     return validateDataAgainstSchema(data, schema);
   }
   /**
-   * Fetches and validates a schema from a URL, then returns the parsed data schema.
+   * Fetches and validates a data schema from a URL, then returns the parsed data schema.
    *
-   * @param url - The URL to fetch the schema from
+   * @param url - The URL to fetch the data schema from
    * @returns The validated data schema
    * @throws SchemaValidationError if invalid or fetch fails
    * @example
@@ -43396,6 +43883,73 @@ init_schemas();
 
 // src/controllers/server.ts
 init_errors();
+
+// src/utils/operationHandle.ts
+init_errors();
+var OperationHandle = class {
+  constructor(controller, id) {
+    this.controller = controller;
+    this.id = id;
+    __publicField(this, "_resultPromise");
+  }
+  /**
+   * Waits for the operation to complete and returns the result.
+   *
+   * @remarks
+   * Results are memoized - multiple calls return the same promise.
+   * The method polls the server at regular intervals until the operation
+   * succeeds, fails, or times out. Returns the raw string result from the
+   * server - callers are responsible for parsing if needed.
+   *
+   * @param options - Optional polling configuration
+   * @returns The operation result as a string when completed
+   * @throws {PersonalServerError} When the operation fails or times out
+   * @example
+   * ```typescript
+   * const result = await handle.waitForResult({
+   *   timeout: 60000,
+   *   pollingInterval: 500
+   * });
+   * // If expecting JSON, parse it:
+   * const data = JSON.parse(result);
+   * ```
+   */
+  async waitForResult(options) {
+    if (!this._resultPromise) {
+      this._resultPromise = this.pollForCompletion(options);
+    }
+    return this._resultPromise;
+  }
+  async pollForCompletion(options) {
+    const startTime = Date.now();
+    const timeout = options?.timeout ?? 3e4;
+    const interval = options?.pollingInterval ?? 500;
+    while (true) {
+      const result = await this.controller.getOperation(
+        this.id
+      );
+      if (result.status === "succeeded") {
+        if (result.result) {
+          return result.result;
+        }
+        throw new PersonalServerError(
+          "Operation succeeded but returned no result"
+        );
+      }
+      if (result.status === "failed") {
+        throw new PersonalServerError(
+          `Operation ${result.status}: ${result.result || "Unknown error"}`
+        );
+      }
+      if (Date.now() - startTime > timeout) {
+        throw new PersonalServerError(`Operation timed out after ${timeout}ms`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+  }
+};
+
+// src/controllers/server.ts
 var ServerController = class {
   constructor(context) {
     this.context = context;
@@ -43477,26 +44031,29 @@ var ServerController = class {
     }
   }
   /**
-   * Creates an operation via the personal server API.
+   * Creates a server operation and returns a handle for lifecycle management.
    *
    * @remarks
-   * This method submits a computation request to the personal server API.
-   * The response includes the operation ID.
-   * @param params - The request parameters object
+   * This method submits a computation request to the personal server and returns
+   * an OperationHandle that provides Promise-based methods for waiting on results.
+   * The handle pattern matches TransactionHandle for consistency across async operations.
+   *
+   * @param params - The operation request parameters
    * @param params.permissionId - The permission ID authorizing this operation.
-   *   Obtain from granted permissions via `vana.permissions.getUserPermissionGrantsOnChain()`.
-   * @returns A Promise that resolves to an operation response with status and control URLs
-   * @throws {PersonalServerError} When server request fails or parameters are invalid.
-   *   Verify permissionId exists and is active for the target server.
-   * @throws {NetworkError} When personal server API communication fails.
-   *   Check server URL configuration and network connectivity.
+   *   Obtain via `vana.permissions.getUserPermissionGrantsOnChain()`.
+   * @returns An OperationHandle providing access to the operation ID and result methods
+   * @throws {PersonalServerError} When the server request fails or parameters are invalid
+   * @throws {NetworkError} When personal server API communication fails
    * @example
    * ```typescript
-   * const response = await vana.server.createOperation({
-   *   permissionId: 123,
+   * const operation = await vana.server.createOperation({
+   *   permissionId: 123
    * });
-   *
-   * console.log(`Operation created: ${response.id}`);
+   * console.log(`Operation ID: ${operation.id}`);
+   * 
+   * // Wait for completion
+   * const result = await operation.waitForResult();
+   * console.log("Result:", result);
    * ```
    */
   async createOperation(params) {
@@ -43512,7 +44069,7 @@ var ServerController = class {
       };
       console.debug("\u{1F50D} Debug - createOperation requestBody", requestBody);
       const response = await this.makeRequest(requestBody);
-      return response;
+      return new OperationHandle(this, response.id);
     } catch (error) {
       if (error instanceof Error) {
         if (error instanceof NetworkError || error instanceof SerializationError || error instanceof SignatureError || error instanceof PersonalServerError) {
@@ -43529,30 +44086,20 @@ var ServerController = class {
     }
   }
   /**
-   * Polls the status of a computation request for updates and results.
+   * Retrieves the current status and result of a server operation.
    *
    * @remarks
-   * This method checks the current status of a computation request by querying
-   * the personal server API using the provided operation ID. It returns the current
-   * status, any available output, and error information. The method can be
-   * called periodically until the operation completes or fails.
-   *
-   * Common status values include: `starting`, `processing`, `succeeded`, `failed`, `canceled`.
-   * @param operationId - The operation ID returned from the initial request submission
-   * @returns A Promise that resolves to the current operation response with status and results
-   * @throws {NetworkError} When the polling request fails or returns invalid data
+   * Common status values: `starting`, `running`, `succeeded`, `failed`, `canceled`.
+   * When status is `succeeded`, the result field contains the operation output.
+   *
+   * @param operationId - The ID of the operation to query
+   * @returns The operation response containing status, result, and metadata
+   * @throws {NetworkError} When the API request fails or returns invalid data
    * @example
    * ```typescript
-   * // Poll until completion
-   * let result = await vana.server.getOperation(response.id);
-   *
-   * while (result.status === "processing") {
-   *   await new Promise(resolve => setTimeout(resolve, 1000));
-   *   result = await vana.server.getOperation(response.id);
-   * }
-   *
-   * if (result.status === "succeeded") {
-   *   console.log("Computation completed:", result.output);
+   * const status = await vana.server.getOperation(operationId);
+   * if (status.status === 'succeeded') {
+   *   console.log('Result:', JSON.parse(status.result));
    * }
    * ```
    */
@@ -46905,7 +47452,7 @@ export {
   storeGrantFile,
   summarizeGrant,
   validateDataAgainstSchema,
-  validateDataSchema,
+  validateDataSchemaAgainstMetaSchema,
   validateGrant,
   validateGrantExpiry,
   validateGrantFile,