@opendatalabs/vana-sdk 3.5.1 → 3.6.0

package/dist/index.node.cjs

@@ -1174,6 +1174,7 @@ var init_browser2 = __esm({
 var index_node_exports = {};
 __export(index_node_exports, {
   ACCOUNT_PERSONAL_SERVER_REGISTRATION_INTENT: () => ACCOUNT_PERSONAL_SERVER_REGISTRATION_INTENT,
+  ADD_DATA_TYPES: () => ADD_DATA_TYPES,
   AccountPersonalServerLiteOwnerBindingError: () => AccountPersonalServerLiteOwnerBindingError,
   AccountPersonalServerRegistrationError: () => AccountPersonalServerRegistrationError,
   BUILDER_REGISTRATION_TYPES: () => BUILDER_REGISTRATION_TYPES,
@@ -1183,13 +1184,14 @@ __export(index_node_exports, {
   CallbackStorage: () => CallbackStorage,
   ContractFactory: () => ContractFactory,
   ContractNotFoundError: () => ContractNotFoundError,
+  DATA_REGISTRY_STATUS_ABI: () => DATA_REGISTRY_STATUS_ABI,
   DataFileEnvelopeSchema: () => DataFileEnvelopeSchema,
+  DataPointStatus: () => DataPointStatus,
   DropboxStorage: () => DropboxStorage,
   ECIESError: () => ECIESError,
-  ESCROW_DEPOSIT_ABI: () => ESCROW_DEPOSIT_ABI,
+  ESCROW_DEPOSIT_ABI: () => ESCROW_DEPOSIT_ABI2,
   ExpiredTokenError: () => ExpiredTokenError,
-  FILE_DELETION_TYPES: () => FILE_DELETION_TYPES,
-  FILE_REGISTRATION_TYPES: () => FILE_REGISTRATION_TYPES,
+  FEE_REGISTRY_ABI: () => FEE_REGISTRY_ABI,
   GENERIC_PAYMENT_TYPES: () => GENERIC_PAYMENT_TYPES,
   GRANT_REGISTRATION_TYPES: () => GRANT_REGISTRATION_TYPES,
   GRANT_REVOCATION_TYPES: () => GRANT_REVOCATION_TYPES,
@@ -1202,6 +1204,7 @@ __export(index_node_exports, {
   MASTER_KEY_MESSAGE: () => MASTER_KEY_MESSAGE,
   MissingAuthError: () => MissingAuthError,
   NATIVE_ASSET_ADDRESS: () => NATIVE_ASSET_ADDRESS,
+  NATIVE_VANA_ASSET: () => NATIVE_VANA_ASSET,
   NetworkError: () => NetworkError,
   NodeECIESProvider: () => NodeECIESUint8Provider,
   NodePlatformAdapter: () => NodePlatformAdapter,
@@ -1219,6 +1222,8 @@ __export(index_node_exports, {
   PersonalServerError: () => PersonalServerError,
   PinataStorage: () => PinataStorage,
   R2Storage: () => R2Storage,
+  RECORD_DATA_ACCESS_TYPES: () => RECORD_DATA_ACCESS_TYPES,
+  REGISTRATION_KIND_FOR_OP: () => REGISTRATION_KIND_FOR_OP,
   ReadOnlyError: () => ReadOnlyError,
   RelayerError: () => RelayerError,
   SERVER_REGISTRATION_TYPES: () => SERVER_REGISTRATION_TYPES,
@@ -1233,10 +1238,15 @@ __export(index_node_exports, {
   VanaError: () => VanaError,
   VanaStorage: () => VanaStorage,
   assertValidPkceVerifier: () => assertValidPkceVerifier,
+  buildDepositNativeRequest: () => buildDepositNativeRequest,
+  buildDepositTokenRequest: () => buildDepositTokenRequest,
+  buildMarkDataPointUnavailableRequest: () => buildMarkDataPointUnavailableRequest,
+  buildPersonalServerDataReadRequest: () => buildPersonalServerDataReadRequest,
   buildPersonalServerLiteOwnerBindingMessage: () => buildPersonalServerLiteOwnerBindingMessage,
   buildPersonalServerLiteOwnerBindingSignature: () => buildPersonalServerLiteOwnerBindingSignature,
   buildPersonalServerRegistrationSignature: () => buildPersonalServerRegistrationSignature,
   buildPersonalServerRegistrationTypedData: () => buildPersonalServerRegistrationTypedData,
+  buildSetDataPointStatusRequest: () => buildSetDataPointStatusRequest,
   buildWeb3SignedHeader: () => buildWeb3SignedHeader,
   builderRegistrationDomain: () => builderRegistrationDomain,
   chains: () => chains,
@@ -1255,14 +1265,19 @@ __export(index_node_exports, {
   createVanaStorageProvider: () => createVanaStorageProvider,
   createViemPersonalServerLiteOwnerBindingSigner: () => createViemPersonalServerLiteOwnerBindingSigner,
   createViemPersonalServerRegistrationSigner: () => createViemPersonalServerRegistrationSigner,
+  dataRegistryContractAddress: () => dataRegistryContractAddress,
+  dataRegistryDomain: () => dataRegistryDomain,
   decryptWithPassword: () => decryptWithPassword,
   deriveMasterKey: () => deriveMasterKey,
   deriveScopeKey: () => deriveScopeKey,
   deserializeECIES: () => deserializeECIES,
   detectPlatform: () => detectPlatform,
+  encodeDepositNativeData: () => encodeDepositNativeData,
+  encodeDepositTokenData: () => encodeDepositTokenData,
+  encodeSetDataPointStatusData: () => encodeSetDataPointStatusData,
   encryptWithPassword: () => encryptWithPassword,
-  fileDeletionDomain: () => fileDeletionDomain,
-  fileRegistrationDomain: () => fileRegistrationDomain,
+  escrowContractAddress: () => escrowContractAddress,
+  escrowPaymentDomain: () => escrowPaymentDomain,
   generatePkceVerifier: () => generatePkceVerifier,
   genericPaymentDomain: () => genericPaymentDomain,
   getAbi: () => getAbi,
@@ -1271,6 +1286,8 @@ __export(index_node_exports, {
   getContractAddress: () => getContractAddress,
   getContractController: () => getContractController,
   getContractInfo: () => getContractInfo,
+  getFee: () => getFee,
+  getOpFee: () => getOpFee,
   getPlatformCapabilities: () => getPlatformCapabilities,
   getServiceEndpoints: () => getServiceEndpoints,
   grantRegistrationDomain: () => grantRegistrationDomain,
@@ -1282,11 +1299,12 @@ __export(index_node_exports, {
   moksha: () => moksha,
   mokshaServices: () => mokshaServices,
   mokshaTestnet: () => mokshaTestnet2,
-  parseGrantRegistrationPayload: () => parseGrantRegistrationPayload,
   parsePSError: () => parsePSError,
   parseScope: () => parseScope,
   parseWeb3SignedHeader: () => parseWeb3SignedHeader,
+  personalServerDataReadPath: () => personalServerDataReadPath,
   personalServerRegistrationDomain: () => personalServerRegistrationDomain,
+  readPersonalServerData: () => readPersonalServerData,
   recoverServerOwner: () => recoverServerOwner,
   registerPersonalServerSignature: () => registerPersonalServerSignature,
   scopeCoveredByGrant: () => scopeCoveredByGrant,
@@ -32712,6 +32730,7 @@ function formatOAuthError(body, status) {
 // 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,
@@ -32720,13 +32739,7 @@ function buildDomain(chainId, verifyingContract) {
     verifyingContract
   };
 }
-function fileRegistrationDomain(config) {
-  return buildDomain(
-    config.chainId,
-    config.contracts.dataRegistry
-  );
-}
-function fileDeletionDomain(config) {
+function dataRegistryDomain(config) {
   return buildDomain(
     config.chainId,
     config.contracts.dataRegistry
@@ -32756,31 +32769,26 @@ function builderRegistrationDomain(config) {
     config.contracts.dataPortabilityGrantees
   );
 }
-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" }
-  ]
-};
+function escrowPaymentDomain(config) {
+  return buildDomain(
+    config.chainId,
+    config.contracts.dataPortabilityEscrow
+  );
+}
 var GRANT_REGISTRATION_TYPES = {
   GrantRegistration: [
     { name: "grantorAddress", type: "address" },
     { name: "granteeId", type: "bytes32" },
-    { name: "grant", type: "string" },
-    { name: "fileIds", type: "uint256[]" }
+    { name: "scopes", type: "string[]" },
+    { name: "grantVersion", type: "uint256" },
+    { name: "expiresAt", type: "uint256" }
   ]
 };
 var GRANT_REVOCATION_TYPES = {
   GrantRevocation: [
     { name: "grantorAddress", type: "address" },
-    { name: "grantId", type: "bytes32" }
+    { name: "grantId", type: "bytes32" },
+    { name: "grantVersion", type: "uint256" }
   ]
 };
 var SERVER_REGISTRATION_TYPES = {
@@ -32799,6 +32807,24 @@ var BUILDER_REGISTRATION_TYPES = {
     { name: "appUrl", type: "string" }
   ]
 };
+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
 var import_viem14 = require("viem");
@@ -33246,67 +33272,34 @@ function isDataPortabilityGatewayConfig(value) {
     return false;
   }
   const c = contracts;
-  return isHexString(c["dataRegistry"]) && isHexString(c["dataPortabilityPermissions"]) && isHexString(c["dataPortabilityServer"]) && isHexString(c["dataPortabilityGrantees"]);
-}
-function parseGrantRegistrationPayload(grant) {
-  let parsed;
-  try {
-    parsed = JSON.parse(grant);
-  } catch {
-    return null;
-  }
-  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 (value["nonce"] !== void 0 && (typeof value["nonce"] !== "number" || !Number.isFinite(value["nonce"]))) {
-    return null;
-  }
-  return {
-    user: value["user"],
-    builder: value["builder"],
-    scopes: value["scopes"],
-    expiresAt: value["expiresAt"],
-    nonce: value["nonce"]
-  };
+  return isHexString(c["dataRegistry"]) && isHexString(c["dataPortabilityPermissions"]) && isHexString(c["dataPortabilityServer"]) && isHexString(c["dataPortabilityGrantees"]) && isHexString(c["dataPortabilityEscrow"]) && isHexString(c["feeRegistry"]);
 }
-function parseFileIds(fileIds) {
+function toUint256(value) {
   try {
-    const values = (fileIds ?? []).map((fileId) => BigInt(fileId));
-    return {
-      values,
-      display: values.map((fileId) => fileId.toString())
-    };
+    if (typeof value === "number" && !Number.isSafeInteger(value)) {
+      return null;
+    }
+    const big = typeof value === "bigint" ? value : BigInt(value);
+    if (big < 0n) return null;
+    return big;
   } catch {
     return null;
   }
 }
 async function verifyGrantRegistration(input) {
-  const payload = parseGrantRegistrationPayload(input.grant);
-  if (!payload) {
-    return {
-      valid: false,
-      error: "Grant must be JSON with scopes and expiresAt"
-    };
+  if (!Array.isArray(input.scopes) || input.scopes.length === 0) {
+    return { valid: false, error: "scopes must be a non-empty array" };
+  }
+  if (!input.scopes.every((scope) => typeof scope === "string")) {
+    return { valid: false, error: "scopes must contain only strings" };
   }
-  const fileIds = parseFileIds(input.fileIds);
-  if (!fileIds) {
-    return { valid: false, error: "fileIds must contain integer values" };
+  const grantVersion = toUint256(input.grantVersion);
+  if (grantVersion === null || grantVersion < 1n) {
+    return { valid: false, error: "grantVersion must be a uint256 >= 1" };
+  }
+  const expiresAt = toUint256(input.expiresAt);
+  if (expiresAt === null) {
+    return { valid: false, error: "expiresAt must be a non-negative uint256" };
   }
   let valid;
   try {
@@ -33318,8 +33311,9 @@ async function verifyGrantRegistration(input) {
       message: {
         grantorAddress: input.grantorAddress,
         granteeId: input.granteeId,
-        grant: input.grant,
-        fileIds: fileIds.values
+        scopes: input.scopes,
+        grantVersion,
+        expiresAt
       },
       signature: input.signature
     });
@@ -33330,26 +33324,269 @@ async function verifyGrantRegistration(input) {
     return { valid: false, error: "Grant signature does not match grantor" };
   }
   const nowSeconds = input.nowSeconds ?? Math.floor(Date.now() / 1e3);
-  if (payload.expiresAt > 0 && payload.expiresAt < nowSeconds) {
+  if (expiresAt > 0n && expiresAt < BigInt(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,
-    grant: input.grant,
-    payload,
-    fileIds: fileIds.display
+    scopes: input.scopes,
+    grantVersion: grantVersion.toString(),
+    expiresAt: expiresAt.toString()
   };
 }
 
-// src/protocol/scopes.ts
+// src/protocol/fee-registry.ts
+var import_viem18 = require("viem");
+var FEE_REGISTRY_ABI = (0, import_viem18.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
+  };
+}
+
+// src/protocol/escrow-deposit.ts
+var import_viem19 = require("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 (0, import_viem19.encodeFunctionData)({
+    abi: ESCROW_DEPOSIT_ABI,
+    functionName: "depositNative",
+    args: [input.account]
+  });
+}
+function encodeDepositTokenData(input) {
+  return (0, import_viem19.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
+var import_viem20 = require("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 (0, import_viem20.encodeFunctionData)({
+    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/data-file.ts
 var import_zod = require("zod");
+var DataFileEnvelopeSchema = import_zod.z.object({
+  $schema: import_zod.z.string().url().optional(),
+  version: import_zod.z.literal("1.0"),
+  scope: import_zod.z.string(),
+  schemaId: import_zod.z.string().optional(),
+  collectedAt: import_zod.z.string().datetime(),
+  data: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())
+});
+function createDataFileEnvelope(scope, collectedAt, data, schemaUrl, schemaId) {
+  return {
+    ...schemaUrl !== void 0 && { $schema: schemaUrl },
+    ...schemaId !== void 0 && { schemaId },
+    version: "1.0",
+    scope,
+    collectedAt,
+    data
+  };
+}
+var IngestResponseSchema = import_zod.z.object({
+  scope: import_zod.z.string(),
+  collectedAt: import_zod.z.string().datetime(),
+  status: import_zod.z.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/scopes.ts
+var import_zod2 = require("zod");
 var SEGMENT_RE = /^[a-z0-9][a-z0-9_]*$/;
-var ScopeSchema = import_zod.z.string().refine(
+var ScopeSchema = import_zod2.z.string().refine(
   (scope) => {
     const parts = scope.split(".");
     return parts.length >= 2 && parts.length <= 3 && parts.every((part) => SEGMENT_RE.test(part));
@@ -33390,32 +33627,6 @@ function scopeCoveredByGrant(requestedScope, grantedScopes) {
   );
 }
 
-// src/protocol/data-file.ts
-var import_zod2 = require("zod");
-var DataFileEnvelopeSchema = import_zod2.z.object({
-  $schema: import_zod2.z.string().url().optional(),
-  version: import_zod2.z.literal("1.0"),
-  scope: import_zod2.z.string(),
-  schemaId: import_zod2.z.string().optional(),
-  collectedAt: import_zod2.z.string().datetime(),
-  data: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown())
-});
-function createDataFileEnvelope(scope, collectedAt, data, schemaUrl, schemaId) {
-  return {
-    ...schemaUrl !== void 0 && { $schema: schemaUrl },
-    ...schemaId !== void 0 && { schemaId },
-    version: "1.0",
-    scope,
-    collectedAt,
-    data
-  };
-}
-var IngestResponseSchema = import_zod2.z.object({
-  scope: import_zod2.z.string(),
-  collectedAt: import_zod2.z.string().datetime(),
-  status: import_zod2.z.enum(["stored", "syncing"])
-});
-
 // src/protocol/gateway.ts
 function createGatewayClient(baseUrl) {
   const base = baseUrl.replace(/\/+$/, "");
@@ -33423,16 +33634,6 @@ 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;
@@ -33482,31 +33683,33 @@ function createGatewayClient(baseUrl) {
       }
       return unwrapEnvelope(res);
     },
-    async getFile(fileId) {
-      const res = await fetch(`${base}/v1/files/${fileId}`);
+    async getDataPoint(dataPointId) {
+      const res = await fetch(`${base}/v1/data/${dataPointId}`);
       if (res.status === 404) return null;
       if (!res.ok) {
         throw new Error(`Gateway error: ${res.status} ${res.statusText}`);
       }
-      return normalizeFileRecord(await unwrapEnvelope(res));
+      return unwrapEnvelope(res);
     },
-    async listFilesSince(owner, cursor, options) {
+    async listDataPointsByOwner(owner, cursor, options) {
       const params = new URLSearchParams({ user: owner });
       if (cursor !== null) {
         params.set("cursor", cursor);
       }
-      if (options?.includeDeleted) {
-        params.set("includeDeleted", "true");
+      if (options?.since) {
+        params.set("since", options.since);
+      }
+      if (options?.limit !== void 0) {
+        params.set("limit", String(options.limit));
       }
-      const res = await fetch(`${base}/v1/files?${params.toString()}`);
+      const res = await fetch(`${base}/v1/data?${params.toString()}`);
       if (!res.ok) {
         throw new Error(`Gateway error: ${res.status} ${res.statusText}`);
       }
       const envelope = await res.json();
-      const { pagination } = envelope;
-      const nextCursor = pagination?.hasMore === false ? null : pagination?.nextCursor ?? envelope.data.cursor ?? null;
+      const nextCursor = envelope.pagination?.hasMore === false ? null : envelope.pagination?.nextCursor ?? null;
       return {
-        files: envelope.data.files.map(normalizeFileRecord),
+        dataPoints: envelope.data.dataPoints,
         cursor: nextCursor
       };
     },
@@ -33548,8 +33751,8 @@ function createGatewayClient(baseUrl) {
         alreadyRegistered: false
       };
     },
-    async registerFile(params) {
-      const res = await fetch(`${base}/v1/files`, {
+    async registerBuilder(params) {
+      const res = await fetch(`${base}/v1/builders`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -33557,22 +33760,57 @@ function createGatewayClient(baseUrl) {
         },
         body: JSON.stringify({
           ownerAddress: params.ownerAddress,
-          url: params.url,
-          schemaId: params.schemaId
+          granteeAddress: params.granteeAddress,
+          publicKey: params.publicKey,
+          appUrl: params.appUrl
         })
       });
       if (res.status === 409) {
         const body2 = await res.json().catch(() => ({}));
         return {
-          fileId: getMutationId(body2, "fileId")
+          builderId: getMutationId(
+            body2,
+            "builderId"
+          ),
+          alreadyRegistered: true
         };
       }
       if (!res.ok) {
         throw new Error(`Gateway error: ${res.status} ${res.statusText}`);
       }
-      const body = await res.json();
+      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(() => ({}));
       return {
-        fileId: getMutationId(body, "fileId")
+        dataPointId: getMutationId(
+          body,
+          "dataPointId"
+        ),
+        expectedVersion: body.expectedVersion
       };
     },
     async createGrant(params) {
@@ -33585,8 +33823,9 @@ function createGatewayClient(baseUrl) {
         body: JSON.stringify({
           grantorAddress: params.grantorAddress,
           granteeId: params.granteeId,
-          grant: params.grant,
-          fileIds: params.fileIds
+          scopes: params.scopes,
+          grantVersion: params.grantVersion,
+          expiresAt: params.expiresAt
         })
       });
       if (res.status === 409) {
@@ -33611,7 +33850,8 @@ function createGatewayClient(baseUrl) {
           Authorization: `Web3Signed ${params.signature}`
         },
         body: JSON.stringify({
-          grantorAddress: params.grantorAddress
+          grantorAddress: params.grantorAddress,
+          grantVersion: params.grantVersion
         })
       });
       if (res.status === 409) return;
@@ -33619,21 +33859,62 @@ function createGatewayClient(baseUrl) {
         throw new Error(`Gateway error: ${res.status} ${res.statusText}`);
       }
     },
-    async deleteFile(params) {
-      const res = await fetch(`${base}/v1/files/${params.fileId}`, {
-        method: "DELETE",
+    async getEscrowBalance(account) {
+      const res = await fetch(`${base}/v1/escrow/balance?account=${account}`);
+      if (!res.ok) {
+        throw new Error(`Gateway error: ${res.status} ${res.statusText}`);
+      }
+      return await res.json();
+    },
+    async submitEscrowDeposit(params) {
+      const res = await fetch(`${base}/v1/escrow/deposit`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ txHash: params.txHash })
+      });
+      if (res.status !== 200 && res.status !== 202) {
+        throw new Error(`Gateway error: ${res.status} ${res.statusText}`);
+      }
+      return await 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;
+      }
+      const res = await fetch(`${base}/v1/escrow/pay`, {
+        method: "POST",
         headers: {
           "Content-Type": "application/json",
           Authorization: `Web3Signed ${params.signature}`
         },
-        body: JSON.stringify({
-          ownerAddress: params.ownerAddress
-        })
+        body: JSON.stringify(body)
       });
-      if (res.status === 409) return;
       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 ?? {})
+      });
+      if (!res.ok) {
+        throw new Error(`Gateway error: ${res.status} ${res.statusText}`);
+      }
+      return await res.json();
     }
   };
 }
@@ -33657,7 +33938,7 @@ function genericPaymentDomain(chainId, escrowContract) {
     verifyingContract: escrowContract
   };
 }
-var ESCROW_DEPOSIT_ABI = [
+var ESCROW_DEPOSIT_ABI2 = [
   {
     type: "function",
     name: "depositNative",
@@ -33815,6 +34096,7 @@ async function parsePSError(response) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCOUNT_PERSONAL_SERVER_REGISTRATION_INTENT,
+  ADD_DATA_TYPES,
   AccountPersonalServerLiteOwnerBindingError,
   AccountPersonalServerRegistrationError,
   BUILDER_REGISTRATION_TYPES,
@@ -33824,13 +34106,14 @@ async function parsePSError(response) {
   CallbackStorage,
   ContractFactory,
   ContractNotFoundError,
+  DATA_REGISTRY_STATUS_ABI,
   DataFileEnvelopeSchema,
+  DataPointStatus,
   DropboxStorage,
   ECIESError,
   ESCROW_DEPOSIT_ABI,
   ExpiredTokenError,
-  FILE_DELETION_TYPES,
-  FILE_REGISTRATION_TYPES,
+  FEE_REGISTRY_ABI,
   GENERIC_PAYMENT_TYPES,
   GRANT_REGISTRATION_TYPES,
   GRANT_REVOCATION_TYPES,
@@ -33843,6 +34126,7 @@ async function parsePSError(response) {
   MASTER_KEY_MESSAGE,
   MissingAuthError,
   NATIVE_ASSET_ADDRESS,
+  NATIVE_VANA_ASSET,
   NetworkError,
   NodeECIESProvider,
   NodePlatformAdapter,
@@ -33860,6 +34144,8 @@ async function parsePSError(response) {
   PersonalServerError,
   PinataStorage,
   R2Storage,
+  RECORD_DATA_ACCESS_TYPES,
+  REGISTRATION_KIND_FOR_OP,
   ReadOnlyError,
   RelayerError,
   SERVER_REGISTRATION_TYPES,
@@ -33874,10 +34160,15 @@ async function parsePSError(response) {
   VanaError,
   VanaStorage,
   assertValidPkceVerifier,
+  buildDepositNativeRequest,
+  buildDepositTokenRequest,
+  buildMarkDataPointUnavailableRequest,
+  buildPersonalServerDataReadRequest,
   buildPersonalServerLiteOwnerBindingMessage,
   buildPersonalServerLiteOwnerBindingSignature,
   buildPersonalServerRegistrationSignature,
   buildPersonalServerRegistrationTypedData,
+  buildSetDataPointStatusRequest,
   buildWeb3SignedHeader,
   builderRegistrationDomain,
   chains,
@@ -33896,14 +34187,19 @@ async function parsePSError(response) {
   createVanaStorageProvider,
   createViemPersonalServerLiteOwnerBindingSigner,
   createViemPersonalServerRegistrationSigner,
+  dataRegistryContractAddress,
+  dataRegistryDomain,
   decryptWithPassword,
   deriveMasterKey,
   deriveScopeKey,
   deserializeECIES,
   detectPlatform,
+  encodeDepositNativeData,
+  encodeDepositTokenData,
+  encodeSetDataPointStatusData,
   encryptWithPassword,
-  fileDeletionDomain,
-  fileRegistrationDomain,
+  escrowContractAddress,
+  escrowPaymentDomain,
   generatePkceVerifier,
   genericPaymentDomain,
   getAbi,
@@ -33912,6 +34208,8 @@ async function parsePSError(response) {
   getContractAddress,
   getContractController,
   getContractInfo,
+  getFee,
+  getOpFee,
   getPlatformCapabilities,
   getServiceEndpoints,
   grantRegistrationDomain,
@@ -33923,11 +34221,12 @@ async function parsePSError(response) {
   moksha,
   mokshaServices,
   mokshaTestnet,
-  parseGrantRegistrationPayload,
   parsePSError,
   parseScope,
   parseWeb3SignedHeader,
+  personalServerDataReadPath,
   personalServerRegistrationDomain,
+  readPersonalServerData,
   recoverServerOwner,
   registerPersonalServerSignature,
   scopeCoveredByGrant,