@opendatalabs/vana-sdk 3.4.1-canary.e9d0aad → 3.5.0

package/dist/index.browser.js

@@ -31882,7 +31882,6 @@ async function verifyWeb3Signed(params) {
 // src/protocol/eip712.ts
 var DOMAIN_NAME = "Vana Data Portability";
 var DOMAIN_VERSION = "1";
-var NATIVE_VANA_ASSET = "0x0000000000000000000000000000000000000000";
 function buildDomain(chainId, verifyingContract) {
   return {
     name: DOMAIN_NAME,
@@ -31891,7 +31890,13 @@ function buildDomain(chainId, verifyingContract) {
     verifyingContract
   };
 }
-function dataRegistryDomain(config) {
+function fileRegistrationDomain(config) {
+  return buildDomain(
+    config.chainId,
+    config.contracts.dataRegistry
+  );
+}
+function fileDeletionDomain(config) {
   return buildDomain(
     config.chainId,
     config.contracts.dataRegistry
@@ -31921,26 +31926,31 @@ function builderRegistrationDomain(config) {
     config.contracts.dataPortabilityGrantees
   );
 }
-function escrowPaymentDomain(config) {
-  return buildDomain(
-    config.chainId,
-    config.contracts.dataPortabilityEscrow
-  );
-}
+var FILE_REGISTRATION_TYPES = {
+  FileRegistration: [
+    { name: "ownerAddress", type: "address" },
+    { name: "url", type: "string" },
+    { name: "schemaId", type: "bytes32" }
+  ]
+};
+var FILE_DELETION_TYPES = {
+  FileDeletion: [
+    { name: "ownerAddress", type: "address" },
+    { name: "fileId", type: "bytes32" }
+  ]
+};
 var GRANT_REGISTRATION_TYPES = {
   GrantRegistration: [
     { name: "grantorAddress", type: "address" },
     { name: "granteeId", type: "bytes32" },
-    { name: "scopes", type: "string[]" },
-    { name: "grantVersion", type: "uint256" },
-    { name: "expiresAt", type: "uint256" }
+    { name: "grant", type: "string" },
+    { name: "fileIds", type: "uint256[]" }
   ]
 };
 var GRANT_REVOCATION_TYPES = {
   GrantRevocation: [
     { name: "grantorAddress", type: "address" },
-    { name: "grantId", type: "bytes32" },
-    { name: "grantVersion", type: "uint256" }
+    { name: "grantId", type: "bytes32" }
   ]
 };
 var SERVER_REGISTRATION_TYPES = {
@@ -31959,41 +31969,16 @@ var BUILDER_REGISTRATION_TYPES = {
     { name: "appUrl", type: "string" }
   ]
 };
-var GENERIC_PAYMENT_TYPES = {
-  GenericPayment: [
-    { name: "payerAddress", type: "address" },
-    { name: "opType", type: "string" },
-    { name: "opId", type: "bytes32" },
-    { name: "asset", type: "address" },
-    { name: "amount", type: "uint256" },
-    { name: "paymentNonce", type: "uint256" }
-  ]
-};
-var ADD_DATA_TYPES = {
-  AddData: [
-    { name: "ownerAddress", type: "address" },
-    { name: "scope", type: "string" },
-    { name: "dataHash", type: "bytes32" },
-    { name: "metadataHash", type: "bytes32" },
-    { name: "expectedVersion", type: "uint256" }
-  ]
-};
-var RECORD_DATA_ACCESS_TYPES = {
-  RecordDataAccess: [
-    { name: "ownerAddress", type: "address" },
-    { name: "scope", type: "string" },
-    { name: "version", type: "uint256" },
-    { name: "accessor", type: "address" },
-    { name: "recordId", type: "bytes32" }
-  ]
-};
 
 // src/protocol/personal-server-registration.ts
 import {
   isAddress
 } from "viem";
-var PERSONAL_SERVER_REGISTRATION_DEFAULT_CHAIN_ID = 1480;
-var PERSONAL_SERVER_REGISTRATION_DEFAULT_VERIFYING_CONTRACT = "0x1483B1F634DBA75AeaE60da7f01A679aabd5ee2c";
+var PERSONAL_SERVER_REGISTRATION_DEFAULT_CHAIN_ID = vanaMainnet2.id;
+var PERSONAL_SERVER_REGISTRATION_DEFAULT_VERIFYING_CONTRACT = getContractAddress(
+  PERSONAL_SERVER_REGISTRATION_DEFAULT_CHAIN_ID,
+  "DataPortabilityServers"
+);
 function assertAddress(value, name) {
   if (!isAddress(value)) {
     throw new Error(`${name} must be a valid EVM address`);
@@ -32008,6 +31993,12 @@ function getAccountAddress(account) {
 function isPersonalServerRegistrationSigner(source) {
   return "address" in source && typeof source.signTypedData === "function";
 }
+function getDefaultServerRegistrationContract(chainId) {
+  return getContractAddress(
+    chainId,
+    "DataPortabilityServers"
+  );
+}
 function createViemPersonalServerRegistrationSigner(source, options = {}) {
   if (isPersonalServerRegistrationSigner(source)) {
     return source;
@@ -32030,12 +32021,13 @@ function personalServerRegistrationDomain(input = {}) {
   if (input.config) {
     return serverRegistrationDomain(input.config);
   }
-  const verifyingContract = input.verifyingContract ?? PERSONAL_SERVER_REGISTRATION_DEFAULT_VERIFYING_CONTRACT;
+  const chainId = input.chainId ?? PERSONAL_SERVER_REGISTRATION_DEFAULT_CHAIN_ID;
+  const verifyingContract = input.verifyingContract ?? getDefaultServerRegistrationContract(chainId);
   assertAddress(verifyingContract, "verifyingContract");
   return {
     name: "Vana Data Portability",
     version: "1",
-    chainId: input.chainId ?? PERSONAL_SERVER_REGISTRATION_DEFAULT_CHAIN_ID,
+    chainId,
     verifyingContract
   };
 }
@@ -32073,11 +32065,11 @@ async function buildPersonalServerRegistrationSignature(input) {
 }
 var registerPersonalServerSignature = buildPersonalServerRegistrationSignature;
 
-// src/protocol/personal-server-lite-owner-binding.ts
+// src/personal-server-lite/owner-binding.ts
 import {
   isAddress as isAddress2
 } from "viem";
-var PERSONAL_SERVER_LITE_OWNER_BINDING_VERSION = "vana.account.v1";
+var PERSONAL_SERVER_LITE_OWNER_BINDING_VERSION = "vana.ps-lite.owner-binding.v1";
 var PERSONAL_SERVER_LITE_OWNER_BINDING_PURPOSE = "ps-lite-owner";
 var PERSONAL_SERVER_LITE_OWNER_BINDING_PREFIX = `${PERSONAL_SERVER_LITE_OWNER_BINDING_VERSION}:${PERSONAL_SERVER_LITE_OWNER_BINDING_PURPOSE}:`;
 function assertAddress2(value, name) {
@@ -32428,34 +32420,67 @@ function isDataPortabilityGatewayConfig(value) {
     return false;
   }
   const c = contracts;
-  return isHexString(c["dataRegistry"]) && isHexString(c["dataPortabilityPermissions"]) && isHexString(c["dataPortabilityServer"]) && isHexString(c["dataPortabilityGrantees"]) && isHexString(c["dataPortabilityEscrow"]) && isHexString(c["feeRegistry"]);
+  return isHexString(c["dataRegistry"]) && isHexString(c["dataPortabilityPermissions"]) && isHexString(c["dataPortabilityServer"]) && isHexString(c["dataPortabilityGrantees"]);
 }
-function toUint256(value) {
+function parseGrantRegistrationPayload(grant) {
+  let parsed;
   try {
-    if (typeof value === "number" && !Number.isSafeInteger(value)) {
-      return null;
-    }
-    const big = typeof value === "bigint" ? value : BigInt(value);
-    if (big < 0n) return null;
-    return big;
+    parsed = JSON.parse(grant);
   } catch {
     return null;
   }
-}
-async function verifyGrantRegistration(input) {
-  if (!Array.isArray(input.scopes) || input.scopes.length === 0) {
-    return { valid: false, error: "scopes must be a non-empty array" };
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return null;
+  }
+  const value = parsed;
+  if (!Array.isArray(value["scopes"]) || value["scopes"].length === 0) {
+    return null;
+  }
+  if (!value["scopes"].every((scope) => typeof scope === "string")) {
+    return null;
+  }
+  if (typeof value["expiresAt"] !== "number" || !Number.isFinite(value["expiresAt"])) {
+    return null;
+  }
+  if (value["user"] !== void 0 && !isHexString(value["user"])) {
+    return null;
+  }
+  if (value["builder"] !== void 0 && !isHexString(value["builder"])) {
+    return null;
   }
-  if (!input.scopes.every((scope) => typeof scope === "string")) {
-    return { valid: false, error: "scopes must contain only strings" };
+  if (value["nonce"] !== void 0 && (typeof value["nonce"] !== "number" || !Number.isFinite(value["nonce"]))) {
+    return null;
   }
-  const grantVersion = toUint256(input.grantVersion);
-  if (grantVersion === null || grantVersion < 1n) {
-    return { valid: false, error: "grantVersion must be a uint256 >= 1" };
+  return {
+    user: value["user"],
+    builder: value["builder"],
+    scopes: value["scopes"],
+    expiresAt: value["expiresAt"],
+    nonce: value["nonce"]
+  };
+}
+function parseFileIds(fileIds) {
+  try {
+    const values = (fileIds ?? []).map((fileId) => BigInt(fileId));
+    return {
+      values,
+      display: values.map((fileId) => fileId.toString())
+    };
+  } catch {
+    return null;
   }
-  const expiresAt = toUint256(input.expiresAt);
-  if (expiresAt === null) {
-    return { valid: false, error: "expiresAt must be a non-negative uint256" };
+}
+async function verifyGrantRegistration(input) {
+  const payload = parseGrantRegistrationPayload(input.grant);
+  if (!payload) {
+    return {
+      valid: false,
+      error: "Grant must be JSON with scopes and expiresAt"
+    };
+  }
+  const fileIds = parseFileIds(input.fileIds);
+  if (!fileIds) {
+    return { valid: false, error: "fileIds must contain integer values" };
   }
   let valid;
   try {
@@ -32467,9 +32492,8 @@ async function verifyGrantRegistration(input) {
       message: {
         grantorAddress: input.grantorAddress,
         granteeId: input.granteeId,
-        scopes: input.scopes,
-        grantVersion,
-        expiresAt
+        grant: input.grant,
+        fileIds: fileIds.values
       },
       signature: input.signature
     });
@@ -32480,197 +32504,19 @@ async function verifyGrantRegistration(input) {
     return { valid: false, error: "Grant signature does not match grantor" };
   }
   const nowSeconds = input.nowSeconds ?? Math.floor(Date.now() / 1e3);
-  if (expiresAt > 0n && expiresAt < BigInt(nowSeconds)) {
+  if (payload.expiresAt > 0 && payload.expiresAt < nowSeconds) {
     return { valid: false, error: "Grant has expired" };
   }
+  if (payload.user !== void 0 && payload.user.toLowerCase() !== input.grantorAddress.toLowerCase()) {
+    return { valid: false, error: "Grant user does not match grantorAddress" };
+  }
   return {
     valid: true,
     grantorAddress: input.grantorAddress,
     granteeId: input.granteeId,
-    scopes: input.scopes,
-    grantVersion: grantVersion.toString(),
-    expiresAt: expiresAt.toString()
-  };
-}
-
-// src/protocol/escrow-deposit.ts
-import { encodeFunctionData } from "viem";
-var ESCROW_DEPOSIT_ABI = [
-  {
-    type: "function",
-    name: "depositNative",
-    stateMutability: "payable",
-    inputs: [{ name: "account", type: "address" }],
-    outputs: []
-  },
-  {
-    type: "function",
-    name: "depositToken",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "account", type: "address" },
-      { name: "token", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: []
-  }
-];
-function escrowContractAddress(config) {
-  return config.contracts.dataPortabilityEscrow;
-}
-function encodeDepositNativeData(input) {
-  return encodeFunctionData({
-    abi: ESCROW_DEPOSIT_ABI,
-    functionName: "depositNative",
-    args: [input.account]
-  });
-}
-function encodeDepositTokenData(input) {
-  return encodeFunctionData({
-    abi: ESCROW_DEPOSIT_ABI,
-    functionName: "depositToken",
-    args: [input.account, input.token, input.amount]
-  });
-}
-function buildDepositNativeRequest(config, input) {
-  return {
-    to: escrowContractAddress(config),
-    data: encodeDepositNativeData({ account: input.account }),
-    value: input.amount
-  };
-}
-function buildDepositTokenRequest(config, input) {
-  return {
-    to: escrowContractAddress(config),
-    data: encodeDepositTokenData(input)
-  };
-}
-
-// src/protocol/data-point-status.ts
-import { encodeFunctionData as encodeFunctionData2 } from "viem";
-var DataPointStatus = /* @__PURE__ */ ((DataPointStatus2) => {
-  DataPointStatus2[DataPointStatus2["None"] = 0] = "None";
-  DataPointStatus2[DataPointStatus2["Active"] = 1] = "Active";
-  DataPointStatus2[DataPointStatus2["Inactive"] = 2] = "Inactive";
-  DataPointStatus2[DataPointStatus2["Unavailable"] = 3] = "Unavailable";
-  return DataPointStatus2;
-})(DataPointStatus || {});
-var DATA_REGISTRY_STATUS_ABI = [
-  {
-    type: "function",
-    name: "setStatus",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "scope", type: "string" },
-      { name: "newStatus", type: "uint8" }
-    ],
-    outputs: []
-  }
-];
-function dataRegistryContractAddress(config) {
-  return config.contracts.dataRegistry;
-}
-function encodeSetDataPointStatusData(input) {
-  return encodeFunctionData2({
-    abi: DATA_REGISTRY_STATUS_ABI,
-    functionName: "setStatus",
-    args: [input.scope, input.status]
-  });
-}
-function buildSetDataPointStatusRequest(config, input) {
-  return {
-    to: dataRegistryContractAddress(config),
-    data: encodeSetDataPointStatusData(input)
-  };
-}
-function buildMarkDataPointUnavailableRequest(config, input) {
-  return buildSetDataPointStatusRequest(config, {
-    scope: input.scope,
-    status: 3 /* Unavailable */
-  });
-}
-
-// src/protocol/fee-registry.ts
-import { parseAbi } from "viem";
-var FEE_REGISTRY_ABI = parseAbi([
-  "struct Fee { uint256 amount; address asset; address payee; bool enabled; }",
-  "function fees(bytes32 operation) view returns (Fee)",
-  "function operationKey(string name) pure returns (bytes32)"
-]);
-var REGISTRATION_KIND_FOR_OP = {
-  grant: "grant_registration",
-  data: "data_registration",
-  server: "server_registration",
-  builder: "builder_registration"
-};
-function operationNameFor(kind, opts) {
-  switch (kind) {
-    case "grant_registration":
-      return opts?.grantRegistrationOpName ?? "grant_registration";
-    case "data_access":
-      return opts?.dataAccessOpName ?? "data_access";
-    case "data_registration":
-      return opts?.dataRegistrationOpName ?? "data_registration";
-    case "server_registration":
-      return opts?.serverRegistrationOpName ?? "server_registration";
-    case "builder_registration":
-      return opts?.builderRegistrationOpName ?? "builder_registration";
-  }
-}
-var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-async function getFee(client, config, kind, opts) {
-  const address = config.contracts.feeRegistry;
-  const opName = operationNameFor(kind, opts);
-  const opKey = await client.readContract({
-    address,
-    abi: FEE_REGISTRY_ABI,
-    functionName: "operationKey",
-    args: [opName]
-  });
-  const fee = await client.readContract({
-    address,
-    abi: FEE_REGISTRY_ABI,
-    functionName: "fees",
-    args: [opKey]
-  });
-  if (fee.enabled && fee.payee === ZERO_ADDRESS) {
-    throw new Error(
-      `FeeRegistry: enabled operation "${opName}" has zero-address payee \u2014 contract pre-flight rejects payouts to 0x0`
-    );
-  }
-  return fee;
-}
-async function getOpFee(client, config, opType, opts) {
-  const registrationKind = REGISTRATION_KIND_FOR_OP[opType];
-  if (!registrationKind) {
-    throw new Error(
-      `getOpFee: unknown opType "${opType}" \u2014 supported types are ${Object.keys(REGISTRATION_KIND_FOR_OP).join(", ")}`
-    );
-  }
-  const includeDataAccess = opType === "grant";
-  const [registration, dataAccess] = await Promise.all([
-    getFee(client, config, registrationKind, opts),
-    includeDataAccess ? getFee(client, config, "data_access", opts) : Promise.resolve({
-      amount: 0n,
-      asset: ZERO_ADDRESS,
-      payee: ZERO_ADDRESS,
-      enabled: false
-    })
-  ]);
-  if (registration.enabled && dataAccess.enabled && registration.asset.toLowerCase() !== dataAccess.asset.toLowerCase()) {
-    throw new Error(
-      `FeeRegistry asset mismatch for "${opType}": registration=${registration.asset} vs data_access=${dataAccess.asset}. The gateway requires both kinds to settle in the same asset when both are enabled.`
-    );
-  }
-  const asset = registration.enabled ? registration.asset : dataAccess.enabled ? dataAccess.asset : ZERO_ADDRESS;
-  return {
-    asset,
-    registrationFee: registration.enabled ? registration.amount : 0n,
-    dataAccessFee: dataAccess.enabled ? dataAccess.amount : 0n,
-    registrationEnabled: registration.enabled,
-    dataAccessEnabled: dataAccess.enabled,
-    registrationPayee: registration.enabled ? registration.payee : ZERO_ADDRESS,
-    dataAccessPayee: dataAccess.enabled ? dataAccess.payee : ZERO_ADDRESS
+    grant: input.grant,
+    payload,
+    fileIds: fileIds.display
   };
 }
 
@@ -32744,45 +32590,6 @@ var IngestResponseSchema = z2.object({
   status: z2.enum(["stored", "syncing"])
 });
 
-// src/protocol/personal-server-data.ts
-function personalServerDataReadPath(scope) {
-  return `/v1/data/${encodeURIComponent(scope)}`;
-}
-async function buildPersonalServerDataReadRequest(params) {
-  const path = personalServerDataReadPath(params.scope);
-  const baseUrl = params.personalServerUrl.replace(/\/+$/, "");
-  const audience = params.audience ?? baseUrl;
-  const headers = new Headers(params.headers);
-  headers.set(
-    "Authorization",
-    await buildWeb3SignedHeader({
-      aud: audience,
-      grantId: params.grantId,
-      method: "GET",
-      signMessage: params.signMessage,
-      uri: path
-    })
-  );
-  return new Request(`${baseUrl}${path}`, {
-    headers,
-    method: "GET"
-  });
-}
-async function readPersonalServerData(params) {
-  const fetchFn = params.fetch ?? globalThis.fetch;
-  if (fetchFn === void 0) {
-    throw new Error("No fetch implementation available");
-  }
-  const request = await buildPersonalServerDataReadRequest(params);
-  const response = await fetchFn(request);
-  if (!response.ok) {
-    throw new Error(
-      `Personal Server data read failed: ${response.status} ${response.statusText}`
-    );
-  }
-  return DataFileEnvelopeSchema.parse(await response.json());
-}
-
 // src/protocol/gateway.ts
 function createGatewayClient(baseUrl) {
   const base = baseUrl.replace(/\/+$/, "");
@@ -32790,6 +32597,16 @@ function createGatewayClient(baseUrl) {
     const envelope = await res.json();
     return envelope.data;
   }
+  function normalizeFileRecord(record) {
+    return {
+      fileId: record.fileId ?? record.id ?? "",
+      owner: record.owner ?? record.ownerAddress ?? "",
+      url: record.url,
+      schemaId: record.schemaId,
+      createdAt: record.createdAt ?? record.addedAt ?? "",
+      deletedAt: record.deletedAt ?? null
+    };
+  }
   function getMutationId(body, key) {
     const value = body[key] ?? body["id"];
     return typeof value === "string" ? value : void 0;
@@ -32839,33 +32656,31 @@ function createGatewayClient(baseUrl) {
       }
       return unwrapEnvelope(res);
     },
-    async getDataPoint(dataPointId) {
-      const res = await fetch(`${base}/v1/data/${dataPointId}`);
+    async getFile(fileId) {
+      const res = await fetch(`${base}/v1/files/${fileId}`);
       if (res.status === 404) return null;
       if (!res.ok) {
         throw new Error(`Gateway error: ${res.status} ${res.statusText}`);
       }
-      return unwrapEnvelope(res);
+      return normalizeFileRecord(await unwrapEnvelope(res));
     },
-    async listDataPointsByOwner(owner, cursor, options) {
+    async listFilesSince(owner, cursor, options) {
       const params = new URLSearchParams({ user: owner });
       if (cursor !== null) {
         params.set("cursor", cursor);
       }
-      if (options?.since) {
-        params.set("since", options.since);
+      if (options?.includeDeleted) {
+        params.set("includeDeleted", "true");
       }
-      if (options?.limit !== void 0) {
-        params.set("limit", String(options.limit));
-      }
-      const res = await fetch(`${base}/v1/data?${params.toString()}`);
+      const res = await fetch(`${base}/v1/files?${params.toString()}`);
       if (!res.ok) {
         throw new Error(`Gateway error: ${res.status} ${res.statusText}`);
       }
       const envelope = await res.json();
-      const nextCursor = envelope.pagination?.hasMore === false ? null : envelope.pagination?.nextCursor ?? null;
+      const { pagination } = envelope;
+      const nextCursor = pagination?.hasMore === false ? null : pagination?.nextCursor ?? envelope.data.cursor ?? null;
       return {
-        dataPoints: envelope.data.dataPoints,
+        files: envelope.data.files.map(normalizeFileRecord),
         cursor: nextCursor
       };
     },
@@ -32907,8 +32722,8 @@ function createGatewayClient(baseUrl) {
         alreadyRegistered: false
       };
     },
-    async registerBuilder(params) {
-      const res = await fetch(`${base}/v1/builders`, {
+    async registerFile(params) {
+      const res = await fetch(`${base}/v1/files`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -32916,57 +32731,22 @@ function createGatewayClient(baseUrl) {
         },
         body: JSON.stringify({
           ownerAddress: params.ownerAddress,
-          granteeAddress: params.granteeAddress,
-          publicKey: params.publicKey,
-          appUrl: params.appUrl
+          url: params.url,
+          schemaId: params.schemaId
         })
       });
       if (res.status === 409) {
         const body2 = await res.json().catch(() => ({}));
         return {
-          builderId: getMutationId(
-            body2,
-            "builderId"
-          ),
-          alreadyRegistered: true
+          fileId: getMutationId(body2, "fileId")
         };
       }
       if (!res.ok) {
         throw new Error(`Gateway error: ${res.status} ${res.statusText}`);
       }
-      const body = await res.json().catch(() => ({}));
-      return {
-        builderId: getMutationId(body, "builderId"),
-        alreadyRegistered: false
-      };
-    },
-    async registerDataPoint(params) {
-      const res = await fetch(`${base}/v1/data`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Web3Signed ${params.signature}`
-        },
-        body: JSON.stringify({
-          ownerAddress: params.ownerAddress,
-          scope: params.scope,
-          dataHash: params.dataHash,
-          metadataHash: params.metadataHash,
-          expectedVersion: params.expectedVersion
-        })
-      });
-      if (!res.ok) {
-        const body2 = await res.json().catch(() => ({}));
-        const detail = body2.error ?? res.statusText;
-        throw new Error(`Gateway error: ${res.status} ${detail}`);
-      }
-      const body = await res.json().catch(() => ({}));
+      const body = await res.json();
       return {
-        dataPointId: getMutationId(
-          body,
-          "dataPointId"
-        ),
-        expectedVersion: body.expectedVersion
+        fileId: getMutationId(body, "fileId")
       };
     },
     async createGrant(params) {
@@ -32979,9 +32759,8 @@ function createGatewayClient(baseUrl) {
         body: JSON.stringify({
           grantorAddress: params.grantorAddress,
           granteeId: params.granteeId,
-          scopes: params.scopes,
-          grantVersion: params.grantVersion,
-          expiresAt: params.expiresAt
+          grant: params.grant,
+          fileIds: params.fileIds
         })
       });
       if (res.status === 409) {
@@ -33006,8 +32785,7 @@ function createGatewayClient(baseUrl) {
           Authorization: `Web3Signed ${params.signature}`
         },
         body: JSON.stringify({
-          grantorAddress: params.grantorAddress,
-          grantVersion: params.grantVersion
+          grantorAddress: params.grantorAddress
         })
       });
       if (res.status === 409) return;
@@ -33015,62 +32793,133 @@ function createGatewayClient(baseUrl) {
         throw new Error(`Gateway error: ${res.status} ${res.statusText}`);
       }
     },
-    async getEscrowBalance(account) {
-      const res = await fetch(`${base}/v1/escrow/balance?account=${account}`);
+    async deleteFile(params) {
+      const res = await fetch(`${base}/v1/files/${params.fileId}`, {
+        method: "DELETE",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Web3Signed ${params.signature}`
+        },
+        body: JSON.stringify({
+          ownerAddress: params.ownerAddress
+        })
+      });
+      if (res.status === 409) return;
       if (!res.ok) {
         throw new Error(`Gateway error: ${res.status} ${res.statusText}`);
       }
-      return await res.json();
-    },
-    async submitEscrowDeposit(params) {
+    }
+  };
+}
+
+// src/protocol/escrow.ts
+var GENERIC_PAYMENT_TYPES = {
+  GenericPayment: [
+    { name: "payerAddress", type: "address" },
+    { name: "opType", type: "string" },
+    { name: "opId", type: "bytes32" },
+    { name: "asset", type: "address" },
+    { name: "amount", type: "uint256" },
+    { name: "paymentNonce", type: "uint256" }
+  ]
+};
+function genericPaymentDomain(chainId, escrowContract) {
+  return {
+    name: "Vana Data Portability",
+    version: "1",
+    chainId,
+    verifyingContract: escrowContract
+  };
+}
+var ESCROW_DEPOSIT_ABI = [
+  {
+    type: "function",
+    name: "depositNative",
+    stateMutability: "payable",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "depositToken",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "account", type: "address" },
+      { name: "token", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: []
+  }
+];
+var NATIVE_ASSET_ADDRESS = "0x0000000000000000000000000000000000000000";
+function createEscrowGatewayClient(baseUrl) {
+  const base = baseUrl.replace(/\/+$/, "");
+  async function throwOnError(res, context) {
+    if (!res.ok) {
+      let detail = "";
+      try {
+        const body = await res.json();
+        if (body.error) detail = `: ${body.error}`;
+      } catch {
+      }
+      throw new Error(
+        `Escrow gateway error (${context}): ${res.status} ${res.statusText}${detail}`
+      );
+    }
+  }
+  return {
+    async submitDeposit({ txHash }) {
       const res = await fetch(`${base}/v1/escrow/deposit`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ txHash: params.txHash })
+        body: JSON.stringify({ txHash })
       });
       if (res.status !== 200 && res.status !== 202) {
-        throw new Error(`Gateway error: ${res.status} ${res.statusText}`);
+        await throwOnError(res, "POST /v1/escrow/deposit");
       }
-      return await res.json();
+      return res.json();
     },
-    async payForOperation(params) {
-      const body = {
-        payerAddress: params.payerAddress,
-        opType: params.opType,
-        opId: params.opId,
-        asset: params.asset,
-        amount: params.amount,
-        paymentNonce: params.paymentNonce
-      };
-      if (params.accessRecord) {
-        body["accessRecord"] = params.accessRecord;
-      }
+    async getEscrowBalance(account) {
+      const res = await fetch(
+        `${base}/v1/escrow/balance?account=${encodeURIComponent(account)}`
+      );
+      await throwOnError(res, "GET /v1/escrow/balance");
+      return res.json();
+    },
+    async syncEscrowBalance(account) {
+      const res = await fetch(
+        `${base}/v1/escrow/balance/sync?account=${encodeURIComponent(account)}`,
+        { method: "POST" }
+      );
+      await throwOnError(res, "POST /v1/escrow/balance/sync");
+      return res.json();
+    },
+    async payForOp({
+      payerAddress,
+      opType,
+      opId,
+      asset,
+      amount,
+      paymentNonce,
+      signature
+    }) {
       const res = await fetch(`${base}/v1/escrow/pay`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: `Web3Signed ${params.signature}`
+          Authorization: `Web3Signed ${signature}`
         },
-        body: JSON.stringify(body)
-      });
-      if (!res.ok) {
-        throw new Error(`Gateway error: ${res.status} ${res.statusText}`);
-      }
-      return await res.json();
-    },
-    async settle(params) {
-      const res = await fetch(`${base}/v1/settle`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        // The gateway accepts an empty body; only `limit` is recognised.
-        // Always send a JSON body so the gateway's req.body shape parse
-        // doesn't have to deal with an undefined.
-        body: JSON.stringify(params ?? {})
+        body: JSON.stringify({
+          payerAddress,
+          opType,
+          opId,
+          asset,
+          amount,
+          paymentNonce
+        })
       });
-      if (!res.ok) {
-        throw new Error(`Gateway error: ${res.status} ${res.statusText}`);
-      }
-      return await res.json();
+      await throwOnError(res, "POST /v1/escrow/pay");
+      return res.json();
     }
   };
 }
@@ -33139,7 +32988,6 @@ async function parsePSError(response) {
 }
 export {
   ACCOUNT_PERSONAL_SERVER_REGISTRATION_INTENT,
-  ADD_DATA_TYPES,
   AccountPersonalServerLiteOwnerBindingError,
   AccountPersonalServerRegistrationError,
   BUILDER_REGISTRATION_TYPES,
@@ -33150,14 +32998,13 @@ export {
   CallbackStorage,
   ContractFactory,
   ContractNotFoundError,
-  DATA_REGISTRY_STATUS_ABI,
   DataFileEnvelopeSchema,
-  DataPointStatus,
   DropboxStorage,
   ECIESError,
   ESCROW_DEPOSIT_ABI,
   ExpiredTokenError,
-  FEE_REGISTRY_ABI,
+  FILE_DELETION_TYPES,
+  FILE_REGISTRATION_TYPES,
   GENERIC_PAYMENT_TYPES,
   GRANT_REGISTRATION_TYPES,
   GRANT_REVOCATION_TYPES,
@@ -33169,7 +33016,7 @@ export {
   IpfsStorage,
   MASTER_KEY_MESSAGE,
   MissingAuthError,
-  NATIVE_VANA_ASSET,
+  NATIVE_ASSET_ADDRESS,
   NetworkError,
   NonceError,
   OAuthClient,
@@ -33185,8 +33032,6 @@ export {
   PersonalServerError,
   PinataStorage,
   R2Storage,
-  RECORD_DATA_ACCESS_TYPES,
-  REGISTRATION_KIND_FOR_OP,
   ReadOnlyError,
   RelayerError,
   SERVER_REGISTRATION_TYPES,
@@ -33201,15 +33046,10 @@ export {
   VanaError,
   VanaStorage,
   assertValidPkceVerifier,
-  buildDepositNativeRequest,
-  buildDepositTokenRequest,
-  buildMarkDataPointUnavailableRequest,
-  buildPersonalServerDataReadRequest,
   buildPersonalServerLiteOwnerBindingMessage,
   buildPersonalServerLiteOwnerBindingSignature,
   buildPersonalServerRegistrationSignature,
   buildPersonalServerRegistrationTypedData,
-  buildSetDataPointStatusRequest,
   buildWeb3SignedHeader,
   builderRegistrationDomain,
   chains,
@@ -33219,33 +33059,28 @@ export {
   contractCacheForTesting,
   createBrowserPlatformAdapter,
   createDataFileEnvelope,
+  createEscrowGatewayClient,
   createGatewayClient,
   createPlatformAdapterSafe,
   createVanaStorageProvider,
   createViemPersonalServerLiteOwnerBindingSigner,
   createViemPersonalServerRegistrationSigner,
-  dataRegistryContractAddress,
-  dataRegistryDomain,
   decryptWithPassword,
   deriveMasterKey,
   deriveScopeKey,
   deserializeECIES,
   detectPlatform,
-  encodeDepositNativeData,
-  encodeDepositTokenData,
-  encodeSetDataPointStatusData,
   encryptWithPassword,
-  escrowContractAddress,
-  escrowPaymentDomain,
+  fileDeletionDomain,
+  fileRegistrationDomain,
   generatePkceVerifier,
+  genericPaymentDomain,
   getAbi,
   getAllChains,
   getChainConfig,
   getContractAddress,
   getContractController,
   getContractInfo,
-  getFee,
-  getOpFee,
   getPlatformCapabilities,
   getServiceEndpoints,
   grantRegistrationDomain,
@@ -33257,12 +33092,11 @@ export {
   moksha,
   mokshaServices,
   mokshaTestnet2 as mokshaTestnet,
+  parseGrantRegistrationPayload,
   parsePSError,
   parseScope,
   parseWeb3SignedHeader,
-  personalServerDataReadPath,
   personalServerRegistrationDomain,
-  readPersonalServerData,
   recoverServerOwner,
   registerPersonalServerSignature,
   scopeCoveredByGrant,