@opendatalabs/vana-sdk 3.17.0 → 3.18.0

package/dist/protocol/data-point-deletion.cjs

@@ -0,0 +1,220 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var data_point_deletion_exports = {};
+__export(data_point_deletion_exports, {
+  TOMBSTONE_DATA_HASH: () => TOMBSTONE_DATA_HASH,
+  TOMBSTONE_DATA_HASH_PREIMAGE: () => TOMBSTONE_DATA_HASH_PREIMAGE,
+  TOMBSTONE_METADATA_HASH: () => TOMBSTONE_METADATA_HASH,
+  TOMBSTONE_METADATA_HASH_PREIMAGE: () => TOMBSTONE_METADATA_HASH_PREIMAGE,
+  buildDataPointDeletionSignature: () => buildDataPointDeletionSignature,
+  buildDataPointDeletionTypedData: () => buildDataPointDeletionTypedData,
+  computeTombstoneHash: () => computeTombstoneHash,
+  createViemDataPointDeletionSigner: () => createViemDataPointDeletionSigner,
+  deleteDataPoint: () => deleteDataPoint,
+  isDataPointTombstone: () => isDataPointTombstone,
+  isTombstoneHashes: () => isTombstoneHashes,
+  tombstoneDeletedAt: () => tombstoneDeletedAt
+});
+module.exports = __toCommonJS(data_point_deletion_exports);
+var import_viem = require("viem");
+var import_errors = require("../errors");
+var import_response_body = require("../utils/response-body");
+var import_eip712 = require("./eip712");
+var import_lineage = require("./lineage");
+const TOMBSTONE_DATA_HASH_PREIMAGE = "vana.data-point.tombstone.v1";
+const TOMBSTONE_METADATA_HASH_PREIMAGE = "vana.data-point.tombstone.metadata.v1";
+const TOMBSTONE_DATA_HASH = "0x30c45ee72fe56d1927701316925ab7ceacd3b6f9267061735d59396f075c6222";
+const TOMBSTONE_METADATA_HASH = "0xc5255a141acd6a2ae55971b62c0a85977c2511989dc114ad2abc2b7644f57d90";
+function computeTombstoneHash(preimage) {
+  return (0, import_viem.keccak256)((0, import_viem.stringToBytes)(preimage));
+}
+function isTombstoneHashes(dataHash, metadataHash) {
+  return typeof dataHash === "string" && typeof metadataHash === "string" && dataHash.toLowerCase() === TOMBSTONE_DATA_HASH && metadataHash.toLowerCase() === TOMBSTONE_METADATA_HASH;
+}
+function isDataPointTombstone(value) {
+  if (!(0, import_response_body.isPlainObject)(value)) return false;
+  if (typeof value["deletedAt"] === "string") return true;
+  return isTombstoneHashes(
+    typeof value["dataHash"] === "string" ? value["dataHash"] : void 0,
+    typeof value["metadataHash"] === "string" ? value["metadataHash"] : void 0
+  );
+}
+function tombstoneDeletedAt(value) {
+  if (!(0, import_response_body.isPlainObject)(value)) return null;
+  const deletedAt = value["deletedAt"];
+  return typeof deletedAt === "string" ? deletedAt : null;
+}
+function assertAddress(value, name) {
+  if (!(0, import_viem.isAddress)(value)) {
+    throw new Error(`${name} must be a valid EVM address`);
+  }
+}
+function assertUint256(value, name) {
+  if (value < 0n || value > import_viem.maxUint256) {
+    throw new Error(`${name} must fit in uint256, got ${value}`);
+  }
+}
+function getAccountAddress(account) {
+  if (!account) return void 0;
+  return typeof account === "string" ? account : account.address;
+}
+function isDataPointDeletionSigner(source) {
+  return "address" in source && typeof source.signTypedData === "function";
+}
+function createViemDataPointDeletionSigner(source, options = {}) {
+  if (isDataPointDeletionSigner(source)) {
+    return source;
+  }
+  const accountAddress = getAccountAddress(options.account) ?? getAccountAddress(source.account);
+  if (accountAddress) {
+    return {
+      address: accountAddress,
+      signTypedData: (typedData) => source.signTypedData({
+        ...typedData,
+        account: options.account ?? source.account ?? accountAddress
+      })
+    };
+  }
+  throw new Error(
+    "Viem wallet client requires an account option or account property"
+  );
+}
+function buildDataPointDeletionTypedData(input) {
+  assertAddress(input.ownerAddress, "ownerAddress");
+  if (input.scope.length === 0) {
+    throw new Error("scope must be a non-empty string");
+  }
+  if (input.expectedVersion <= 0n) {
+    throw new Error("expectedVersion must be a positive version number");
+  }
+  assertUint256(input.expectedVersion, "expectedVersion");
+  return {
+    domain: (0, import_eip712.dataRegistryDomain)(input.config),
+    types: import_eip712.ADD_DATA_TYPES,
+    primaryType: "AddData",
+    message: {
+      ownerAddress: input.ownerAddress,
+      scope: input.scope,
+      dataHash: TOMBSTONE_DATA_HASH,
+      metadataHash: TOMBSTONE_METADATA_HASH,
+      expectedVersion: input.expectedVersion
+    }
+  };
+}
+async function buildDataPointDeletionSignature(input) {
+  const typedData = buildDataPointDeletionTypedData({
+    ownerAddress: input.signer.address,
+    scope: input.scope,
+    expectedVersion: input.expectedVersion,
+    config: input.config
+  });
+  const signature = await input.signer.signTypedData(typedData);
+  return {
+    signature,
+    signerAddress: input.signer.address,
+    typedData
+  };
+}
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+function parseExpectedVersion(value) {
+  if (typeof value !== "string" || !/^\d+$/.test(value)) {
+    throw new Error(
+      `Gateway returned a malformed expectedVersion: ${JSON.stringify(value)}`
+    );
+  }
+  const parsed = BigInt(value);
+  assertUint256(parsed, "Gateway expectedVersion");
+  return parsed;
+}
+async function deleteDataPoint(input) {
+  const ownerAddress = input.signer.address;
+  const dataPointId = (0, import_lineage.deriveDataPointId)(ownerAddress, input.scope);
+  let currentVersion = input.currentVersion;
+  if (currentVersion === void 0) {
+    const record = await input.gateway.getDataPoint(dataPointId);
+    if (record === null) {
+      throw new import_errors.DataPointNotFoundError(
+        `No data point registered for scope '${input.scope}' owned by ${ownerAddress}`,
+        { dataPointId, scope: input.scope, ownerAddress }
+      );
+    }
+    if (isDataPointTombstone(record)) {
+      throw new import_errors.DataPointDeletedError(
+        `Data point ${dataPointId} (scope '${input.scope}') is already deleted`,
+        {
+          dataPointId,
+          scope: input.scope,
+          ownerAddress,
+          deletedAt: tombstoneDeletedAt(record)
+        }
+      );
+    }
+    currentVersion = parseExpectedVersion(record.expectedVersion);
+  }
+  if (currentVersion < 0n || currentVersion >= import_viem.maxUint256) {
+    throw new Error(
+      `currentVersion ${currentVersion} cannot be incremented to a uint256 tombstone version`
+    );
+  }
+  const tombstoneVersion = currentVersion + 1n;
+  const signed = await buildDataPointDeletionSignature({
+    signer: input.signer,
+    scope: input.scope,
+    expectedVersion: tombstoneVersion,
+    config: input.config
+  });
+  const tombstone = await input.gateway.deleteDataPoint({
+    ownerAddress,
+    scope: input.scope,
+    expectedVersion: tombstoneVersion.toString(),
+    signature: signed.signature
+  });
+  const base = {
+    dataPointId,
+    ownerAddress,
+    scope: input.scope,
+    version: tombstoneVersion.toString(),
+    signature: signed.signature,
+    tombstone
+  };
+  try {
+    const storage = await input.storage.deleteScope(ownerAddress, input.scope);
+    return { ...base, status: "deleted", storage };
+  } catch (cause) {
+    return { ...base, status: "partial", storageError: toError(cause) };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TOMBSTONE_DATA_HASH,
+  TOMBSTONE_DATA_HASH_PREIMAGE,
+  TOMBSTONE_METADATA_HASH,
+  TOMBSTONE_METADATA_HASH_PREIMAGE,
+  buildDataPointDeletionSignature,
+  buildDataPointDeletionTypedData,
+  computeTombstoneHash,
+  createViemDataPointDeletionSigner,
+  deleteDataPoint,
+  isDataPointTombstone,
+  isTombstoneHashes,
+  tombstoneDeletedAt
+});
+//# sourceMappingURL=data-point-deletion.cjs.map

package/dist/protocol/data-point-deletion.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/protocol/data-point-deletion.ts"],"sourcesContent":["/**\n * Data point deletion (tombstone) helpers for DataRegistryV2.\n *\n * A deletion is an owner-signed `AddData` for version `current + 1` whose\n * `dataHash` / `metadataHash` are the protocol-wide tombstone constants below.\n * The gateway records the tombstone version and marks the row `deletedAt`;\n * the encrypted blobs in vana-storage are removed afterwards as a best-effort\n * follow-up. The tombstone is the durable fact; blob removal is cleanup.\n *\n * The typed-data definition is exactly {@link ADD_DATA_TYPES} against\n * {@link dataRegistryDomain} -- the same signature the registration path uses,\n * so a verifier cannot tell a deletion apart from a registration except by\n * the hashes.\n *\n * @category Protocol\n */\n\nimport {\n  isAddress,\n  keccak256,\n  maxUint256,\n  stringToBytes,\n  type Account,\n  type Address,\n  type Hex,\n  type TypedDataDefinition,\n} from \"viem\";\nimport { DataPointDeletedError, DataPointNotFoundError } from \"../errors\";\nimport { isPlainObject } from \"../utils/response-body\";\nimport {\n  ADD_DATA_TYPES,\n  dataRegistryDomain,\n  type AddDataMessage,\n  type DataPortabilityGatewayConfig,\n} from \"./eip712\";\nimport type {\n  DeleteDataPointResult as GatewayDeleteDataPointResult,\n  GatewayClient,\n} from \"./gateway\";\nimport { deriveDataPointId } from \"./lineage\";\n\n/** UTF-8 preimage of {@link TOMBSTONE_DATA_HASH}. */\nexport const TOMBSTONE_DATA_HASH_PREIMAGE = \"vana.data-point.tombstone.v1\";\n/** UTF-8 preimage of {@link TOMBSTONE_METADATA_HASH}. */\nexport const TOMBSTONE_METADATA_HASH_PREIMAGE =\n  \"vana.data-point.tombstone.metadata.v1\";\n\n/**\n * `keccak256(utf8(\"vana.data-point.tombstone.v1\"))` -- the `dataHash` a\n * deletion AddData carries. Single source of truth shared with the gateway\n * and Personal Server; never change without a new `.vN` preimage.\n */\nexport const TOMBSTONE_DATA_HASH =\n  \"0x30c45ee72fe56d1927701316925ab7ceacd3b6f9267061735d59396f075c6222\" as const;\n\n/**\n * `keccak256(utf8(\"vana.data-point.tombstone.metadata.v1\"))` -- the\n * `metadataHash` a deletion AddData carries.\n */\nexport const TOMBSTONE_METADATA_HASH =\n  \"0xc5255a141acd6a2ae55971b62c0a85977c2511989dc114ad2abc2b7644f57d90\" as const;\n\n/**\n * Recompute a tombstone hash from its preimage. Exposed so tests and\n * downstream services can prove the pinned constants match the contract.\n */\nexport function computeTombstoneHash(preimage: string): Hex {\n  return keccak256(stringToBytes(preimage));\n}\n\n/** True when the pair of hashes is exactly the tombstone pair. */\nexport function isTombstoneHashes(\n  dataHash: string | undefined,\n  metadataHash: string | undefined,\n): boolean {\n  return (\n    typeof dataHash === \"string\" &&\n    typeof metadataHash === \"string\" &&\n    dataHash.toLowerCase() === TOMBSTONE_DATA_HASH &&\n    metadataHash.toLowerCase() === TOMBSTONE_METADATA_HASH\n  );\n}\n\n/**\n * Detect a deleted data point from any record-shaped value: a non-null\n * `deletedAt`, or the tombstone hash pair. Accepts `unknown` so read\n * helpers can run it on a raw JSON body before trusting the payload.\n */\nexport function isDataPointTombstone(value: unknown): boolean {\n  if (!isPlainObject(value)) return false;\n  if (typeof value[\"deletedAt\"] === \"string\") return true;\n  return isTombstoneHashes(\n    typeof value[\"dataHash\"] === \"string\" ? value[\"dataHash\"] : undefined,\n    typeof value[\"metadataHash\"] === \"string\"\n      ? value[\"metadataHash\"]\n      : undefined,\n  );\n}\n\n/**\n * Read `deletedAt` off any value a gateway or Personal Server might hand\n * back (a record, an error body, `null`, an array, ...). Returns `null`\n * unless it is a string, so every `DataPointDeletedError` carries the same\n * `deletedAt` semantics regardless of which read path raised it.\n */\nexport function tombstoneDeletedAt(value: unknown): string | null {\n  if (!isPlainObject(value)) return null;\n  const deletedAt = value[\"deletedAt\"];\n  return typeof deletedAt === \"string\" ? deletedAt : null;\n}\n\nexport type DataPointDeletionTypedData = TypedDataDefinition<\n  typeof ADD_DATA_TYPES,\n  \"AddData\"\n> & {\n  message: AddDataMessage;\n};\n\nexport interface DataPointDeletionSigner {\n  /** The data point owner. Must match `AddData.ownerAddress`. */\n  address: Address;\n  signTypedData(typedData: DataPointDeletionTypedData): Promise<Hex> | Hex;\n}\n\nexport interface ViemDataPointDeletionWalletClient {\n  account?: Account | Address | null;\n  signTypedData(\n    typedData: DataPointDeletionTypedData & { account?: Account | Address },\n  ): Promise<Hex>;\n}\n\nexport type ViemDataPointDeletionSignerSource =\n  | DataPointDeletionSigner\n  | ViemDataPointDeletionWalletClient;\n\nexport interface BuildDataPointDeletionTypedDataInput {\n  ownerAddress: Address;\n  scope: string;\n  /**\n   * The version the tombstone is written at -- `current + 1`. This is the\n   * `AddData.expectedVersion` field; the gateway rejects with 409 unless it\n   * is strictly greater than the stored version.\n   */\n  expectedVersion: bigint;\n  config: DataPortabilityGatewayConfig;\n}\n\nexport interface BuildDataPointDeletionSignatureInput {\n  signer: DataPointDeletionSigner;\n  scope: string;\n  /** See {@link BuildDataPointDeletionTypedDataInput.expectedVersion}. */\n  expectedVersion: bigint;\n  config: DataPortabilityGatewayConfig;\n}\n\nexport interface DataPointDeletionSignature {\n  signature: Hex;\n  signerAddress: Address;\n  typedData: DataPointDeletionTypedData;\n}\n\nfunction assertAddress(value: string, name: string): void {\n  if (!isAddress(value)) {\n    throw new Error(`${name} must be a valid EVM address`);\n  }\n}\n\n// `AddData.expectedVersion` is a uint256 on the contract. A bigint has no\n// such bound, so every version the SDK signs or increments is checked here\n// rather than trusting the TypeScript type.\nfunction assertUint256(value: bigint, name: string): void {\n  if (value < 0n || value > maxUint256) {\n    throw new Error(`${name} must fit in uint256, got ${value}`);\n  }\n}\n\nfunction getAccountAddress(\n  account: Account | Address | null | undefined,\n): Address | undefined {\n  if (!account) return undefined;\n  return typeof account === \"string\" ? account : account.address;\n}\n\nfunction isDataPointDeletionSigner(\n  source: ViemDataPointDeletionSignerSource,\n): source is DataPointDeletionSigner {\n  return \"address\" in source && typeof source.signTypedData === \"function\";\n}\n\n/**\n * Adapt a viem local account or wallet client to\n * {@link DataPointDeletionSigner}. Mirrors\n * `createViemPersonalServerRegistrationSigner`.\n */\nexport function createViemDataPointDeletionSigner(\n  source: ViemDataPointDeletionSignerSource,\n  options: { account?: Account | Address } = {},\n): DataPointDeletionSigner {\n  if (isDataPointDeletionSigner(source)) {\n    return source;\n  }\n\n  const accountAddress =\n    getAccountAddress(options.account) ?? getAccountAddress(source.account);\n\n  if (accountAddress) {\n    return {\n      address: accountAddress,\n      signTypedData: (typedData) =>\n        source.signTypedData({\n          ...typedData,\n          account: options.account ?? source.account ?? accountAddress,\n        }),\n    };\n  }\n\n  throw new Error(\n    \"Viem wallet client requires an account option or account property\",\n  );\n}\n\n/**\n * Build the exact `AddData` typed data a deletion signs: the tombstone hash\n * pair at `expectedVersion`, against the DataRegistryV2 domain.\n */\nexport function buildDataPointDeletionTypedData(\n  input: BuildDataPointDeletionTypedDataInput,\n): DataPointDeletionTypedData {\n  assertAddress(input.ownerAddress, \"ownerAddress\");\n  if (input.scope.length === 0) {\n    throw new Error(\"scope must be a non-empty string\");\n  }\n  if (input.expectedVersion <= 0n) {\n    throw new Error(\"expectedVersion must be a positive version number\");\n  }\n  assertUint256(input.expectedVersion, \"expectedVersion\");\n\n  return {\n    domain: dataRegistryDomain(input.config),\n    types: ADD_DATA_TYPES,\n    primaryType: \"AddData\",\n    message: {\n      ownerAddress: input.ownerAddress,\n      scope: input.scope,\n      dataHash: TOMBSTONE_DATA_HASH,\n      metadataHash: TOMBSTONE_METADATA_HASH,\n      expectedVersion: input.expectedVersion,\n    },\n  };\n}\n\n/** Sign a deletion `AddData` with the owner's signer. */\nexport async function buildDataPointDeletionSignature(\n  input: BuildDataPointDeletionSignatureInput,\n): Promise<DataPointDeletionSignature> {\n  const typedData = buildDataPointDeletionTypedData({\n    ownerAddress: input.signer.address,\n    scope: input.scope,\n    expectedVersion: input.expectedVersion,\n    config: input.config,\n  });\n  const signature = await input.signer.signTypedData(typedData);\n\n  return {\n    signature,\n    signerAddress: input.signer.address,\n    typedData,\n  };\n}\n\n/**\n * Outcome of a scope-wide blob delete. `VanaStorage.deleteScope` returns a\n * superset of this shape.\n */\nexport interface DataPointBlobDeleteResult {\n  count: number;\n  totalBytes: number;\n}\n\n/**\n * The storage half of a deletion -- structurally satisfied by `VanaStorage`.\n * Removes every version's blob under `(owner, scope)`.\n */\nexport interface DataPointBlobStore {\n  deleteScope(\n    ownerAddress: Address,\n    scope: string,\n  ): Promise<DataPointBlobDeleteResult>;\n}\n\nexport interface DeleteDataPointInput {\n  /** Gateway client -- only `getDataPoint` and `deleteDataPoint` are used. */\n  gateway: Pick<GatewayClient, \"getDataPoint\" | \"deleteDataPoint\">;\n  /** Blob store for the best-effort cleanup after the tombstone lands. */\n  storage: DataPointBlobStore;\n  /** Owner signer. `signer.address` is the data point owner. */\n  signer: DataPointDeletionSigner;\n  scope: string;\n  config: DataPortabilityGatewayConfig;\n  /**\n   * Skip the gateway lookup and treat this as the current version. Use when\n   * the caller already holds a fresh `DataPointRecord.expectedVersion`;\n   * omit to let the SDK fetch it.\n   */\n  currentVersion?: bigint;\n}\n\ninterface DataPointDeletionBase {\n  dataPointId: Hex;\n  ownerAddress: Address;\n  scope: string;\n  /** Decimal-string uint256 of the tombstone version (`current + 1`). */\n  version: string;\n  signature: Hex;\n  /** The gateway's 200 body for the tombstone. */\n  tombstone: GatewayDeleteDataPointResult;\n}\n\n/** Both the gateway tombstone and the blob cleanup succeeded. */\nexport interface DataPointDeletedResult extends DataPointDeletionBase {\n  status: \"deleted\";\n  storage: DataPointBlobDeleteResult;\n}\n\n/**\n * The gateway recorded the tombstone (durable, the data point is deleted)\n * but the blob cleanup failed. Retry `storage.deleteScope(owner, scope)`\n * later; the tombstone does not need to be re-signed.\n */\nexport interface DataPointDeletionPartialResult extends DataPointDeletionBase {\n  status: \"partial\";\n  storageError: Error;\n}\n\nexport type DataPointDeletionResult =\n  | DataPointDeletedResult\n  | DataPointDeletionPartialResult;\n\nfunction toError(value: unknown): Error {\n  return value instanceof Error ? value : new Error(String(value));\n}\n\n// The wire type says decimal-string uint256, but the type system cannot\n// enforce that at runtime: refuse anything else here rather than letting\n// `BigInt()` throw a bare SyntaxError (or, worse, sign for a bogus version).\nfunction parseExpectedVersion(value: unknown): bigint {\n  if (typeof value !== \"string\" || !/^\\d+$/.test(value)) {\n    throw new Error(\n      `Gateway returned a malformed expectedVersion: ${JSON.stringify(value)}`,\n    );\n  }\n  const parsed = BigInt(value);\n  assertUint256(parsed, \"Gateway expectedVersion\");\n  return parsed;\n}\n\n/**\n * Delete a data point end to end. Symmetric with `registerDataPoint`.\n *\n * Order, deliberately:\n *   1. fetch the current version from the gateway (unless supplied),\n *   2. sign the tombstone `AddData` for `current + 1`,\n *   3. `DELETE /v1/data/:dataPointId` on the gateway,\n *   4. delete every blob under `(owner, scope)` in vana-storage.\n *\n * Steps 1-3 throw on failure ({@link DataPointNotFoundError},\n * {@link DataPointDeletedError}, `DataPointVersionConflictError`, or a\n * generic gateway error). A step-4 failure does NOT throw: the tombstone is\n * already the durable fact, so the result comes back with\n * `status: \"partial\"` and the storage error attached.\n */\nexport async function deleteDataPoint(\n  input: DeleteDataPointInput,\n): Promise<DataPointDeletionResult> {\n  const ownerAddress = input.signer.address;\n  const dataPointId = deriveDataPointId(ownerAddress, input.scope);\n\n  let currentVersion = input.currentVersion;\n  if (currentVersion === undefined) {\n    const record = await input.gateway.getDataPoint(dataPointId);\n    if (record === null) {\n      throw new DataPointNotFoundError(\n        `No data point registered for scope '${input.scope}' owned by ${ownerAddress}`,\n        { dataPointId, scope: input.scope, ownerAddress },\n      );\n    }\n    if (isDataPointTombstone(record)) {\n      throw new DataPointDeletedError(\n        `Data point ${dataPointId} (scope '${input.scope}') is already deleted`,\n        {\n          dataPointId,\n          scope: input.scope,\n          ownerAddress,\n          deletedAt: tombstoneDeletedAt(record),\n        },\n      );\n    }\n    currentVersion = parseExpectedVersion(record.expectedVersion);\n  }\n\n  // Whichever source supplied it, `current + 1` must itself be a uint256:\n  // a negative current version would sign for 0 or wrap, and\n  // 2^256 - 1 cannot be incremented at all.\n  if (currentVersion < 0n || currentVersion >= maxUint256) {\n    throw new Error(\n      `currentVersion ${currentVersion} cannot be incremented to a uint256 tombstone version`,\n    );\n  }\n  const tombstoneVersion = currentVersion + 1n;\n  const signed = await buildDataPointDeletionSignature({\n    signer: input.signer,\n    scope: input.scope,\n    expectedVersion: tombstoneVersion,\n    config: input.config,\n  });\n\n  const tombstone = await input.gateway.deleteDataPoint({\n    ownerAddress,\n    scope: input.scope,\n    expectedVersion: tombstoneVersion.toString(),\n    signature: signed.signature,\n  });\n\n  const base: DataPointDeletionBase = {\n    dataPointId,\n    ownerAddress,\n    scope: input.scope,\n    version: tombstoneVersion.toString(),\n    signature: signed.signature,\n    tombstone,\n  };\n\n  try {\n    const storage = await input.storage.deleteScope(ownerAddress, input.scope);\n    return { ...base, status: \"deleted\", storage };\n  } catch (cause) {\n    return { ...base, status: \"partial\", storageError: toError(cause) };\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/protocol/data-point-deletion.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Data point deletion (tombstone) helpers for DataRegistryV2.
+ *
+ * A deletion is an owner-signed `AddData` for version `current + 1` whose
+ * `dataHash` / `metadataHash` are the protocol-wide tombstone constants below.
+ * The gateway records the tombstone version and marks the row `deletedAt`;
+ * the encrypted blobs in vana-storage are removed afterwards as a best-effort
+ * follow-up. The tombstone is the durable fact; blob removal is cleanup.
+ *
+ * The typed-data definition is exactly {@link ADD_DATA_TYPES} against
+ * {@link dataRegistryDomain} -- the same signature the registration path uses,
+ * so a verifier cannot tell a deletion apart from a registration except by
+ * the hashes.
+ *
+ * @category Protocol
+ */
+import { type Account, type Address, type Hex, type TypedDataDefinition } from "viem";
+import { ADD_DATA_TYPES, type AddDataMessage, type DataPortabilityGatewayConfig } from "./eip712.js";
+import type { DeleteDataPointResult as GatewayDeleteDataPointResult, GatewayClient } from "./gateway.js";
+/** UTF-8 preimage of {@link TOMBSTONE_DATA_HASH}. */
+export declare const TOMBSTONE_DATA_HASH_PREIMAGE = "vana.data-point.tombstone.v1";
+/** UTF-8 preimage of {@link TOMBSTONE_METADATA_HASH}. */
+export declare const TOMBSTONE_METADATA_HASH_PREIMAGE = "vana.data-point.tombstone.metadata.v1";
+/**
+ * `keccak256(utf8("vana.data-point.tombstone.v1"))` -- the `dataHash` a
+ * deletion AddData carries. Single source of truth shared with the gateway
+ * and Personal Server; never change without a new `.vN` preimage.
+ */
+export declare const TOMBSTONE_DATA_HASH: "0x30c45ee72fe56d1927701316925ab7ceacd3b6f9267061735d59396f075c6222";
+/**
+ * `keccak256(utf8("vana.data-point.tombstone.metadata.v1"))` -- the
+ * `metadataHash` a deletion AddData carries.
+ */
+export declare const TOMBSTONE_METADATA_HASH: "0xc5255a141acd6a2ae55971b62c0a85977c2511989dc114ad2abc2b7644f57d90";
+/**
+ * Recompute a tombstone hash from its preimage. Exposed so tests and
+ * downstream services can prove the pinned constants match the contract.
+ */
+export declare function computeTombstoneHash(preimage: string): Hex;
+/** True when the pair of hashes is exactly the tombstone pair. */
+export declare function isTombstoneHashes(dataHash: string | undefined, metadataHash: string | undefined): boolean;
+/**
+ * Detect a deleted data point from any record-shaped value: a non-null
+ * `deletedAt`, or the tombstone hash pair. Accepts `unknown` so read
+ * helpers can run it on a raw JSON body before trusting the payload.
+ */
+export declare function isDataPointTombstone(value: unknown): boolean;
+/**
+ * Read `deletedAt` off any value a gateway or Personal Server might hand
+ * back (a record, an error body, `null`, an array, ...). Returns `null`
+ * unless it is a string, so every `DataPointDeletedError` carries the same
+ * `deletedAt` semantics regardless of which read path raised it.
+ */
+export declare function tombstoneDeletedAt(value: unknown): string | null;
+export type DataPointDeletionTypedData = TypedDataDefinition<typeof ADD_DATA_TYPES, "AddData"> & {
+    message: AddDataMessage;
+};
+export interface DataPointDeletionSigner {
+    /** The data point owner. Must match `AddData.ownerAddress`. */
+    address: Address;
+    signTypedData(typedData: DataPointDeletionTypedData): Promise<Hex> | Hex;
+}
+export interface ViemDataPointDeletionWalletClient {
+    account?: Account | Address | null;
+    signTypedData(typedData: DataPointDeletionTypedData & {
+        account?: Account | Address;
+    }): Promise<Hex>;
+}
+export type ViemDataPointDeletionSignerSource = DataPointDeletionSigner | ViemDataPointDeletionWalletClient;
+export interface BuildDataPointDeletionTypedDataInput {
+    ownerAddress: Address;
+    scope: string;
+    /**
+     * The version the tombstone is written at -- `current + 1`. This is the
+     * `AddData.expectedVersion` field; the gateway rejects with 409 unless it
+     * is strictly greater than the stored version.
+     */
+    expectedVersion: bigint;
+    config: DataPortabilityGatewayConfig;
+}
+export interface BuildDataPointDeletionSignatureInput {
+    signer: DataPointDeletionSigner;
+    scope: string;
+    /** See {@link BuildDataPointDeletionTypedDataInput.expectedVersion}. */
+    expectedVersion: bigint;
+    config: DataPortabilityGatewayConfig;
+}
+export interface DataPointDeletionSignature {
+    signature: Hex;
+    signerAddress: Address;
+    typedData: DataPointDeletionTypedData;
+}
+/**
+ * Adapt a viem local account or wallet client to
+ * {@link DataPointDeletionSigner}. Mirrors
+ * `createViemPersonalServerRegistrationSigner`.
+ */
+export declare function createViemDataPointDeletionSigner(source: ViemDataPointDeletionSignerSource, options?: {
+    account?: Account | Address;
+}): DataPointDeletionSigner;
+/**
+ * Build the exact `AddData` typed data a deletion signs: the tombstone hash
+ * pair at `expectedVersion`, against the DataRegistryV2 domain.
+ */
+export declare function buildDataPointDeletionTypedData(input: BuildDataPointDeletionTypedDataInput): DataPointDeletionTypedData;
+/** Sign a deletion `AddData` with the owner's signer. */
+export declare function buildDataPointDeletionSignature(input: BuildDataPointDeletionSignatureInput): Promise<DataPointDeletionSignature>;
+/**
+ * Outcome of a scope-wide blob delete. `VanaStorage.deleteScope` returns a
+ * superset of this shape.
+ */
+export interface DataPointBlobDeleteResult {
+    count: number;
+    totalBytes: number;
+}
+/**
+ * The storage half of a deletion -- structurally satisfied by `VanaStorage`.
+ * Removes every version's blob under `(owner, scope)`.
+ */
+export interface DataPointBlobStore {
+    deleteScope(ownerAddress: Address, scope: string): Promise<DataPointBlobDeleteResult>;
+}
+export interface DeleteDataPointInput {
+    /** Gateway client -- only `getDataPoint` and `deleteDataPoint` are used. */
+    gateway: Pick<GatewayClient, "getDataPoint" | "deleteDataPoint">;
+    /** Blob store for the best-effort cleanup after the tombstone lands. */
+    storage: DataPointBlobStore;
+    /** Owner signer. `signer.address` is the data point owner. */
+    signer: DataPointDeletionSigner;
+    scope: string;
+    config: DataPortabilityGatewayConfig;
+    /**
+     * Skip the gateway lookup and treat this as the current version. Use when
+     * the caller already holds a fresh `DataPointRecord.expectedVersion`;
+     * omit to let the SDK fetch it.
+     */
+    currentVersion?: bigint;
+}
+interface DataPointDeletionBase {
+    dataPointId: Hex;
+    ownerAddress: Address;
+    scope: string;
+    /** Decimal-string uint256 of the tombstone version (`current + 1`). */
+    version: string;
+    signature: Hex;
+    /** The gateway's 200 body for the tombstone. */
+    tombstone: GatewayDeleteDataPointResult;
+}
+/** Both the gateway tombstone and the blob cleanup succeeded. */
+export interface DataPointDeletedResult extends DataPointDeletionBase {
+    status: "deleted";
+    storage: DataPointBlobDeleteResult;
+}
+/**
+ * The gateway recorded the tombstone (durable, the data point is deleted)
+ * but the blob cleanup failed. Retry `storage.deleteScope(owner, scope)`
+ * later; the tombstone does not need to be re-signed.
+ */
+export interface DataPointDeletionPartialResult extends DataPointDeletionBase {
+    status: "partial";
+    storageError: Error;
+}
+export type DataPointDeletionResult = DataPointDeletedResult | DataPointDeletionPartialResult;
+/**
+ * Delete a data point end to end. Symmetric with `registerDataPoint`.
+ *
+ * Order, deliberately:
+ *   1. fetch the current version from the gateway (unless supplied),
+ *   2. sign the tombstone `AddData` for `current + 1`,
+ *   3. `DELETE /v1/data/:dataPointId` on the gateway,
+ *   4. delete every blob under `(owner, scope)` in vana-storage.
+ *
+ * Steps 1-3 throw on failure ({@link DataPointNotFoundError},
+ * {@link DataPointDeletedError}, `DataPointVersionConflictError`, or a
+ * generic gateway error). A step-4 failure does NOT throw: the tombstone is
+ * already the durable fact, so the result comes back with
+ * `status: "partial"` and the storage error attached.
+ */
+export declare function deleteDataPoint(input: DeleteDataPointInput): Promise<DataPointDeletionResult>;
+export {};

package/dist/protocol/data-point-deletion.js

@@ -0,0 +1,193 @@
+import {
+  isAddress,
+  keccak256,
+  maxUint256,
+  stringToBytes
+} from "viem";
+import { DataPointDeletedError, DataPointNotFoundError } from "../errors.js";
+import { isPlainObject } from "../utils/response-body.js";
+import {
+  ADD_DATA_TYPES,
+  dataRegistryDomain
+} from "./eip712.js";
+import { deriveDataPointId } from "./lineage.js";
+const TOMBSTONE_DATA_HASH_PREIMAGE = "vana.data-point.tombstone.v1";
+const TOMBSTONE_METADATA_HASH_PREIMAGE = "vana.data-point.tombstone.metadata.v1";
+const TOMBSTONE_DATA_HASH = "0x30c45ee72fe56d1927701316925ab7ceacd3b6f9267061735d59396f075c6222";
+const TOMBSTONE_METADATA_HASH = "0xc5255a141acd6a2ae55971b62c0a85977c2511989dc114ad2abc2b7644f57d90";
+function computeTombstoneHash(preimage) {
+  return keccak256(stringToBytes(preimage));
+}
+function isTombstoneHashes(dataHash, metadataHash) {
+  return typeof dataHash === "string" && typeof metadataHash === "string" && dataHash.toLowerCase() === TOMBSTONE_DATA_HASH && metadataHash.toLowerCase() === TOMBSTONE_METADATA_HASH;
+}
+function isDataPointTombstone(value) {
+  if (!isPlainObject(value)) return false;
+  if (typeof value["deletedAt"] === "string") return true;
+  return isTombstoneHashes(
+    typeof value["dataHash"] === "string" ? value["dataHash"] : void 0,
+    typeof value["metadataHash"] === "string" ? value["metadataHash"] : void 0
+  );
+}
+function tombstoneDeletedAt(value) {
+  if (!isPlainObject(value)) return null;
+  const deletedAt = value["deletedAt"];
+  return typeof deletedAt === "string" ? deletedAt : null;
+}
+function assertAddress(value, name) {
+  if (!isAddress(value)) {
+    throw new Error(`${name} must be a valid EVM address`);
+  }
+}
+function assertUint256(value, name) {
+  if (value < 0n || value > maxUint256) {
+    throw new Error(`${name} must fit in uint256, got ${value}`);
+  }
+}
+function getAccountAddress(account) {
+  if (!account) return void 0;
+  return typeof account === "string" ? account : account.address;
+}
+function isDataPointDeletionSigner(source) {
+  return "address" in source && typeof source.signTypedData === "function";
+}
+function createViemDataPointDeletionSigner(source, options = {}) {
+  if (isDataPointDeletionSigner(source)) {
+    return source;
+  }
+  const accountAddress = getAccountAddress(options.account) ?? getAccountAddress(source.account);
+  if (accountAddress) {
+    return {
+      address: accountAddress,
+      signTypedData: (typedData) => source.signTypedData({
+        ...typedData,
+        account: options.account ?? source.account ?? accountAddress
+      })
+    };
+  }
+  throw new Error(
+    "Viem wallet client requires an account option or account property"
+  );
+}
+function buildDataPointDeletionTypedData(input) {
+  assertAddress(input.ownerAddress, "ownerAddress");
+  if (input.scope.length === 0) {
+    throw new Error("scope must be a non-empty string");
+  }
+  if (input.expectedVersion <= 0n) {
+    throw new Error("expectedVersion must be a positive version number");
+  }
+  assertUint256(input.expectedVersion, "expectedVersion");
+  return {
+    domain: dataRegistryDomain(input.config),
+    types: ADD_DATA_TYPES,
+    primaryType: "AddData",
+    message: {
+      ownerAddress: input.ownerAddress,
+      scope: input.scope,
+      dataHash: TOMBSTONE_DATA_HASH,
+      metadataHash: TOMBSTONE_METADATA_HASH,
+      expectedVersion: input.expectedVersion
+    }
+  };
+}
+async function buildDataPointDeletionSignature(input) {
+  const typedData = buildDataPointDeletionTypedData({
+    ownerAddress: input.signer.address,
+    scope: input.scope,
+    expectedVersion: input.expectedVersion,
+    config: input.config
+  });
+  const signature = await input.signer.signTypedData(typedData);
+  return {
+    signature,
+    signerAddress: input.signer.address,
+    typedData
+  };
+}
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+function parseExpectedVersion(value) {
+  if (typeof value !== "string" || !/^\d+$/.test(value)) {
+    throw new Error(
+      `Gateway returned a malformed expectedVersion: ${JSON.stringify(value)}`
+    );
+  }
+  const parsed = BigInt(value);
+  assertUint256(parsed, "Gateway expectedVersion");
+  return parsed;
+}
+async function deleteDataPoint(input) {
+  const ownerAddress = input.signer.address;
+  const dataPointId = deriveDataPointId(ownerAddress, input.scope);
+  let currentVersion = input.currentVersion;
+  if (currentVersion === void 0) {
+    const record = await input.gateway.getDataPoint(dataPointId);
+    if (record === null) {
+      throw new DataPointNotFoundError(
+        `No data point registered for scope '${input.scope}' owned by ${ownerAddress}`,
+        { dataPointId, scope: input.scope, ownerAddress }
+      );
+    }
+    if (isDataPointTombstone(record)) {
+      throw new DataPointDeletedError(
+        `Data point ${dataPointId} (scope '${input.scope}') is already deleted`,
+        {
+          dataPointId,
+          scope: input.scope,
+          ownerAddress,
+          deletedAt: tombstoneDeletedAt(record)
+        }
+      );
+    }
+    currentVersion = parseExpectedVersion(record.expectedVersion);
+  }
+  if (currentVersion < 0n || currentVersion >= maxUint256) {
+    throw new Error(
+      `currentVersion ${currentVersion} cannot be incremented to a uint256 tombstone version`
+    );
+  }
+  const tombstoneVersion = currentVersion + 1n;
+  const signed = await buildDataPointDeletionSignature({
+    signer: input.signer,
+    scope: input.scope,
+    expectedVersion: tombstoneVersion,
+    config: input.config
+  });
+  const tombstone = await input.gateway.deleteDataPoint({
+    ownerAddress,
+    scope: input.scope,
+    expectedVersion: tombstoneVersion.toString(),
+    signature: signed.signature
+  });
+  const base = {
+    dataPointId,
+    ownerAddress,
+    scope: input.scope,
+    version: tombstoneVersion.toString(),
+    signature: signed.signature,
+    tombstone
+  };
+  try {
+    const storage = await input.storage.deleteScope(ownerAddress, input.scope);
+    return { ...base, status: "deleted", storage };
+  } catch (cause) {
+    return { ...base, status: "partial", storageError: toError(cause) };
+  }
+}
+export {
+  TOMBSTONE_DATA_HASH,
+  TOMBSTONE_DATA_HASH_PREIMAGE,
+  TOMBSTONE_METADATA_HASH,
+  TOMBSTONE_METADATA_HASH_PREIMAGE,
+  buildDataPointDeletionSignature,
+  buildDataPointDeletionTypedData,
+  computeTombstoneHash,
+  createViemDataPointDeletionSigner,
+  deleteDataPoint,
+  isDataPointTombstone,
+  isTombstoneHashes,
+  tombstoneDeletedAt
+};
+//# sourceMappingURL=data-point-deletion.js.map