@graffiti-garden/implementation-decentralized 0.0.1

package/dist/cjs/3-protocol/2-handles.js

@@ -0,0 +1,65 @@
+"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 handles_exports = {};
+__export(handles_exports, {
+  Handles: () => Handles
+});
+module.exports = __toCommonJS(handles_exports);
+var import_api = require("@graffiti-garden/api");
+var import_dids = require("../1-services/2-dids");
+const HANDLE_DID_PREFIX = "did:web:";
+class Handles {
+  constructor(services) {
+    this.services = services;
+  }
+  actorToHandle = async (actor) => {
+    const actorDocument = await this.services.dids.resolve(actor);
+    const handleDid = actorDocument.alsoKnownAs?.at(0);
+    if (!handleDid) {
+      throw new import_api.GraffitiErrorNotFound(
+        `Handle for actor DID ${actor} not found`
+      );
+    }
+    if (!handleDid.startsWith(HANDLE_DID_PREFIX)) {
+      throw new Error(`Handle DID ${handleDid} is not a valid handle`);
+    }
+    const handle = handleDid.slice(HANDLE_DID_PREFIX.length);
+    const handleDocument = await this.services.dids.resolve(handleDid);
+    if (!handleDocument.alsoKnownAs || !handleDocument.alsoKnownAs.includes(actor)) {
+      throw new Error(`Handle ${handle} does not match actor ${actor}`);
+    }
+    return handle;
+  };
+  handleToActor = async (handle) => {
+    const handleDid = `${HANDLE_DID_PREFIX}${handle}`;
+    const handleDocument = await this.services.dids.resolve(handleDid);
+    const actor = handleDocument.alsoKnownAs?.at(0);
+    if (!actor) {
+      throw new import_api.GraffitiErrorNotFound(
+        `Actor for handle DID ${handleDid} not found`
+      );
+    }
+    const actorDocument = await this.services.dids.resolve(actor);
+    if (!actorDocument.alsoKnownAs || !actorDocument.alsoKnownAs.includes(handleDid)) {
+      throw new Error(`Actor ${actor} does not match handle ${handle}`);
+    }
+    return actor;
+  };
+}
+//# sourceMappingURL=2-handles.js.map

package/dist/cjs/3-protocol/2-handles.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/3-protocol/2-handles.ts"],
+  "sourcesContent": ["import type { Graffiti } from \"@graffiti-garden/api\";\nimport { GraffitiErrorNotFound } from \"@graffiti-garden/api\";\nimport { DecentralizedIdentifiers } from \"../1-services/2-dids\";\n\n// Handles used a fixed method\nconst HANDLE_DID_PREFIX = \"did:web:\";\n\nexport class Handles {\n  constructor(\n    protected readonly services: { dids: DecentralizedIdentifiers },\n  ) {}\n\n  actorToHandle: Graffiti[\"actorToHandle\"] = async (actor) => {\n    const actorDocument = await this.services.dids.resolve(actor);\n\n    const handleDid = actorDocument.alsoKnownAs?.at(0);\n    if (!handleDid) {\n      throw new GraffitiErrorNotFound(\n        `Handle for actor DID ${actor} not found`,\n      );\n    }\n    if (!handleDid.startsWith(HANDLE_DID_PREFIX)) {\n      throw new Error(`Handle DID ${handleDid} is not a valid handle`);\n    }\n\n    const handle = handleDid.slice(HANDLE_DID_PREFIX.length);\n\n    const handleDocument = await this.services.dids.resolve(handleDid);\n    if (\n      !handleDocument.alsoKnownAs ||\n      !handleDocument.alsoKnownAs.includes(actor)\n    ) {\n      throw new Error(`Handle ${handle} does not match actor ${actor}`);\n    }\n\n    return handle;\n  };\n\n  handleToActor: Graffiti[\"handleToActor\"] = async (handle) => {\n    const handleDid = `${HANDLE_DID_PREFIX}${handle}`;\n    const handleDocument = await this.services.dids.resolve(handleDid);\n\n    const actor = handleDocument.alsoKnownAs?.at(0);\n    if (!actor) {\n      throw new GraffitiErrorNotFound(\n        `Actor for handle DID ${handleDid} not found`,\n      );\n    }\n\n    const actorDocument = await this.services.dids.resolve(actor);\n    if (\n      !actorDocument.alsoKnownAs ||\n      !actorDocument.alsoKnownAs.includes(handleDid)\n    ) {\n      throw new Error(`Actor ${actor} does not match handle ${handle}`);\n    }\n\n    return actor;\n  };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,iBAAsC;AACtC,kBAAyC;AAGzC,MAAM,oBAAoB;AAEnB,MAAM,QAAQ;AAAA,EACnB,YACqB,UACnB;AADmB;AAAA,EAClB;AAAA,EAEH,gBAA2C,OAAO,UAAU;AAC1D,UAAM,gBAAgB,MAAM,KAAK,SAAS,KAAK,QAAQ,KAAK;AAE5D,UAAM,YAAY,cAAc,aAAa,GAAG,CAAC;AACjD,QAAI,CAAC,WAAW;AACd,YAAM,IAAI;AAAA,QACR,wBAAwB,KAAK;AAAA,MAC/B;AAAA,IACF;AACA,QAAI,CAAC,UAAU,WAAW,iBAAiB,GAAG;AAC5C,YAAM,IAAI,MAAM,cAAc,SAAS,wBAAwB;AAAA,IACjE;AAEA,UAAM,SAAS,UAAU,MAAM,kBAAkB,MAAM;AAEvD,UAAM,iBAAiB,MAAM,KAAK,SAAS,KAAK,QAAQ,SAAS;AACjE,QACE,CAAC,eAAe,eAChB,CAAC,eAAe,YAAY,SAAS,KAAK,GAC1C;AACA,YAAM,IAAI,MAAM,UAAU,MAAM,yBAAyB,KAAK,EAAE;AAAA,IAClE;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,gBAA2C,OAAO,WAAW;AAC3D,UAAM,YAAY,GAAG,iBAAiB,GAAG,MAAM;AAC/C,UAAM,iBAAiB,MAAM,KAAK,SAAS,KAAK,QAAQ,SAAS;AAEjE,UAAM,QAAQ,eAAe,aAAa,GAAG,CAAC;AAC9C,QAAI,CAAC,OAAO;AACV,YAAM,IAAI;AAAA,QACR,wBAAwB,SAAS;AAAA,MACnC;AAAA,IACF;AAEA,UAAM,gBAAgB,MAAM,KAAK,SAAS,KAAK,QAAQ,KAAK;AAC5D,QACE,CAAC,cAAc,eACf,CAAC,cAAc,YAAY,SAAS,SAAS,GAC7C;AACA,YAAM,IAAI,MAAM,SAAS,KAAK,0BAA0B,MAAM,EAAE;AAAA,IAClE;AAEA,WAAO;AAAA,EACT;AACF;",
+  "names": []
+}

package/dist/cjs/3-protocol/3-object-encoding-tests.js

@@ -0,0 +1,253 @@
+"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 object_encoding_tests_exports = {};
+__export(object_encoding_tests_exports, {
+  objectEncodingTests: () => objectEncodingTests
+});
+module.exports = __toCommonJS(object_encoding_tests_exports);
+var import_vitest = require("vitest");
+var import_object_encoding = require("./3-object-encoding.js");
+var import_utils = require("@noble/hashes/utils.js");
+var import_string_encoding = require("../2-primitives/1-string-encoding.js");
+var import_content_addresses = require("../2-primitives/2-content-addresses.js");
+var import_channel_attestations = require("../2-primitives/3-channel-attestations.js");
+var import_allowed_attestations = require("../2-primitives/4-allowed-attestations.js");
+var import_dag_cbor = require("@ipld/dag-cbor");
+var import_api = require("@graffiti-garden/api");
+function objectEncodingTests() {
+  (0, import_vitest.describe)("object Urls", () => {
+    for (const actor of [
+      "did:plc:alsdkjfkdjf",
+      "did:web:example.com/someone",
+      "did:example:123456789abcdefghi\u{1F47B}"
+    ]) {
+      (0, import_vitest.test)(`encodeObjectUrl encodes and decodes correctly with actor: ${actor}`, async () => {
+        const contentAddressBytes = (0, import_utils.randomBytes)();
+        const contentAddress = await new import_string_encoding.StringEncoder().encode(
+          import_string_encoding.STRING_ENCODER_METHOD_BASE64URL,
+          contentAddressBytes
+        );
+        const url = (0, import_object_encoding.encodeObjectUrl)(actor, contentAddress);
+        const decoded = (0, import_object_encoding.decodeObjectUrl)(url);
+        (0, import_vitest.expect)(decoded.actor).toBe(actor);
+        (0, import_vitest.expect)(decoded.contentAddress).toBe(contentAddress);
+      });
+    }
+    for (const invalidUrl of [
+      "http://example.com/not-an-object-url",
+      "graffiti:",
+      "graffiti:",
+      "graffiti:no-content-address",
+      "graffiti:too:many:parts"
+    ]) {
+      (0, import_vitest.test)(`Invalid Graffiti URL: ${invalidUrl}`, () => {
+        (0, import_vitest.expect)(() => (0, import_object_encoding.decodeObjectUrl)(invalidUrl)).toThrow();
+      });
+    }
+  });
+  (0, import_vitest.describe)("object encoding and validation", async () => {
+    const objectEncoding = new import_object_encoding.ObjectEncoding({
+      stringEncoder: new import_string_encoding.StringEncoder(),
+      allowedAttestations: new import_allowed_attestations.AllowedAttestations(),
+      channelAttestations: new import_channel_attestations.ChannelAttestations(),
+      contentAddresses: new import_content_addresses.ContentAddresses()
+    });
+    const value = {
+      message: "Hello world!",
+      nested: {
+        foo: {
+          bar: 42
+        }
+      },
+      array: [1, "something \u{1F47B}", { key: "value" }]
+    };
+    const channels = ["channel1\u{1F47B}", "channel2"];
+    const allowed = ["did:web:noone.example.com", "did:web:someone.else.com"];
+    const actor = "did:web:someone.example.com";
+    const { allowedTickets, tags, objectBytes, object } = await objectEncoding.encode(
+      {
+        value,
+        channels,
+        allowed
+      },
+      actor
+    );
+    (0, import_vitest.assert)(Array.isArray(allowedTickets));
+    (0, import_vitest.test)("validate private", async () => {
+      await objectEncoding.validate(object, tags, objectBytes, {
+        allowedTickets
+      });
+      for (const [index, recipient] of allowed.entries()) {
+        const copy = JSON.parse(JSON.stringify(object));
+        const masked = (0, import_api.maskGraffitiObject)(copy, [], recipient);
+        await objectEncoding.validate(masked, tags, objectBytes, {
+          recipient,
+          allowedTicket: allowedTickets[index],
+          allowedIndex: index
+        });
+      }
+    });
+    (0, import_vitest.test)("incorrect value", async () => {
+      await (0, import_vitest.expect)(
+        objectEncoding.validate(
+          {
+            ...object,
+            value: {
+              ...object.value,
+              extra: "field"
+            }
+          },
+          tags,
+          objectBytes,
+          {
+            allowedTickets
+          }
+        )
+      ).rejects.toThrow();
+    });
+    (0, import_vitest.test)("incorrect content address", async () => {
+      const url = (0, import_object_encoding.encodeObjectUrl)(
+        actor,
+        await new import_string_encoding.StringEncoder().encode(
+          import_string_encoding.STRING_ENCODER_METHOD_BASE64URL,
+          (0, import_utils.randomBytes)()
+        )
+      );
+      await (0, import_vitest.expect)(
+        objectEncoding.validate(
+          {
+            ...object,
+            url
+          },
+          [new TextEncoder().encode(url), ...tags.slice(1)],
+          objectBytes,
+          {
+            allowedTickets
+          }
+        )
+      ).rejects.toThrow();
+    });
+    (0, import_vitest.test)("incorrect bytes", async () => {
+      const wrongObjectBytes = (0, import_utils.randomBytes)();
+      const correctContentAddress = (0, import_object_encoding.decodeObjectUrl)(object.url).contentAddress;
+      const correctContentAddressBytes = await new import_string_encoding.StringEncoder().decode(
+        correctContentAddress
+      );
+      const contentAddresses = new import_content_addresses.ContentAddresses();
+      const contentAddressMethod = await contentAddresses.getMethod(
+        correctContentAddressBytes
+      );
+      const wrongContentAddressBytes = await contentAddresses.register(
+        contentAddressMethod,
+        wrongObjectBytes
+      );
+      const wrongContentAddress = await new import_string_encoding.StringEncoder().encode(
+        import_string_encoding.STRING_ENCODER_METHOD_BASE64URL,
+        wrongContentAddressBytes
+      );
+      const wrongObjectUrl = (0, import_object_encoding.encodeObjectUrl)(actor, wrongContentAddress);
+      await (0, import_vitest.expect)(
+        objectEncoding.validate(
+          {
+            ...object,
+            url: wrongObjectUrl
+          },
+          [new TextEncoder().encode(wrongObjectUrl), ...tags.slice(1)],
+          wrongObjectBytes,
+          {
+            allowedTickets
+          }
+        )
+      ).rejects.toThrow();
+    });
+    (0, import_vitest.test)("incorrect format", async () => {
+      const wrongData = {
+        not: "the expected format"
+      };
+      const wrongObjectBytes = (0, import_dag_cbor.encode)(wrongData);
+      const correctContentAddress = (0, import_object_encoding.decodeObjectUrl)(object.url).contentAddress;
+      const correctContentAddressBytes = await new import_string_encoding.StringEncoder().decode(
+        correctContentAddress
+      );
+      const contentAddresses = new import_content_addresses.ContentAddresses();
+      const contentAddressMethod = await contentAddresses.getMethod(
+        correctContentAddressBytes
+      );
+      const wrongContentAddressBytes = await contentAddresses.register(
+        contentAddressMethod,
+        wrongObjectBytes
+      );
+      const wrongContentAddress = await new import_string_encoding.StringEncoder().encode(
+        import_string_encoding.STRING_ENCODER_METHOD_BASE64URL,
+        wrongContentAddressBytes
+      );
+      const wrongObjectUrl = (0, import_object_encoding.encodeObjectUrl)(actor, wrongContentAddress);
+      await (0, import_vitest.expect)(
+        objectEncoding.validate(
+          {
+            ...object,
+            url: wrongObjectUrl
+          },
+          [new TextEncoder().encode(wrongObjectUrl), ...tags.slice(1)],
+          wrongObjectBytes,
+          {
+            allowedTickets
+          }
+        )
+      ).rejects.toThrow();
+    });
+    (0, import_vitest.test)("missing allowed tickets", async () => {
+      await (0, import_vitest.expect)(
+        objectEncoding.validate(object, tags, objectBytes)
+      ).rejects.toThrow();
+    });
+    (0, import_vitest.test)("wrong allowed tickets", async () => {
+      const wrongAllowedTickets = await Promise.all(
+        allowedTickets.map(
+          async (ticket) => (await new import_allowed_attestations.AllowedAttestations().attest(
+            import_allowed_attestations.ALLOWED_ATTESTATION_METHOD_HMAC_SHA256,
+            "did:web:not-the-right.actor"
+          )).ticket
+        )
+      );
+      await (0, import_vitest.expect)(
+        objectEncoding.validate(object, tags, objectBytes, {
+          allowedTickets: wrongAllowedTickets
+        })
+      ).rejects.toThrow();
+    });
+    (0, import_vitest.test)("wrong recipients", async () => {
+      const wrongRecipients = allowed.map((recipient) => recipient + "-wrong");
+      await (0, import_vitest.expect)(
+        objectEncoding.validate(
+          {
+            ...object,
+            allowed: wrongRecipients
+          },
+          tags,
+          objectBytes,
+          {
+            allowedTickets
+          }
+        )
+      ).rejects.toThrow();
+    });
+  });
+}
+//# sourceMappingURL=3-object-encoding-tests.js.map

package/dist/cjs/3-protocol/3-object-encoding-tests.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/3-protocol/3-object-encoding-tests.ts"],
+  "sourcesContent": ["import { assert, describe, expect, test } from \"vitest\";\n\nimport {\n  encodeObjectUrl,\n  decodeObjectUrl,\n  ObjectEncoding,\n} from \"./3-object-encoding.js\";\nimport { randomBytes } from \"@noble/hashes/utils.js\";\nimport {\n  STRING_ENCODER_METHOD_BASE64URL,\n  StringEncoder,\n} from \"../2-primitives/1-string-encoding.js\";\nimport { ContentAddresses } from \"../2-primitives/2-content-addresses.js\";\nimport { ChannelAttestations } from \"../2-primitives/3-channel-attestations.js\";\nimport {\n  ALLOWED_ATTESTATION_METHOD_HMAC_SHA256,\n  AllowedAttestations,\n} from \"../2-primitives/4-allowed-attestations.js\";\nimport {\n  encode as dagCborEncode,\n  decode as dagCborDecode,\n} from \"@ipld/dag-cbor\";\nimport {\n  maskGraffitiObject,\n  type GraffitiObjectBase,\n} from \"@graffiti-garden/api\";\n\nexport function objectEncodingTests() {\n  describe(\"object Urls\", () => {\n    for (const actor of [\n      \"did:plc:alsdkjfkdjf\",\n      \"did:web:example.com/someone\",\n      \"did:example:123456789abcdefghi\uD83D\uDC7B\",\n    ]) {\n      test(`encodeObjectUrl encodes and decodes correctly with actor: ${actor}`, async () => {\n        const contentAddressBytes = randomBytes();\n        const contentAddress = await new StringEncoder().encode(\n          STRING_ENCODER_METHOD_BASE64URL,\n          contentAddressBytes,\n        );\n\n        const url = encodeObjectUrl(actor, contentAddress);\n        const decoded = decodeObjectUrl(url);\n        expect(decoded.actor).toBe(actor);\n        expect(decoded.contentAddress).toBe(contentAddress);\n      });\n    }\n\n    for (const invalidUrl of [\n      \"http://example.com/not-an-object-url\",\n      \"graffiti:\",\n      \"graffiti:\",\n      \"graffiti:no-content-address\",\n      \"graffiti:too:many:parts\",\n    ]) {\n      test(`Invalid Graffiti URL: ${invalidUrl}`, () => {\n        expect(() => decodeObjectUrl(invalidUrl)).toThrow();\n      });\n    }\n  });\n\n  describe(\"object encoding and validation\", async () => {\n    const objectEncoding = new ObjectEncoding({\n      stringEncoder: new StringEncoder(),\n      allowedAttestations: new AllowedAttestations(),\n      channelAttestations: new ChannelAttestations(),\n      contentAddresses: new ContentAddresses(),\n    });\n\n    const value = {\n      message: \"Hello world!\",\n      nested: {\n        foo: {\n          bar: 42,\n        },\n      },\n      array: [1, \"something \uD83D\uDC7B\", { key: \"value\" }],\n    };\n    const channels = [\"channel1\uD83D\uDC7B\", \"channel2\"];\n    const allowed = [\"did:web:noone.example.com\", \"did:web:someone.else.com\"];\n    const actor = \"did:web:someone.example.com\";\n\n    const { allowedTickets, tags, objectBytes, object } =\n      await objectEncoding.encode<{}>(\n        {\n          value,\n          channels,\n          allowed,\n        },\n        actor,\n      );\n    assert(Array.isArray(allowedTickets));\n\n    test(\"validate private\", async () => {\n      await objectEncoding.validate(object, tags, objectBytes, {\n        allowedTickets,\n      });\n\n      for (const [index, recipient] of allowed.entries()) {\n        const copy = JSON.parse(JSON.stringify(object)) as GraffitiObjectBase;\n        const masked = maskGraffitiObject(copy, [], recipient);\n        await objectEncoding.validate(masked, tags, objectBytes, {\n          recipient: recipient,\n          allowedTicket: allowedTickets[index],\n          allowedIndex: index,\n        });\n      }\n    });\n\n    test(\"incorrect value\", async () => {\n      await expect(\n        objectEncoding.validate(\n          {\n            ...object,\n            value: {\n              ...object.value,\n              extra: \"field\",\n            },\n          },\n          tags,\n          objectBytes,\n          {\n            allowedTickets,\n          },\n        ),\n      ).rejects.toThrow();\n    });\n\n    test(\"incorrect content address\", async () => {\n      const url = encodeObjectUrl(\n        actor,\n        await new StringEncoder().encode(\n          STRING_ENCODER_METHOD_BASE64URL,\n          randomBytes(),\n        ),\n      );\n\n      await expect(\n        objectEncoding.validate(\n          {\n            ...object,\n            url,\n          },\n          [new TextEncoder().encode(url), ...tags.slice(1)],\n          objectBytes,\n          {\n            allowedTickets,\n          },\n        ),\n      ).rejects.toThrow();\n    });\n\n    test(\"incorrect bytes\", async () => {\n      const wrongObjectBytes = randomBytes();\n      const correctContentAddress = decodeObjectUrl(object.url).contentAddress;\n      const correctContentAddressBytes = await new StringEncoder().decode(\n        correctContentAddress,\n      );\n      const contentAddresses = new ContentAddresses();\n      const contentAddressMethod = await contentAddresses.getMethod(\n        correctContentAddressBytes,\n      );\n      const wrongContentAddressBytes = await contentAddresses.register(\n        contentAddressMethod,\n        wrongObjectBytes,\n      );\n      const wrongContentAddress = await new StringEncoder().encode(\n        STRING_ENCODER_METHOD_BASE64URL,\n        wrongContentAddressBytes,\n      );\n      const wrongObjectUrl = encodeObjectUrl(actor, wrongContentAddress);\n\n      await expect(\n        objectEncoding.validate(\n          {\n            ...object,\n            url: wrongObjectUrl,\n          },\n          [new TextEncoder().encode(wrongObjectUrl), ...tags.slice(1)],\n          wrongObjectBytes,\n          {\n            allowedTickets,\n          },\n        ),\n      ).rejects.toThrow();\n    });\n\n    test(\"incorrect format\", async () => {\n      const wrongData = {\n        not: \"the expected format\",\n      };\n      const wrongObjectBytes = dagCborEncode(wrongData);\n      const correctContentAddress = decodeObjectUrl(object.url).contentAddress;\n      const correctContentAddressBytes = await new StringEncoder().decode(\n        correctContentAddress,\n      );\n      const contentAddresses = new ContentAddresses();\n      const contentAddressMethod = await contentAddresses.getMethod(\n        correctContentAddressBytes,\n      );\n      const wrongContentAddressBytes = await contentAddresses.register(\n        contentAddressMethod,\n        wrongObjectBytes,\n      );\n      const wrongContentAddress = await new StringEncoder().encode(\n        STRING_ENCODER_METHOD_BASE64URL,\n        wrongContentAddressBytes,\n      );\n      const wrongObjectUrl = encodeObjectUrl(actor, wrongContentAddress);\n      await expect(\n        objectEncoding.validate(\n          {\n            ...object,\n            url: wrongObjectUrl,\n          },\n          [new TextEncoder().encode(wrongObjectUrl), ...tags.slice(1)],\n          wrongObjectBytes,\n          {\n            allowedTickets,\n          },\n        ),\n      ).rejects.toThrow();\n    });\n\n    test(\"missing allowed tickets\", async () => {\n      await expect(\n        objectEncoding.validate(object, tags, objectBytes),\n      ).rejects.toThrow();\n    });\n\n    test(\"wrong allowed tickets\", async () => {\n      const wrongAllowedTickets = await Promise.all(\n        allowedTickets.map(\n          async (ticket) =>\n            (\n              await new AllowedAttestations().attest(\n                ALLOWED_ATTESTATION_METHOD_HMAC_SHA256,\n                \"did:web:not-the-right.actor\",\n              )\n            ).ticket,\n        ),\n      );\n\n      await expect(\n        objectEncoding.validate(object, tags, objectBytes, {\n          allowedTickets: wrongAllowedTickets,\n        }),\n      ).rejects.toThrow();\n    });\n\n    test(\"wrong recipients\", async () => {\n      const wrongRecipients = allowed.map((recipient) => recipient + \"-wrong\");\n\n      await expect(\n        objectEncoding.validate(\n          {\n            ...object,\n            allowed: wrongRecipients,\n          },\n          tags,\n          objectBytes,\n          {\n            allowedTickets,\n          },\n        ),\n      ).rejects.toThrow();\n    });\n  });\n}\n"],
+  "mappings": "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",
+  "names": ["dagCborEncode"]
+}

package/dist/cjs/3-protocol/3-object-encoding.js

@@ -0,0 +1,287 @@
+"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 object_encoding_exports = {};
+__export(object_encoding_exports, {
+  GRAFFITI_OBJECT_URL_PREFIX: () => GRAFFITI_OBJECT_URL_PREFIX,
+  MAX_OBJECT_SIZE_BYTES: () => MAX_OBJECT_SIZE_BYTES,
+  ObjectEncoding: () => ObjectEncoding,
+  decodeObjectUrl: () => decodeObjectUrl,
+  decodeObjectUrlComponent: () => decodeObjectUrlComponent,
+  encodeObjectUrl: () => encodeObjectUrl,
+  encodeObjectUrlComponent: () => encodeObjectUrlComponent
+});
+module.exports = __toCommonJS(object_encoding_exports);
+var import_content_addresses = require("../2-primitives/2-content-addresses");
+var import_utils = require("@noble/hashes/utils.js");
+var import_dag_cbor = require("@ipld/dag-cbor");
+var import_mini = require("zod/mini");
+var import_channel_attestations = require("../2-primitives/3-channel-attestations");
+var import_allowed_attestations = require("../2-primitives/4-allowed-attestations");
+var import_string_encoding = require("../2-primitives/1-string-encoding");
+const MAX_OBJECT_SIZE_BYTES = 32 * 1024;
+class ObjectEncoding {
+  constructor(primitives) {
+    this.primitives = primitives;
+  }
+  async encode(partialObject, actor) {
+    partialObject = cleanUndefined(partialObject);
+    const channelAttestationAndPublicIds = await Promise.all(
+      partialObject.channels.map(
+        (channel) => this.primitives.channelAttestations.attest(
+          // TODO: get this from the DID document of the actor
+          import_channel_attestations.CHANNEL_ATTESTATION_METHOD_SHA256_ED25519,
+          actor,
+          channel
+        )
+      )
+    );
+    const channelAttestations = channelAttestationAndPublicIds.map(
+      (c) => c.attestation
+    );
+    const channelPublicIds = channelAttestationAndPublicIds.map(
+      (c) => c.channelPublicId
+    );
+    const objectData = {
+      [VALUE_PROPERTY]: partialObject.value,
+      [CHANNEL_ATTESTATIONS_PROPERTY]: channelAttestations,
+      [NONCE_PROPERTY]: (0, import_utils.randomBytes)(32)
+    };
+    let allowedTickets = void 0;
+    if (Array.isArray(partialObject.allowed)) {
+      const allowedAttestations = await Promise.all(
+        partialObject.allowed.map(
+          async (allowedActor) => this.primitives.allowedAttestations.attest(
+            // TODO: get this from the DID document of the actor
+            import_allowed_attestations.ALLOWED_ATTESTATION_METHOD_HMAC_SHA256,
+            allowedActor
+          )
+        )
+      );
+      objectData[ALLOWED_ATTESTATIONS_PROPERTY] = allowedAttestations.map(
+        (a) => a.attestation
+      );
+      allowedTickets = allowedAttestations.map((a) => a.ticket);
+    }
+    const objectBytes = (0, import_dag_cbor.encode)(objectData);
+    if (objectBytes.byteLength > MAX_OBJECT_SIZE_BYTES) {
+      throw new Error("The object is too large");
+    }
+    const objectContentAddressBytes = await this.primitives.contentAddresses.register(
+      // TODO: get this from the DID document of the actor
+      import_content_addresses.CONTENT_ADDRESS_METHOD_SHA256,
+      objectBytes
+    );
+    const objectContentAddress = await this.primitives.stringEncoder.encode(
+      import_string_encoding.STRING_ENCODER_METHOD_BASE64URL,
+      objectContentAddressBytes
+    );
+    const objectUrl = encodeObjectUrl(actor, objectContentAddress);
+    const tags = [new TextEncoder().encode(objectUrl), ...channelPublicIds];
+    const object = {
+      value: partialObject.value,
+      channels: partialObject.channels,
+      url: objectUrl,
+      actor,
+      ...partialObject.allowed ? {
+        allowed: partialObject.allowed
+      } : {}
+    };
+    return {
+      object,
+      tags,
+      objectBytes,
+      allowedTickets
+    };
+  }
+  async validate(object, tags, objectBytes, privateObjectInfo) {
+    if (objectBytes.byteLength > MAX_OBJECT_SIZE_BYTES) {
+      throw new Error("Object is too big");
+    }
+    const { actor, contentAddress } = decodeObjectUrl(object.url);
+    if (actor !== object.actor) {
+      throw new Error("Object actor does not match URL actor");
+    }
+    const objectUrlTag = tags.at(0);
+    if (!objectUrlTag) {
+      throw new Error("No object URL tag");
+    }
+    if (new TextDecoder().decode(objectUrlTag) !== object.url) {
+      throw new Error("Object URL tag does not match object URL");
+    }
+    const channelPublicIds = tags.slice(1);
+    const contentAddressBytes = await this.primitives.stringEncoder.decode(contentAddress);
+    const contentAddressMethod = await this.primitives.contentAddresses.getMethod(contentAddressBytes);
+    const expectedContentAddress = await this.primitives.contentAddresses.register(
+      contentAddressMethod,
+      objectBytes
+    );
+    if (expectedContentAddress.length !== contentAddressBytes.length || !expectedContentAddress.every((b, i) => b === contentAddressBytes[i])) {
+      throw new Error("Content address is invalid");
+    }
+    const objectDataUnknown = (0, import_dag_cbor.decode)(objectBytes);
+    const objectData = ObjectDataSchema.parse(objectDataUnknown);
+    const value = objectData[VALUE_PROPERTY];
+    const channelAttestations = objectData[CHANNEL_ATTESTATIONS_PROPERTY];
+    const allowedAttestations = objectData[ALLOWED_ATTESTATIONS_PROPERTY];
+    const valueBytes = (0, import_dag_cbor.encode)(value);
+    const expectedValueBytes = (0, import_dag_cbor.encode)(object.value);
+    if (valueBytes.length !== expectedValueBytes.length || !valueBytes.every((b, i) => b === expectedValueBytes[i])) {
+      throw new Error("Object value does not match storage value");
+    }
+    if (channelAttestations.length !== channelPublicIds.length) {
+      throw new Error("Not as many channel attestations and public ids");
+    }
+    for (const [index, attestation] of channelAttestations.entries()) {
+      const channelPublicId = channelPublicIds[index];
+      const isValid = await this.primitives.channelAttestations.validate(
+        attestation,
+        actor,
+        channelPublicId
+      );
+      if (!isValid) {
+        throw new Error("Invalid channel attestation");
+      }
+    }
+    if (object.channels.length) {
+      if (object.channels.length !== channelPublicIds.length) {
+        throw new Error(
+          "Number of claimed channels does not match attestations/public IDs"
+        );
+      }
+      const channelAttestationMethod = await this.primitives.channelAttestations.getMethod(
+        channelPublicIds[0]
+      );
+      const expectedChannelPublicIds = await Promise.all(
+        object.channels.map(
+          (channel) => this.primitives.channelAttestations.register(
+            channelAttestationMethod,
+            channel
+          )
+        )
+      );
+      for (const [
+        index,
+        expectedPublicId
+      ] of expectedChannelPublicIds.entries()) {
+        const actualPublicId = channelPublicIds[index];
+        if (expectedPublicId.length !== actualPublicId.length || !expectedPublicId.every((b, i) => b === actualPublicId[i])) {
+          throw new Error("Channel public id does not match expected");
+        }
+      }
+    }
+    if (privateObjectInfo) {
+      if (!allowedAttestations) {
+        throw new Error("Object is public but thought to be private");
+      }
+      let recipients;
+      let allowedTickets;
+      let attestations;
+      if ("recipient" in privateObjectInfo) {
+        recipients = [privateObjectInfo.recipient];
+        allowedTickets = [privateObjectInfo.allowedTicket];
+        attestations = allowedAttestations.filter(
+          (_, i) => i === privateObjectInfo.allowedIndex
+        );
+      } else {
+        recipients = [...object.allowed ?? []];
+        allowedTickets = privateObjectInfo.allowedTickets;
+        attestations = allowedAttestations;
+      }
+      if (recipients.length !== object.allowed?.length) {
+        throw new Error("Recipient count does not match object allowed list");
+      }
+      if (!recipients.every((r) => object.allowed?.includes(r))) {
+        throw new Error("Recipient not in object allowed list");
+      }
+      for (const [index, recipient] of recipients.entries()) {
+        const allowedTicket = allowedTickets.at(index);
+        const allowedAttestation = attestations.at(index);
+        if (!allowedTicket) {
+          throw new Error("Missing allowed ticket for recipient");
+        }
+        if (!allowedAttestation) {
+          throw new Error("Missing allowed attestation for recipient");
+        }
+        const isValid = await this.primitives.allowedAttestations.validate(
+          allowedAttestation,
+          recipient,
+          allowedTicket
+        );
+        if (!isValid) {
+          throw new Error("Invalid allowed attestation for recipient");
+        }
+      }
+    } else if (allowedAttestations) {
+      throw new Error("Object is private but no recipient info provided");
+    }
+  }
+}
+const VALUE_PROPERTY = "v";
+const CHANNEL_ATTESTATIONS_PROPERTY = "c";
+const ALLOWED_ATTESTATIONS_PROPERTY = "a";
+const NONCE_PROPERTY = "n";
+const Uint8ArraySchema = (0, import_mini.custom)(
+  (v) => v instanceof Uint8Array
+);
+const ObjectDataSchema = (0, import_mini.strictObject)({
+  [VALUE_PROPERTY]: (0, import_mini.looseObject)({}),
+  [CHANNEL_ATTESTATIONS_PROPERTY]: (0, import_mini.array)(Uint8ArraySchema),
+  [ALLOWED_ATTESTATIONS_PROPERTY]: (0, import_mini.optional)((0, import_mini.array)(Uint8ArraySchema)),
+  [NONCE_PROPERTY]: Uint8ArraySchema
+});
+const GRAFFITI_OBJECT_URL_PREFIX = "graffiti:";
+function encodeObjectUrlComponent(value) {
+  const replaced = value.replace(/:/g, "!").replace(/\//g, "~");
+  return encodeURIComponent(replaced);
+}
+function decodeObjectUrlComponent(value) {
+  const decoded = decodeURIComponent(value);
+  return decoded.replace(/!/g, ":").replace(/~/g, "/");
+}
+function encodeObjectUrl(actor, contentAddress) {
+  return `${GRAFFITI_OBJECT_URL_PREFIX}${encodeObjectUrlComponent(actor)}:${encodeObjectUrlComponent(contentAddress)}`;
+}
+function decodeObjectUrl(objectUrl) {
+  if (!objectUrl.startsWith(GRAFFITI_OBJECT_URL_PREFIX)) {
+    throw new Error("Invalid object URL");
+  }
+  const rest = objectUrl.slice(GRAFFITI_OBJECT_URL_PREFIX.length);
+  const parts = rest.split(":");
+  if (parts.length !== 2) {
+    throw new Error("Invalid object URL format");
+  }
+  const [actor, contentAddress] = parts;
+  return {
+    actor: decodeObjectUrlComponent(actor),
+    contentAddress: decodeObjectUrlComponent(contentAddress)
+  };
+}
+function cleanUndefined(value) {
+  if (value === void 0) return null;
+  if (Array.isArray(value)) {
+    return value.map(cleanUndefined);
+  }
+  if (typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, v]) => v !== void 0).map(([k, v]) => [k, cleanUndefined(v)])
+    );
+  }
+  return value;
+}
+//# sourceMappingURL=3-object-encoding.js.map