@opendatalabs/vana-sdk 0.1.0-alpha.2fd4542 → 0.1.0-alpha.321a1fe

package/dist/index.browser.js

@@ -3038,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",
@@ -3132,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: [
           {
@@ -36216,69 +36264,451 @@ var init_ipfs = __esm({
   }
 });
 
-// src/utils/blockchain/registry.ts
-import { getContract } from "viem";
-async function fetchSchemaFromChain(context, schemaId) {
-  const chainId = context.walletClient.chain?.id;
-  if (!chainId) {
-    throw new Error("Chain ID not available");
-  }
-  const dataRefinerRegistryAddress = getContractAddress(
-    chainId,
-    "DataRefinerRegistry"
-  );
-  const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
-  const dataRefinerRegistry = getContract({
-    address: dataRefinerRegistryAddress,
-    abi: dataRefinerRegistryAbi,
-    client: context.publicClient
-  });
-  const schemaData = await dataRefinerRegistry.read.schemas([BigInt(schemaId)]);
-  if (!schemaData) {
-    throw new Error(`Schema with ID ${schemaId} not found`);
-  }
-  const schemaObj = schemaData;
-  if (!schemaObj.name || !schemaObj.dialect || !schemaObj.definitionUrl) {
-    throw new Error("Incomplete schema data");
-  }
-  return {
-    id: schemaId,
-    name: schemaObj.name,
-    dialect: schemaObj.dialect,
-    definitionUrl: schemaObj.definitionUrl
-  };
-}
-async function fetchSchemaCountFromChain(context) {
-  const chainId = context.walletClient.chain?.id;
-  if (!chainId) {
-    throw new Error("Chain ID not available");
-  }
-  const dataRefinerRegistryAddress = getContractAddress(
-    chainId,
-    "DataRefinerRegistry"
-  );
-  const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
-  const dataRefinerRegistry = getContract({
-    address: dataRefinerRegistryAddress,
-    abi: dataRefinerRegistryAbi,
-    client: context.publicClient
-  });
-  const count = await dataRefinerRegistry.read.schemasCount();
-  return Number(count);
-}
-var init_registry = __esm({
-  "src/utils/blockchain/registry.ts"() {
-    "use strict";
-    init_addresses();
-    init_abi();
-  }
-});
-
 // src/generated/subgraph.ts
-var GetSchemaDocument, ListSchemasDocument, CountSchemasDocument;
+var GetUserPermissionsDocument, GetUserTrustedServersDocument, GetUserFilesDocument, GetFileProofsDocument, GetDlpDocument, GetSchemaDocument, ListSchemasDocument, CountSchemasDocument;
 var init_subgraph = __esm({
   "src/generated/subgraph.ts"() {
     "use strict";
+    GetUserPermissionsDocument = {
+      kind: "Document",
+      definitions: [
+        {
+          kind: "OperationDefinition",
+          operation: "query",
+          name: { kind: "Name", value: "GetUserPermissions" },
+          variableDefinitions: [
+            {
+              kind: "VariableDefinition",
+              variable: {
+                kind: "Variable",
+                name: { kind: "Name", value: "userId" }
+              },
+              type: {
+                kind: "NonNullType",
+                type: { kind: "NamedType", name: { kind: "Name", value: "ID" } }
+              }
+            }
+          ],
+          selectionSet: {
+            kind: "SelectionSet",
+            selections: [
+              {
+                kind: "Field",
+                name: { kind: "Name", value: "user" },
+                arguments: [
+                  {
+                    kind: "Argument",
+                    name: { kind: "Name", value: "id" },
+                    value: {
+                      kind: "Variable",
+                      name: { kind: "Name", value: "userId" }
+                    }
+                  }
+                ],
+                selectionSet: {
+                  kind: "SelectionSet",
+                  selections: [
+                    { kind: "Field", name: { kind: "Name", value: "id" } },
+                    {
+                      kind: "Field",
+                      name: { kind: "Name", value: "permissions" },
+                      selectionSet: {
+                        kind: "SelectionSet",
+                        selections: [
+                          { kind: "Field", name: { kind: "Name", value: "id" } },
+                          { kind: "Field", name: { kind: "Name", value: "grant" } },
+                          { kind: "Field", name: { kind: "Name", value: "nonce" } },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "signature" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "startBlock" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "endBlock" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "addedAtBlock" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "addedAtTimestamp" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "transactionHash" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "grantee" },
+                            selectionSet: {
+                              kind: "SelectionSet",
+                              selections: [
+                                {
+                                  kind: "Field",
+                                  name: { kind: "Name", value: "id" }
+                                },
+                                {
+                                  kind: "Field",
+                                  name: { kind: "Name", value: "address" }
+                                }
+                              ]
+                            }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "filePermissions" },
+                            selectionSet: {
+                              kind: "SelectionSet",
+                              selections: [
+                                {
+                                  kind: "Field",
+                                  name: { kind: "Name", value: "file" },
+                                  selectionSet: {
+                                    kind: "SelectionSet",
+                                    selections: [
+                                      {
+                                        kind: "Field",
+                                        name: { kind: "Name", value: "id" }
+                                      },
+                                      {
+                                        kind: "Field",
+                                        name: { kind: "Name", value: "url" }
+                                      }
+                                    ]
+                                  }
+                                }
+                              ]
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  ]
+                }
+              }
+            ]
+          }
+        }
+      ]
+    };
+    GetUserTrustedServersDocument = {
+      kind: "Document",
+      definitions: [
+        {
+          kind: "OperationDefinition",
+          operation: "query",
+          name: { kind: "Name", value: "GetUserTrustedServers" },
+          variableDefinitions: [
+            {
+              kind: "VariableDefinition",
+              variable: {
+                kind: "Variable",
+                name: { kind: "Name", value: "userId" }
+              },
+              type: {
+                kind: "NonNullType",
+                type: { kind: "NamedType", name: { kind: "Name", value: "ID" } }
+              }
+            }
+          ],
+          selectionSet: {
+            kind: "SelectionSet",
+            selections: [
+              {
+                kind: "Field",
+                name: { kind: "Name", value: "user" },
+                arguments: [
+                  {
+                    kind: "Argument",
+                    name: { kind: "Name", value: "id" },
+                    value: {
+                      kind: "Variable",
+                      name: { kind: "Name", value: "userId" }
+                    }
+                  }
+                ],
+                selectionSet: {
+                  kind: "SelectionSet",
+                  selections: [
+                    { kind: "Field", name: { kind: "Name", value: "id" } },
+                    {
+                      kind: "Field",
+                      name: { kind: "Name", value: "serverTrusts" },
+                      selectionSet: {
+                        kind: "SelectionSet",
+                        selections: [
+                          { kind: "Field", name: { kind: "Name", value: "id" } },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "server" },
+                            selectionSet: {
+                              kind: "SelectionSet",
+                              selections: [
+                                {
+                                  kind: "Field",
+                                  name: { kind: "Name", value: "id" }
+                                },
+                                {
+                                  kind: "Field",
+                                  name: { kind: "Name", value: "serverAddress" }
+                                },
+                                {
+                                  kind: "Field",
+                                  name: { kind: "Name", value: "url" }
+                                },
+                                {
+                                  kind: "Field",
+                                  name: { kind: "Name", value: "publicKey" }
+                                }
+                              ]
+                            }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "trustedAt" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "trustedAtBlock" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "untrustedAtBlock" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "transactionHash" }
+                          }
+                        ]
+                      }
+                    }
+                  ]
+                }
+              }
+            ]
+          }
+        }
+      ]
+    };
+    GetUserFilesDocument = {
+      kind: "Document",
+      definitions: [
+        {
+          kind: "OperationDefinition",
+          operation: "query",
+          name: { kind: "Name", value: "GetUserFiles" },
+          variableDefinitions: [
+            {
+              kind: "VariableDefinition",
+              variable: {
+                kind: "Variable",
+                name: { kind: "Name", value: "userId" }
+              },
+              type: {
+                kind: "NonNullType",
+                type: { kind: "NamedType", name: { kind: "Name", value: "ID" } }
+              }
+            }
+          ],
+          selectionSet: {
+            kind: "SelectionSet",
+            selections: [
+              {
+                kind: "Field",
+                name: { kind: "Name", value: "user" },
+                arguments: [
+                  {
+                    kind: "Argument",
+                    name: { kind: "Name", value: "id" },
+                    value: {
+                      kind: "Variable",
+                      name: { kind: "Name", value: "userId" }
+                    }
+                  }
+                ],
+                selectionSet: {
+                  kind: "SelectionSet",
+                  selections: [
+                    { kind: "Field", name: { kind: "Name", value: "id" } },
+                    {
+                      kind: "Field",
+                      name: { kind: "Name", value: "files" },
+                      selectionSet: {
+                        kind: "SelectionSet",
+                        selections: [
+                          { kind: "Field", name: { kind: "Name", value: "id" } },
+                          { kind: "Field", name: { kind: "Name", value: "url" } },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "schemaId" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "addedAtBlock" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "addedAtTimestamp" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "transactionHash" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "owner" },
+                            selectionSet: {
+                              kind: "SelectionSet",
+                              selections: [
+                                {
+                                  kind: "Field",
+                                  name: { kind: "Name", value: "id" }
+                                }
+                              ]
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  ]
+                }
+              }
+            ]
+          }
+        }
+      ]
+    };
+    GetFileProofsDocument = {
+      kind: "Document",
+      definitions: [
+        {
+          kind: "OperationDefinition",
+          operation: "query",
+          name: { kind: "Name", value: "GetFileProofs" },
+          variableDefinitions: [
+            {
+              kind: "VariableDefinition",
+              variable: {
+                kind: "Variable",
+                name: { kind: "Name", value: "fileIds" }
+              },
+              type: {
+                kind: "NonNullType",
+                type: {
+                  kind: "ListType",
+                  type: {
+                    kind: "NonNullType",
+                    type: {
+                      kind: "NamedType",
+                      name: { kind: "Name", value: "BigInt" }
+                    }
+                  }
+                }
+              }
+            }
+          ],
+          selectionSet: {
+            kind: "SelectionSet",
+            selections: [
+              {
+                kind: "Field",
+                name: { kind: "Name", value: "dataRegistryProofs" },
+                arguments: [
+                  {
+                    kind: "Argument",
+                    name: { kind: "Name", value: "where" },
+                    value: {
+                      kind: "ObjectValue",
+                      fields: [
+                        {
+                          kind: "ObjectField",
+                          name: { kind: "Name", value: "fileId_in" },
+                          value: {
+                            kind: "Variable",
+                            name: { kind: "Name", value: "fileIds" }
+                          }
+                        }
+                      ]
+                    }
+                  }
+                ],
+                selectionSet: {
+                  kind: "SelectionSet",
+                  selections: [
+                    { kind: "Field", name: { kind: "Name", value: "fileId" } },
+                    {
+                      kind: "Field",
+                      name: { kind: "Name", value: "dlp" },
+                      selectionSet: {
+                        kind: "SelectionSet",
+                        selections: [
+                          { kind: "Field", name: { kind: "Name", value: "id" } }
+                        ]
+                      }
+                    }
+                  ]
+                }
+              }
+            ]
+          }
+        }
+      ]
+    };
+    GetDlpDocument = {
+      kind: "Document",
+      definitions: [
+        {
+          kind: "OperationDefinition",
+          operation: "query",
+          name: { kind: "Name", value: "GetDLP" },
+          variableDefinitions: [
+            {
+              kind: "VariableDefinition",
+              variable: { kind: "Variable", name: { kind: "Name", value: "id" } },
+              type: {
+                kind: "NonNullType",
+                type: { kind: "NamedType", name: { kind: "Name", value: "ID" } }
+              }
+            }
+          ],
+          selectionSet: {
+            kind: "SelectionSet",
+            selections: [
+              {
+                kind: "Field",
+                name: { kind: "Name", value: "dlp" },
+                arguments: [
+                  {
+                    kind: "Argument",
+                    name: { kind: "Name", value: "id" },
+                    value: {
+                      kind: "Variable",
+                      name: { kind: "Name", value: "id" }
+                    }
+                  }
+                ],
+                selectionSet: {
+                  kind: "SelectionSet",
+                  selections: [
+                    { kind: "Field", name: { kind: "Name", value: "id" } },
+                    { kind: "Field", name: { kind: "Name", value: "name" } },
+                    { kind: "Field", name: { kind: "Name", value: "metadata" } },
+                    { kind: "Field", name: { kind: "Name", value: "status" } },
+                    { kind: "Field", name: { kind: "Name", value: "address" } },
+                    { kind: "Field", name: { kind: "Name", value: "owner" } }
+                  ]
+                }
+              }
+            ]
+          }
+        }
+      ]
+    };
     GetSchemaDocument = {
       kind: "Document",
       definitions: [
@@ -36475,6 +36905,64 @@ var init_subgraph = __esm({
   }
 });
 
+// src/utils/blockchain/registry.ts
+import { getContract } from "viem";
+async function fetchSchemaFromChain(context, schemaId) {
+  const chainId = context.walletClient.chain?.id;
+  if (!chainId) {
+    throw new Error("Chain ID not available");
+  }
+  const dataRefinerRegistryAddress = getContractAddress(
+    chainId,
+    "DataRefinerRegistry"
+  );
+  const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
+  const dataRefinerRegistry = getContract({
+    address: dataRefinerRegistryAddress,
+    abi: dataRefinerRegistryAbi,
+    client: context.publicClient
+  });
+  const schemaData = await dataRefinerRegistry.read.schemas([BigInt(schemaId)]);
+  if (!schemaData) {
+    throw new Error(`Schema with ID ${schemaId} not found`);
+  }
+  const schemaObj = schemaData;
+  if (!schemaObj.name || !schemaObj.dialect || !schemaObj.definitionUrl) {
+    throw new Error("Incomplete schema data");
+  }
+  return {
+    id: schemaId,
+    name: schemaObj.name,
+    dialect: schemaObj.dialect,
+    definitionUrl: schemaObj.definitionUrl
+  };
+}
+async function fetchSchemaCountFromChain(context) {
+  const chainId = context.walletClient.chain?.id;
+  if (!chainId) {
+    throw new Error("Chain ID not available");
+  }
+  const dataRefinerRegistryAddress = getContractAddress(
+    chainId,
+    "DataRefinerRegistry"
+  );
+  const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
+  const dataRefinerRegistry = getContract({
+    address: dataRefinerRegistryAddress,
+    abi: dataRefinerRegistryAbi,
+    client: context.publicClient
+  });
+  const count = await dataRefinerRegistry.read.schemasCount();
+  return Number(count);
+}
+var init_registry = __esm({
+  "src/utils/blockchain/registry.ts"() {
+    "use strict";
+    init_addresses();
+    init_abi();
+  }
+});
+
 // src/utils/urlResolver.ts
 async function fetchFromUrl(url) {
   try {
@@ -37158,6 +37646,7 @@ init_transactionHandle();
 init_errors();
 init_addresses();
 init_abi();
+import { getAddress as getAddress3 } from "viem";
 
 // src/utils/grantFiles.ts
 init_errors();
@@ -37328,6 +37817,7 @@ function validateGrantFile(data) {
 }
 
 // src/utils/grantValidation.ts
+import { getAddress } from "viem";
 import Ajv2 from "ajv";
 import addFormats2 from "ajv-formats";
 
@@ -37531,7 +38021,9 @@ function extractFieldFromBusinessError(error) {
   return void 0;
 }
 function validateGranteeAccess(grantFile, requestingAddress) {
-  if (grantFile.grantee.toLowerCase() !== requestingAddress.toLowerCase()) {
+  const normalizedGrantee = getAddress(grantFile.grantee);
+  const normalizedRequesting = getAddress(requestingAddress);
+  if (normalizedGrantee !== normalizedRequesting) {
     throw new GranteeMismatchError(
       "Permission denied: requesting address does not match grantee",
       grantFile.grantee,
@@ -37563,6 +38055,7 @@ function validateOperationAccess(grantFile, requestedOperation) {
 
 // src/utils/signatureCache.ts
 init_crypto_utils();
+import { getAddress as getAddress2 } from "viem";
 var SignatureCache = class {
   /**
    * Get a cached signature if it exists and hasn't expired
@@ -37653,7 +38146,7 @@ var SignatureCache = class {
     }
   }
   static getCacheKey(walletAddress, messageHash) {
-    return `${this.PREFIX}${walletAddress.toLowerCase()}:${messageHash}`;
+    return `${this.PREFIX}${getAddress2(walletAddress)}:${messageHash}`;
   }
   /**
    * Generate a deterministic hash of a message object for cache key generation
@@ -38928,20 +39421,22 @@ var PermissionsController = class {
       if (!userData || !userData.permissions?.length) {
         return [];
       }
-      const onChainGrants = userData.permissions.slice(0, limit).map((permission) => ({
-        id: BigInt(permission.id),
-        grantUrl: permission.grant,
-        grantSignature: permission.signature,
-        grantHash: "",
-        // Not available in new schema, compute if needed
-        nonce: BigInt(permission.nonce),
-        addedAtBlock: BigInt(permission.addedAtBlock),
-        addedAtTimestamp: BigInt(permission.addedAtTimestamp || "0"),
-        transactionHash: permission.transactionHash || "",
-        grantor: userAddress,
-        active: !permission.endBlock || BigInt(permission.endBlock) === 0n
-        // Active if no end block or end block is 0
-      }));
+      const onChainGrants = userData.permissions.slice(0, limit).map(
+        (permission) => ({
+          id: BigInt(permission.id),
+          grantUrl: permission.grant,
+          grantSignature: permission.signature,
+          nonce: BigInt(permission.nonce),
+          startBlock: BigInt(permission.startBlock),
+          addedAtBlock: BigInt(permission.addedAtBlock),
+          addedAtTimestamp: BigInt(permission.addedAtTimestamp || "0"),
+          transactionHash: permission.transactionHash || "",
+          grantor: userAddress,
+          grantee: permission.grantee,
+          active: !permission.endBlock || BigInt(permission.endBlock) === 0n
+          // Active if no end block or end block is 0
+        })
+      );
       return onChainGrants.sort((a, b) => {
         if (a.id < b.id) return 1;
         if (a.id > b.id) return -1;
@@ -39019,14 +39514,16 @@ var PermissionsController = class {
       );
       const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
       const userAddress = this.context.walletClient.account?.address || await this.getUserAddress();
+      const normalizedUserAddress = getAddress3(userAddress);
+      const normalizedServerAddress = getAddress3(params.serverAddress);
       const txHash = await this.context.walletClient.writeContract({
         address: DataPortabilityServersAddress,
         abi: DataPortabilityServersAbi,
         functionName: "addAndTrustServerByManager",
         args: [
-          userAddress,
+          normalizedUserAddress,
           {
-            serverAddress: params.serverAddress,
+            serverAddress: normalizedServerAddress,
             serverUrl: params.serverUrl,
             publicKey: params.publicKey
           }
@@ -39096,9 +39593,10 @@ var PermissionsController = class {
   async submitAddAndTrustServerWithSignature(params) {
     try {
       const nonce = await this.getServersUserNonce();
+      const serverAddress = getAddress3(params.serverAddress);
       const addAndTrustServerInput = {
         nonce,
-        serverAddress: params.serverAddress,
+        serverAddress,
         publicKey: params.publicKey,
         serverUrl: params.serverUrl
       };
@@ -39903,11 +40401,13 @@ var PermissionsController = class {
       "DataPortabilityGrantees"
     );
     const DataPortabilityGranteesAbi = getAbi("DataPortabilityGrantees");
+    const ownerAddress = getAddress3(params.owner);
+    const granteeAddress = getAddress3(params.granteeAddress);
     const txHash = await this.context.walletClient.writeContract({
       address: DataPortabilityGranteesAddress,
       abi: DataPortabilityGranteesAbi,
       functionName: "registerGrantee",
-      args: [params.owner, params.granteeAddress, params.publicKey],
+      args: [ownerAddress, granteeAddress, params.publicKey],
       account: this.context.walletClient.account || await this.getUserAddress(),
       chain: this.context.walletClient.chain || null
     });
@@ -39934,10 +40434,12 @@ var PermissionsController = class {
    */
   async submitRegisterGranteeWithSignature(params) {
     const nonce = await this.getServersUserNonce();
+    const owner = getAddress3(params.owner);
+    const granteeAddress = getAddress3(params.granteeAddress);
     const registerGranteeInput = {
       nonce,
-      owner: params.owner,
-      granteeAddress: params.granteeAddress,
+      owner,
+      granteeAddress,
       publicKey: params.publicKey
     };
     const typedData = await this.buildRegisterGranteeTypedData(registerGranteeInput);
@@ -41448,7 +41950,9 @@ var PermissionsController = class {
 init_transactionHandle();
 init_addresses();
 init_abi();
+init_subgraph();
 import { getContract as getContract2 } from "viem";
+import { print as print2 } from "graphql";
 
 // src/utils/encryption.ts
 var DEFAULT_ENCRYPTION_SEED = "Please sign to retrieve your encryption key";
@@ -41872,34 +42376,16 @@ var DataController = class {
       );
     }
     try {
-      const query = `
-        query GetUserFiles($userId: ID!) {
-          user(id: $userId) {
-            id
-            files {
-              id
-              url
-              schemaId
-              addedAtBlock
-              addedAtTimestamp
-              transactionHash
-              owner {
-                id
-              }
-            }
-          }
-        }
-      `;
       const response = await fetch(endpoint, {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
         },
         body: JSON.stringify({
-          query,
+          query: print2(GetUserFilesDocument),
           variables: {
             userId: owner.toLowerCase()
-            // Subgraph stores addresses in lowercase
+            // Subgraph requires lowercase addresses
           }
         })
       });
@@ -41979,23 +42465,13 @@ var DataController = class {
    * @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,
+        query: print2(GetFileProofsDocument),
         variables: {
           fileIds: fileIds.map((id) => id.toString())
         }
@@ -42099,25 +42575,13 @@ var DataController = class {
     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,
+            query: print2(GetDlpDocument),
             variables: {
               id: dlpId.toString()
             }
@@ -42140,7 +42604,7 @@ var DataController = class {
         return {
           id: parseInt(result.data.dlp.id),
           name: result.data.dlp.name || "",
-          metadata: result.data.dlp.metadata,
+          metadata: result.data.dlp.metadata || void 0,
           status: result.data.dlp.status ? parseInt(result.data.dlp.status) : void 0,
           address: result.data.dlp.address,
           owner: result.data.dlp.owner
@@ -42354,32 +42818,13 @@ var DataController = class {
   async _getUserPermissionsViaSubgraph(params) {
     const { user, subgraphUrl } = params;
     try {
-      const query = `
-        query GetUserPermissions($userId: ID!) {
-          user(id: $userId) {
-            id
-            permissions {
-              id
-              grant
-              nonce
-              signature
-              addedAtBlock
-              addedAtTimestamp
-              transactionHash
-              user {
-                id
-              }
-            }
-          }
-        }
-      `;
       const response = await fetch(subgraphUrl, {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
         },
         body: JSON.stringify({
-          query,
+          query: print2(GetUserPermissionsDocument),
           variables: {
             userId: user.toLowerCase()
           }
@@ -42408,7 +42853,7 @@ var DataController = class {
         addedAtBlock: BigInt(permission.addedAtBlock),
         addedAtTimestamp: BigInt(permission.addedAtTimestamp),
         transactionHash: permission.transactionHash,
-        user: permission.user.id
+        user
       })).sort((a, b) => Number(b.addedAtTimestamp - a.addedAtTimestamp));
     } catch (error) {
       console.error("Failed to query user permissions from subgraph:", error);
@@ -42580,36 +43025,16 @@ var DataController = class {
       );
     }
     try {
-      const query = `
-        query GetUserTrustedServers($userId: ID!) {
-          user(id: $userId) {
-            id
-            serverTrusts {
-              id
-              server {
-                id
-                serverAddress
-                url
-                publicKey
-              }
-              trustedAt
-              trustedAtBlock
-              untrustedAtBlock
-              transactionHash
-            }
-          }
-        }
-      `;
       const response = await fetch(graphqlEndpoint, {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
         },
         body: JSON.stringify({
-          query,
+          query: print2(GetUserTrustedServersDocument),
           variables: {
             userId: user.toLowerCase()
-            // Subgraph stores addresses in lowercase
+            // Subgraph requires lowercase addresses
           }
         })
       });
@@ -43443,19 +43868,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) {
@@ -43823,6 +44260,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;
@@ -43904,26 +44408,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) {
@@ -43939,7 +44446,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) {
@@ -43956,30 +44463,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));
    * }
    * ```
    */