@opendatalabs/vana-sdk 0.1.0-alpha.b878f1d → 0.1.0-alpha.bae46ec

package/dist/controllers/data.cjs

@@ -37,9 +37,6 @@ var import_addresses = require("../config/addresses");
 var import_abi = require("../generated/abi");
 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");
@@ -143,7 +140,7 @@ class DataController extends import_base.BaseController {
         if (response.type === "error") {
           throw new Error(response.error);
         }
-        if (response.type !== "direct" || typeof response.result !== "object" || response.result === null || !("fileId" in response.result)) {
+        if (response.type !== "direct" || !("fileId" in response.result)) {
           throw new Error("Invalid response from relayer");
         }
         result = response.result;
@@ -438,91 +435,67 @@ class DataController extends import_base.BaseController {
    * });
    * ```
    */
-  async getUserFiles(params, options) {
+  async getUserFiles(params) {
     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 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"
-          )
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
         },
-        options,
-        extractItems: (data) => data?.user?.files,
-        transformItem: (file) => ({
-          id: parseInt(file.id),
+        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,
           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);
+        }
       });
-      if (allFiles.length > 0) {
+      const userFiles = Array.from(fileMap.values()).sort(
+        (a, b) => Number((b.addedAtTimestamp ?? 0n) - (a.addedAtTimestamp ?? 0n))
+      );
+      if (userFiles.length > 0) {
         try {
-          const fileIds = allFiles.map((f) => f.id);
+          const fileIds = userFiles.map((f) => f.id);
           let proofMap;
           try {
             proofMap = await this._fetchProofsFromSubgraph(fileIds, endpoint);
@@ -533,7 +506,7 @@ class DataController extends import_base.BaseController {
             );
             proofMap = await this._fetchProofsFromChain(fileIds);
           }
-          for (const file of allFiles) {
+          for (const file of userFiles) {
             const dlpIds = proofMap.get(file.id);
             if (dlpIds && dlpIds.length > 0) {
               file.dlpIds = dlpIds;
@@ -543,7 +516,7 @@ class DataController extends import_base.BaseController {
           console.warn("Failed to fetch proof data for files:", error);
         }
       }
-      return allFiles;
+      return userFiles;
     } catch (error) {
       console.error("Failed to fetch user files from subgraph:", error);
       throw new Error(
@@ -669,9 +642,6 @@ 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, {
@@ -890,33 +860,21 @@ 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, options) {
+  async getUserPermissions(params) {
     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
-          },
-          options
-        );
+        const permissions = await this._getUserPermissionsViaSubgraph({
+          user,
+          subgraphUrl: endpoint
+        });
         return permissions;
       } catch (error) {
         console.warn("Subgraph query failed, falling back to RPC:", error);
       }
     }
-    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;
+    return await this._getUserPermissionsViaRpc({ user });
   }
   /**
    * Internal method: Query user permissions via subgraph
@@ -926,48 +884,46 @@ 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, options) {
+  async _getUserPermissionsViaSubgraph(params) {
     const { user, subgraphUrl } = params;
     try {
-      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"
-          )
+      const response = await fetch(subgraphUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
         },
-        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
+        body: JSON.stringify({
+          query: (0, import_graphql.print)(import_subgraph.GetUserPermissionsDocument),
+          variables: {
+            userId: user.toLowerCase()
+          }
         })
       });
-      return permissions;
+      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));
     } catch (error) {
       console.error("Failed to query user permissions from subgraph:", error);
       throw error;
@@ -1100,28 +1056,20 @@ class DataController extends import_base.BaseController {
    * });
    * ```
    */
-  async getUserTrustedServers(params, options) {
-    const { user } = params;
+  async getUserTrustedServers(params) {
+    const { user, limit = 50, offset = 0 } = 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
-          },
-          options
-        );
-        return servers;
+        const servers = await this._getUserTrustedServersViaSubgraph({
+          user,
+          subgraphUrl
+        });
+        return limit ? servers.slice(offset, offset + limit) : 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,
@@ -1137,7 +1085,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, options) {
+  async _getUserTrustedServersViaSubgraph(params) {
     const { user, subgraphUrl } = params;
     const graphqlEndpoint = subgraphUrl;
     if (!graphqlEndpoint) {
@@ -1146,46 +1094,42 @@ class DataController extends import_base.BaseController {
       );
     }
     try {
-      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"
-          )
+      const response = await fetch(graphqlEndpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
         },
-        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
+        body: JSON.stringify({
+          query: (0, import_graphql.print)(import_subgraph.GetUserTrustedServersDocument),
+          variables: {
+            userId: user.toLowerCase()
+            // Subgraph requires lowercase addresses
+          }
         })
       });
-      return serverTrusts;
+      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
+      }));
     } catch (error) {
       console.error("Failed to query trusted servers from subgraph:", error);
       throw error;
@@ -1429,7 +1373,7 @@ class DataController extends import_base.BaseController {
    * console.log(`File ${fileId} registered with schema in tx ${transactionHash}`);
    * ```
    */
-  async registerFileWithSchema(url, schemaId, options) {
+  async registerFileWithSchema(url, schemaId) {
     this.assertWallet();
     try {
       const chainId = this.context.publicClient.chain?.id;
@@ -1447,8 +1391,7 @@ class DataController extends import_base.BaseController {
         functionName: "addFileWithSchema",
         args: [url, BigInt(schemaId)],
         account,
-        chain: this.context.walletClient.chain ?? null,
-        ...this.spreadTransactionOptions(options)
+        chain: this.context.walletClient.chain ?? null
       });
       const { tx } = await import("../utils/transactionHelpers");
       return tx({
@@ -1505,7 +1448,15 @@ class DataController extends import_base.BaseController {
         args: [url, ownerAddress, permissions],
         account,
         chain: this.context.walletClient.chain ?? null,
-        ...this.spreadTransactionOptions(options)
+        ...options && {
+          gas: options.gasLimit,
+          nonce: options.nonce,
+          // Use EIP-1559 gas pricing if available, otherwise legacy
+          ...options.maxFeePerGas || options.maxPriorityFeePerGas ? {
+            maxFeePerGas: options.maxFeePerGas,
+            maxPriorityFeePerGas: options.maxPriorityFeePerGas
+          } : options.gasPrice ? { gasPrice: options.gasPrice } : {}
+        }
       });
       const { tx } = await import("../utils/transactionHelpers");
       return tx({
@@ -1560,7 +1511,7 @@ class DataController extends import_base.BaseController {
    * console.log(`File ${result.fileId} registered in tx ${result.hash}`);
    * ```
    */
-  async addFileWithPermissionsAndSchema(url, ownerAddress, permissions = [], schemaId = 0, options) {
+  async addFileWithPermissionsAndSchema(url, ownerAddress, permissions = [], schemaId = 0) {
     this.assertWallet();
     try {
       let encryptedPermissions = [];
@@ -1594,8 +1545,7 @@ class DataController extends import_base.BaseController {
         url,
         ownerAddress,
         encryptedPermissions,
-        schemaId,
-        options
+        schemaId
       );
     } catch (error) {
       console.error("Failed to add file with permissions and schema:", error);
@@ -1660,7 +1610,15 @@ class DataController extends import_base.BaseController {
         args: [url, ownerAddress, permissions, BigInt(schemaId)],
         account,
         chain: this.context.walletClient.chain ?? null,
-        ...this.spreadTransactionOptions(options)
+        ...options && {
+          gas: options.gasLimit,
+          nonce: options.nonce,
+          // Use EIP-1559 gas pricing if available, otherwise legacy
+          ...options.maxFeePerGas || options.maxPriorityFeePerGas ? {
+            maxFeePerGas: options.maxFeePerGas,
+            maxPriorityFeePerGas: options.maxPriorityFeePerGas
+          } : options.gasPrice ? { gasPrice: options.gasPrice } : {}
+        }
       });
       const { tx } = await import("../utils/transactionHelpers");
       return tx({
@@ -1708,7 +1666,7 @@ class DataController extends import_base.BaseController {
    * console.log(`Refiner ${result.refinerId} created`);
    * ```
    */
-  async addRefiner(params, options) {
+  async addRefiner(params) {
     this.assertWallet();
     try {
       const chainId = this.context.publicClient.chain?.id;
@@ -1734,8 +1692,7 @@ class DataController extends import_base.BaseController {
           params.refinementInstructionUrl
         ],
         account,
-        chain: this.context.walletClient.chain ?? null,
-        ...this.spreadTransactionOptions(options)
+        chain: this.context.walletClient.chain ?? null
       });
       const { tx } = await import("../utils/transactionHelpers");
       const txResult = tx({
@@ -1935,7 +1892,7 @@ class DataController extends import_base.BaseController {
    * console.log(`Schema updated in tx ${result.transactionHash}`);
    * ```
    */
-  async updateSchemaId(params, options) {
+  async updateSchemaId(params) {
     this.assertWallet();
     try {
       const chainId = this.context.publicClient.chain?.id;
@@ -1955,8 +1912,7 @@ class DataController extends import_base.BaseController {
         functionName: "updateSchemaId",
         args: [BigInt(params.refinerId), BigInt(params.newSchemaId)],
         account,
-        chain: this.context.walletClient.chain ?? null,
-        ...this.spreadTransactionOptions(options)
+        chain: this.context.walletClient.chain ?? null
       });
       await this.context.publicClient.waitForTransactionReceipt({ hash });
       return {
@@ -2025,7 +1981,7 @@ class DataController extends import_base.BaseController {
         if (response.type === "error") {
           throw new Error(response.error);
         }
-        if (response.type !== "direct" || typeof response.result !== "object" || response.result === null || !("fileId" in response.result)) {
+        if (response.type !== "direct" || !("fileId" in response.result)) {
           throw new Error("Invalid response from relayer");
         }
         const result = response.result;
@@ -2117,7 +2073,7 @@ class DataController extends import_base.BaseController {
           );
         }
       }
-      const finalFilename = filename ?? (encrypt ? `upload-${Date.now()}.enc` : `upload-${Date.now()}.dat`);
+      const finalFilename = filename ?? `upload-${Date.now()}.dat`;
       const uploadResult = await this.context.storageManager.upload(
         finalBlob,
         finalFilename,
@@ -2162,10 +2118,10 @@ class DataController extends import_base.BaseController {
    * console.log(`Transaction: ${result.transactionHash}`);
    * ```
    */
-  async addPermissionToFile(params, options) {
+  async addPermissionToFile(params) {
     this.assertWallet();
     const { fileId, account, publicKey } = params;
-    return await this.submitFilePermission(fileId, account, publicKey, options);
+    return await this.submitFilePermission(fileId, account, publicKey);
   }
   /**
    * Submits a file permission transaction to the blockchain.
@@ -2195,7 +2151,7 @@ class DataController extends import_base.BaseController {
    * console.log(`Permission granted with ID: ${result.permissionId}`);
    * ```
    */
-  async submitFilePermission(fileId, account, publicKey, options) {
+  async submitFilePermission(fileId, account, publicKey) {
     this.assertWallet();
     try {
       const userEncryptionKey = await (0, import_encryption.generateEncryptionKey)(
@@ -2222,8 +2178,7 @@ class DataController extends import_base.BaseController {
         functionName: "addFilePermission",
         args: [BigInt(fileId), account, encryptedKey],
         account: walletAccount,
-        chain: this.context.walletClient.chain ?? null,
-        ...this.spreadTransactionOptions(options)
+        chain: this.context.walletClient.chain ?? null
       });
       const { tx } = await import("../utils/transactionHelpers");
       return tx({