@opendatalabs/vana-sdk 0.1.0-alpha.2e77fcc → 0.1.0-alpha.3041a59

package/dist/controllers/__tests__/data-consistency-integration.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @file Integration tests for data consistency features
+ *
+ * These tests verify the consistency options work correctly
+ * without loading the full DataController implementation
+ */
+export {};

package/dist/controllers/__tests__/operations.processQueue.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/controllers/data.cjs

@@ -32,11 +32,16 @@ __export(data_exports, {
 });
 module.exports = __toCommonJS(data_exports);
 var import_viem = require("viem");
+var import_pollingManager = require("../core/pollingManager");
 var import_base = require("./base");
 var import_addresses = require("../config/addresses");
 var import_abi = require("../generated/abi");
+var import_errors = require("../errors");
 var import_subgraph = require("../generated/subgraph");
 var import_graphql = require("graphql");
+var import_subgraphConsistency = require("../utils/subgraphConsistency");
+var import_subgraphPagination = require("../utils/subgraphPagination");
+var import_chainQuery = require("../utils/chainQuery");
 var import_encryption = require("../utils/encryption");
 var import_schemaValidation = require("../utils/schemaValidation");
 var import_multicall = require("../utils/multicall");
@@ -53,12 +58,18 @@ class DataController extends import_base.BaseController {
       permissions = [],
       encrypt = true,
       providerName,
-      owner
+      owner,
+      schemaValidation = "strict"
     } = params;
+    if (encrypt && owner && owner.toLowerCase() !== this.context.userAddress.toLowerCase()) {
+      throw new import_errors.InvalidConfigurationError(
+        "The 'owner' parameter cannot be different from the connected wallet's address when encryption is enabled. This would create an un-decryptable file."
+      );
+    }
     try {
       let isValid = true;
       let validationErrors = [];
-      if (schemaId !== void 0) {
+      if (schemaId !== void 0 && schemaValidation !== "skip") {
         try {
           const { SchemaController } = await import("./schemas");
           const schemaController = new SchemaController(this.context);
@@ -82,15 +93,20 @@ class DataController extends import_base.BaseController {
           }
           (0, import_schemaValidation.validateDataAgainstSchema)(parsedContent, schema);
         } catch (error) {
-          isValid = false;
-          if (error instanceof Error) {
-            if (typeof error === "object" && "errors" in error && Array.isArray(error.errors)) {
-              validationErrors = error.errors;
-            } else {
-              validationErrors = [error.message];
+          if (schemaValidation === "strict") {
+            throw error;
+          } else if (schemaValidation === "warn") {
+            console.warn(
+              '[Vana SDK] Schema validation failed, but continuing due to validation mode "warn"'
+            );
+            if (error instanceof Error) {
+              console.warn("  Validation error:", error.message);
+              if (typeof error === "object" && "errors" in error && Array.isArray(error.errors)) {
+                console.warn("  Detailed errors:", error.errors);
+              }
             }
-          } else {
-            validationErrors = ["Schema validation failed"];
+            isValid = false;
+            validationErrors = error instanceof Error ? [error.message] : ["Schema validation failed"];
           }
         }
       }
@@ -140,10 +156,17 @@ class DataController extends import_base.BaseController {
         if (response.type === "error") {
           throw new Error(response.error);
         }
-        if (response.type !== "direct" || !("fileId" in response.result)) {
+        if (response.type === "pending") {
+          result = await this.pollRelayerForConfirmation(
+            response.operationId,
+            void 0
+            // TODO: Add TransactionOptions to upload method signature
+          );
+        } else if (response.type === "direct" && typeof response.result === "object" && response.result !== null && "fileId" in response.result) {
+          result = response.result;
+        } else {
           throw new Error("Invalid response from relayer");
         }
-        result = response.result;
       } else {
         const txResult = await this.addFileWithEncryptedPermissionsAndSchema(
           uploadResult.url,
@@ -435,67 +458,91 @@ class DataController extends import_base.BaseController {
    * });
    * ```
    */
-  async getUserFiles(params) {
+  async getUserFiles(params, options) {
     const { owner, subgraphUrl } = params;
+    let dataSource = options?.source === "chain" ? "chain" : "subgraph";
+    if (options?.source === "auto" || !options?.source && options?.minBlock) {
+      const endpoint2 = subgraphUrl ?? this.context.subgraphUrl;
+      const currentBlock = await this.context.publicClient.getBlockNumber();
+      let subgraphBlock;
+      if (endpoint2) {
+        try {
+          const meta = await (0, import_subgraphConsistency.fetchSubgraphMeta)(endpoint2);
+          subgraphBlock = meta.blockNumber;
+        } catch {
+          subgraphBlock = void 0;
+        }
+      }
+      dataSource = (0, import_chainQuery.determineDataSource)(
+        options?.source,
+        options?.minBlock,
+        currentBlock,
+        subgraphBlock
+      );
+    }
+    if (dataSource === "chain") {
+      const publicClient = this.context.publicClient;
+      const chainId = await publicClient.getChainId();
+      const contractAddress = (0, import_addresses.getContractAddress)(chainId, "DataRegistry");
+      const files = await (0, import_chainQuery.getUserFilesFromChain)(
+        publicClient,
+        contractAddress,
+        owner,
+        options?.minBlock ? BigInt(options.minBlock) : void 0
+      );
+      const limit = options?.fetchAll ? files.length : options?.limit ?? 100;
+      const offset = options?.offset ?? 0;
+      return files.slice(offset, offset + limit);
+    }
     const endpoint = subgraphUrl ?? this.context.subgraphUrl;
     if (!endpoint) {
       throw new Error(
         "subgraphUrl is required. Please provide a valid subgraph endpoint or configure it in Vana constructor."
       );
     }
+    if (options?.minBlock || options?.waitForSync) {
+      await (0, import_subgraphConsistency.checkSubgraphConsistency)(endpoint, options);
+    }
     try {
-      const response = await fetch(endpoint, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
+      const orderByMap = {
+        id: "id",
+        addedAtBlock: "addedAtBlock",
+        addedAtTimestamp: "addedAtTimestamp",
+        url: "url",
+        schemaId: "schemaId"
+      };
+      const allFiles = await (0, import_subgraphPagination.executePaginatedQuery)({
+        endpoint,
+        document: import_subgraph.GetUserFilesPaginatedDocument,
+        baseVariables: {
+          userId: owner.toLowerCase(),
+          // Subgraph requires lowercase addresses
+          orderBy: (0, import_subgraphPagination.mapOrderByToEnum)(
+            options?.orderBy,
+            orderByMap,
+            "addedAtBlock"
+          ),
+          orderDirection: (0, import_subgraphPagination.mapOrderDirection)(
+            options?.orderDirection,
+            "asc",
+            "desc"
+          )
         },
-        body: JSON.stringify({
-          query: (0, import_graphql.print)(import_subgraph.GetUserFilesDocument),
-          variables: {
-            userId: owner.toLowerCase()
-            // Subgraph requires lowercase addresses
-          }
-        })
-      });
-      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 user = result.data?.user;
-      if (!user?.files?.length) {
-        console.warn("No files found for user:", owner);
-        return [];
-      }
-      const fileMap = /* @__PURE__ */ new Map();
-      user.files.forEach((file) => {
-        const fileId = parseInt(file.id);
-        const userFile = {
-          id: fileId,
+        options,
+        extractItems: (data) => data?.user?.files,
+        transformItem: (file) => ({
+          id: parseInt(file.id),
           url: file.url,
           ownerAddress: file.owner.id,
           addedAtBlock: BigInt(file.addedAtBlock),
           schemaId: parseInt(file.schemaId),
           addedAtTimestamp: BigInt(file.addedAtTimestamp),
           transactionHash: file.transactionHash
-        };
-        const existing = fileMap.get(fileId);
-        if (!existing || userFile.addedAtTimestamp && existing.addedAtTimestamp && userFile.addedAtTimestamp > existing.addedAtTimestamp) {
-          fileMap.set(fileId, userFile);
-        }
+        })
       });
-      const userFiles = Array.from(fileMap.values()).sort(
-        (a, b) => Number((b.addedAtTimestamp ?? 0n) - (a.addedAtTimestamp ?? 0n))
-      );
-      if (userFiles.length > 0) {
+      if (allFiles.length > 0) {
         try {
-          const fileIds = userFiles.map((f) => f.id);
+          const fileIds = allFiles.map((f) => f.id);
           let proofMap;
           try {
             proofMap = await this._fetchProofsFromSubgraph(fileIds, endpoint);
@@ -506,7 +553,7 @@ class DataController extends import_base.BaseController {
             );
             proofMap = await this._fetchProofsFromChain(fileIds);
           }
-          for (const file of userFiles) {
+          for (const file of allFiles) {
             const dlpIds = proofMap.get(file.id);
             if (dlpIds && dlpIds.length > 0) {
               file.dlpIds = dlpIds;
@@ -516,7 +563,7 @@ class DataController extends import_base.BaseController {
           console.warn("Failed to fetch proof data for files:", error);
         }
       }
-      return userFiles;
+      return allFiles;
     } catch (error) {
       console.error("Failed to fetch user files from subgraph:", error);
       throw new Error(
@@ -642,6 +689,9 @@ class DataController extends import_base.BaseController {
    */
   async getDLP(dlpId, options = {}) {
     const subgraphUrl = options.subgraphUrl ?? this.context.subgraphUrl;
+    if (subgraphUrl && (options.minBlock || options.waitForSync)) {
+      await (0, import_subgraphConsistency.checkSubgraphConsistency)(subgraphUrl, options);
+    }
     if (subgraphUrl) {
       try {
         const response = await fetch(subgraphUrl, {
@@ -860,21 +910,33 @@ class DataController extends import_base.BaseController {
    * @returns Promise resolving to an array of permission objects
    * @throws Error if both subgraph and RPC queries fail
    */
-  async getUserPermissions(params) {
+  async getUserPermissions(params, options) {
     const { user, subgraphUrl } = params;
     const endpoint = subgraphUrl ?? this.context.subgraphUrl;
+    if (endpoint && (options?.minBlock || options?.waitForSync)) {
+      await (0, import_subgraphConsistency.checkSubgraphConsistency)(endpoint, options);
+    }
     if (endpoint) {
       try {
-        const permissions = await this._getUserPermissionsViaSubgraph({
-          user,
-          subgraphUrl: endpoint
-        });
+        const permissions = await this._getUserPermissionsViaSubgraph(
+          {
+            user,
+            subgraphUrl: endpoint
+          },
+          options
+        );
         return permissions;
       } catch (error) {
         console.warn("Subgraph query failed, falling back to RPC:", error);
       }
     }
-    return await this._getUserPermissionsViaRpc({ user });
+    const allPermissions = await this._getUserPermissionsViaRpc({ user });
+    if (options && !options.fetchAll) {
+      const limit = options.limit ?? 100;
+      const offset = options.offset ?? 0;
+      return allPermissions.slice(offset, offset + limit);
+    }
+    return allPermissions;
   }
   /**
    * Internal method: Query user permissions via subgraph
@@ -884,46 +946,48 @@ class DataController extends import_base.BaseController {
    * @param params.subgraphUrl - The subgraph URL endpoint to query
    * @returns Promise resolving to an array of permission objects
    */
-  async _getUserPermissionsViaSubgraph(params) {
+  async _getUserPermissionsViaSubgraph(params, options) {
     const { user, subgraphUrl } = params;
     try {
-      const response = await fetch(subgraphUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
+      const orderByMap = {
+        id: "id",
+        addedAtBlock: "addedAtBlock",
+        addedAtTimestamp: "addedAtTimestamp",
+        grant: "grant",
+        nonce: "nonce",
+        startBlock: "startBlock",
+        endBlock: "endBlock"
+      };
+      const permissions = await (0, import_subgraphPagination.executePaginatedQuery)({
+        endpoint: subgraphUrl,
+        document: import_subgraph.GetUserPermissionsPaginatedDocument,
+        baseVariables: {
+          userId: user.toLowerCase(),
+          orderBy: (0, import_subgraphPagination.mapOrderByToEnum)(
+            options?.orderBy,
+            orderByMap,
+            "addedAtTimestamp"
+          ),
+          orderDirection: (0, import_subgraphPagination.mapOrderDirection)(
+            options?.orderDirection,
+            "desc",
+            "asc"
+          )
         },
-        body: JSON.stringify({
-          query: (0, import_graphql.print)(import_subgraph.GetUserPermissionsDocument),
-          variables: {
-            userId: user.toLowerCase()
-          }
+        options,
+        extractItems: (data) => data?.user?.permissions,
+        transformItem: (permission) => ({
+          id: permission.id,
+          grant: permission.grant,
+          nonce: BigInt(permission.nonce),
+          signature: permission.signature,
+          addedAtBlock: BigInt(permission.addedAtBlock),
+          addedAtTimestamp: BigInt(permission.addedAtTimestamp),
+          transactionHash: permission.transactionHash,
+          user
         })
       });
-      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 query errors: ${result.errors.map((e) => e.message).join(", ")}`
-        );
-      }
-      const userData = result.data?.user;
-      if (!userData?.permissions?.length) {
-        return [];
-      }
-      return userData.permissions.map((permission) => ({
-        id: permission.id,
-        grant: permission.grant,
-        nonce: BigInt(permission.nonce),
-        signature: permission.signature,
-        addedAtBlock: BigInt(permission.addedAtBlock),
-        addedAtTimestamp: BigInt(permission.addedAtTimestamp),
-        transactionHash: permission.transactionHash,
-        user
-      })).sort((a, b) => Number(b.addedAtTimestamp - a.addedAtTimestamp));
+      return permissions;
     } catch (error) {
       console.error("Failed to query user permissions from subgraph:", error);
       throw error;
@@ -1056,20 +1120,28 @@ class DataController extends import_base.BaseController {
    * });
    * ```
    */
-  async getUserTrustedServers(params) {
-    const { user, limit = 50, offset = 0 } = params;
+  async getUserTrustedServers(params, options) {
+    const { user } = params;
     const subgraphUrl = params.subgraphUrl ?? this.context.subgraphUrl;
+    if (subgraphUrl && (options?.minBlock || options?.waitForSync)) {
+      await (0, import_subgraphConsistency.checkSubgraphConsistency)(subgraphUrl, options);
+    }
     if (subgraphUrl) {
       try {
-        const servers = await this._getUserTrustedServersViaSubgraph({
-          user,
-          subgraphUrl
-        });
-        return limit ? servers.slice(offset, offset + limit) : servers;
+        const servers = await this._getUserTrustedServersViaSubgraph(
+          {
+            user,
+            subgraphUrl
+          },
+          options
+        );
+        return servers;
       } catch (error) {
         console.warn("Subgraph query failed, falling back to RPC:", error);
       }
     }
+    const limit = options?.fetchAll ? Number.MAX_SAFE_INTEGER : options?.limit ?? 100;
+    const offset = options?.offset ?? 0;
     const rpcResult = await this._getUserTrustedServersViaRpc({
       user,
       limit,
@@ -1085,7 +1157,7 @@ class DataController extends import_base.BaseController {
    * @param params.subgraphUrl - The subgraph URL endpoint to query
    * @returns Promise resolving to an array of trusted server objects
    */
-  async _getUserTrustedServersViaSubgraph(params) {
+  async _getUserTrustedServersViaSubgraph(params, options) {
     const { user, subgraphUrl } = params;
     const graphqlEndpoint = subgraphUrl;
     if (!graphqlEndpoint) {
@@ -1094,42 +1166,46 @@ class DataController extends import_base.BaseController {
       );
     }
     try {
-      const response = await fetch(graphqlEndpoint, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
+      const orderByMap = {
+        id: "id",
+        trustedAt: "trustedAt",
+        trustedAtBlock: "trustedAtBlock",
+        server: "server",
+        user: "user"
+      };
+      const serverTrusts = await (0, import_subgraphPagination.executePaginatedQuery)({
+        endpoint: graphqlEndpoint,
+        document: import_subgraph.GetUserTrustedServersPaginatedDocument,
+        baseVariables: {
+          userId: user.toLowerCase(),
+          // Subgraph requires lowercase addresses
+          orderBy: (0, import_subgraphPagination.mapOrderByToEnum)(
+            options?.orderBy,
+            orderByMap,
+            "trustedAtBlock"
+          ),
+          orderDirection: (0, import_subgraphPagination.mapOrderDirection)(
+            options?.orderDirection,
+            "desc",
+            "asc"
+          )
         },
-        body: JSON.stringify({
-          query: (0, import_graphql.print)(import_subgraph.GetUserTrustedServersDocument),
-          variables: {
-            userId: user.toLowerCase()
-            // Subgraph requires lowercase addresses
-          }
+        options,
+        extractItems: (data) => {
+          const trusts = data?.user?.serverTrusts ?? [];
+          return trusts.filter((trust) => !trust.untrustedAtBlock);
+        },
+        transformItem: (trust) => ({
+          id: trust.server.id,
+          serverAddress: trust.server.serverAddress,
+          serverUrl: trust.server.url,
+          trustedAt: BigInt(trust.trustedAt),
+          user,
+          name: ""
+          // Not available in new schema, will be empty
         })
       });
-      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 query errors: ${result.errors.map((e) => e.message).join(", ")}`
-        );
-      }
-      if (!result.data?.user) {
-        return [];
-      }
-      return (result.data.user.serverTrusts ?? []).filter((trust) => !trust.untrustedAtBlock).map((trust) => ({
-        id: trust.server.id,
-        serverAddress: trust.server.serverAddress,
-        serverUrl: trust.server.url,
-        trustedAt: BigInt(trust.trustedAt),
-        user,
-        name: ""
-        // Not available in new schema, will be empty
-      }));
+      return serverTrusts;
     } catch (error) {
       console.error("Failed to query trusted servers from subgraph:", error);
       throw error;
@@ -1969,10 +2045,18 @@ class DataController extends import_base.BaseController {
         if (response.type === "error") {
           throw new Error(response.error);
         }
-        if (response.type !== "direct" || !("fileId" in response.result)) {
+        let result;
+        if (response.type === "pending") {
+          result = await this.pollRelayerForConfirmation(
+            response.operationId,
+            void 0
+            // TODO: Add TransactionOptions to upload method signature
+          );
+        } else if (response.type === "direct" && typeof response.result === "object" && response.result !== null && "fileId" in response.result) {
+          result = response.result;
+        } else {
           throw new Error("Invalid response from relayer");
         }
-        const result = response.result;
         return {
           fileId: result.fileId,
           url: uploadResult.url,
@@ -2061,7 +2145,15 @@ class DataController extends import_base.BaseController {
           );
         }
       }
-      const finalFilename = filename ?? `upload-${Date.now()}.dat`;
+      const finalFilename = (() => {
+        if (filename) {
+          if (encrypt && !filename.endsWith(".enc")) {
+            return `${filename}.enc`;
+          }
+          return filename;
+        }
+        return encrypt ? `upload-${Date.now()}.enc` : `upload-${Date.now()}.dat`;
+      })();
       const uploadResult = await this.context.storageManager.upload(
         finalBlob,
         finalFilename,
@@ -2513,6 +2605,26 @@ class DataController extends import_base.BaseController {
   async fetchAndValidateSchema(url) {
     return (0, import_schemaValidation.fetchAndValidateSchema)(url);
   }
+  /**
+   * Polls for confirmation of a relayer operation.
+   * @internal
+   */
+  async pollRelayerForConfirmation(operationId, options) {
+    if (!this.context.relayer) {
+      throw new Error("Relayer not configured for polling");
+    }
+    const pollingManager = new import_pollingManager.PollingManager(this.context.relayer);
+    const result = await pollingManager.startPolling(operationId, {
+      signal: options?.signal,
+      onStatusUpdate: options?.onStatusUpdate,
+      ...options?.pollingOptions
+    });
+    return {
+      fileId: 0,
+      // This would need to be extracted from transaction events
+      transactionHash: result.hash
+    };
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {