@graffiti-garden/implementation-decentralized 0.0.1

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

@@ -0,0 +1,248 @@
+import { assert, describe, expect, test } from "vitest";
+import {
+  encodeObjectUrl,
+  decodeObjectUrl,
+  ObjectEncoding
+} from "./3-object-encoding.js";
+import { randomBytes } from "@noble/hashes/utils.js";
+import {
+  STRING_ENCODER_METHOD_BASE64URL,
+  StringEncoder
+} from "../2-primitives/1-string-encoding.js";
+import { ContentAddresses } from "../2-primitives/2-content-addresses.js";
+import { ChannelAttestations } from "../2-primitives/3-channel-attestations.js";
+import {
+  ALLOWED_ATTESTATION_METHOD_HMAC_SHA256,
+  AllowedAttestations
+} from "../2-primitives/4-allowed-attestations.js";
+import {
+  encode as dagCborEncode,
+  decode as dagCborDecode
+} from "@ipld/dag-cbor";
+import {
+  maskGraffitiObject
+} from "@graffiti-garden/api";
+function objectEncodingTests() {
+  describe("object Urls", () => {
+    for (const actor of [
+      "did:plc:alsdkjfkdjf",
+      "did:web:example.com/someone",
+      "did:example:123456789abcdefghi\u{1F47B}"
+    ]) {
+      test(`encodeObjectUrl encodes and decodes correctly with actor: ${actor}`, async () => {
+        const contentAddressBytes = randomBytes();
+        const contentAddress = await new StringEncoder().encode(
+          STRING_ENCODER_METHOD_BASE64URL,
+          contentAddressBytes
+        );
+        const url = encodeObjectUrl(actor, contentAddress);
+        const decoded = decodeObjectUrl(url);
+        expect(decoded.actor).toBe(actor);
+        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"
+    ]) {
+      test(`Invalid Graffiti URL: ${invalidUrl}`, () => {
+        expect(() => decodeObjectUrl(invalidUrl)).toThrow();
+      });
+    }
+  });
+  describe("object encoding and validation", async () => {
+    const objectEncoding = new ObjectEncoding({
+      stringEncoder: new StringEncoder(),
+      allowedAttestations: new AllowedAttestations(),
+      channelAttestations: new ChannelAttestations(),
+      contentAddresses: new 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
+    );
+    assert(Array.isArray(allowedTickets));
+    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 = maskGraffitiObject(copy, [], recipient);
+        await objectEncoding.validate(masked, tags, objectBytes, {
+          recipient,
+          allowedTicket: allowedTickets[index],
+          allowedIndex: index
+        });
+      }
+    });
+    test("incorrect value", async () => {
+      await expect(
+        objectEncoding.validate(
+          {
+            ...object,
+            value: {
+              ...object.value,
+              extra: "field"
+            }
+          },
+          tags,
+          objectBytes,
+          {
+            allowedTickets
+          }
+        )
+      ).rejects.toThrow();
+    });
+    test("incorrect content address", async () => {
+      const url = encodeObjectUrl(
+        actor,
+        await new StringEncoder().encode(
+          STRING_ENCODER_METHOD_BASE64URL,
+          randomBytes()
+        )
+      );
+      await expect(
+        objectEncoding.validate(
+          {
+            ...object,
+            url
+          },
+          [new TextEncoder().encode(url), ...tags.slice(1)],
+          objectBytes,
+          {
+            allowedTickets
+          }
+        )
+      ).rejects.toThrow();
+    });
+    test("incorrect bytes", async () => {
+      const wrongObjectBytes = randomBytes();
+      const correctContentAddress = decodeObjectUrl(object.url).contentAddress;
+      const correctContentAddressBytes = await new StringEncoder().decode(
+        correctContentAddress
+      );
+      const contentAddresses = new ContentAddresses();
+      const contentAddressMethod = await contentAddresses.getMethod(
+        correctContentAddressBytes
+      );
+      const wrongContentAddressBytes = await contentAddresses.register(
+        contentAddressMethod,
+        wrongObjectBytes
+      );
+      const wrongContentAddress = await new StringEncoder().encode(
+        STRING_ENCODER_METHOD_BASE64URL,
+        wrongContentAddressBytes
+      );
+      const wrongObjectUrl = encodeObjectUrl(actor, wrongContentAddress);
+      await expect(
+        objectEncoding.validate(
+          {
+            ...object,
+            url: wrongObjectUrl
+          },
+          [new TextEncoder().encode(wrongObjectUrl), ...tags.slice(1)],
+          wrongObjectBytes,
+          {
+            allowedTickets
+          }
+        )
+      ).rejects.toThrow();
+    });
+    test("incorrect format", async () => {
+      const wrongData = {
+        not: "the expected format"
+      };
+      const wrongObjectBytes = dagCborEncode(wrongData);
+      const correctContentAddress = decodeObjectUrl(object.url).contentAddress;
+      const correctContentAddressBytes = await new StringEncoder().decode(
+        correctContentAddress
+      );
+      const contentAddresses = new ContentAddresses();
+      const contentAddressMethod = await contentAddresses.getMethod(
+        correctContentAddressBytes
+      );
+      const wrongContentAddressBytes = await contentAddresses.register(
+        contentAddressMethod,
+        wrongObjectBytes
+      );
+      const wrongContentAddress = await new StringEncoder().encode(
+        STRING_ENCODER_METHOD_BASE64URL,
+        wrongContentAddressBytes
+      );
+      const wrongObjectUrl = encodeObjectUrl(actor, wrongContentAddress);
+      await expect(
+        objectEncoding.validate(
+          {
+            ...object,
+            url: wrongObjectUrl
+          },
+          [new TextEncoder().encode(wrongObjectUrl), ...tags.slice(1)],
+          wrongObjectBytes,
+          {
+            allowedTickets
+          }
+        )
+      ).rejects.toThrow();
+    });
+    test("missing allowed tickets", async () => {
+      await expect(
+        objectEncoding.validate(object, tags, objectBytes)
+      ).rejects.toThrow();
+    });
+    test("wrong allowed tickets", async () => {
+      const wrongAllowedTickets = await Promise.all(
+        allowedTickets.map(
+          async (ticket) => (await new AllowedAttestations().attest(
+            ALLOWED_ATTESTATION_METHOD_HMAC_SHA256,
+            "did:web:not-the-right.actor"
+          )).ticket
+        )
+      );
+      await expect(
+        objectEncoding.validate(object, tags, objectBytes, {
+          allowedTickets: wrongAllowedTickets
+        })
+      ).rejects.toThrow();
+    });
+    test("wrong recipients", async () => {
+      const wrongRecipients = allowed.map((recipient) => recipient + "-wrong");
+      await expect(
+        objectEncoding.validate(
+          {
+            ...object,
+            allowed: wrongRecipients
+          },
+          tags,
+          objectBytes,
+          {
+            allowedTickets
+          }
+        )
+      ).rejects.toThrow();
+    });
+  });
+}
+export {
+  objectEncodingTests
+};
+//# sourceMappingURL=3-object-encoding-tests.js.map

package/dist/esm/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": []
+}

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

@@ -0,0 +1,280 @@
+import {
+  CONTENT_ADDRESS_METHOD_SHA256
+} from "../2-primitives/2-content-addresses";
+import { randomBytes } from "@noble/hashes/utils.js";
+import {
+  encode as dagCborEncode,
+  decode as dagCborDecode
+} from "@ipld/dag-cbor";
+import {
+  array,
+  custom,
+  looseObject,
+  optional,
+  strictObject
+} from "zod/mini";
+import { CHANNEL_ATTESTATION_METHOD_SHA256_ED25519 } from "../2-primitives/3-channel-attestations";
+import { ALLOWED_ATTESTATION_METHOD_HMAC_SHA256 } from "../2-primitives/4-allowed-attestations";
+import {
+  STRING_ENCODER_METHOD_BASE64URL
+} from "../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
+          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]: 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
+            ALLOWED_ATTESTATION_METHOD_HMAC_SHA256,
+            allowedActor
+          )
+        )
+      );
+      objectData[ALLOWED_ATTESTATIONS_PROPERTY] = allowedAttestations.map(
+        (a) => a.attestation
+      );
+      allowedTickets = allowedAttestations.map((a) => a.ticket);
+    }
+    const objectBytes = dagCborEncode(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
+      CONTENT_ADDRESS_METHOD_SHA256,
+      objectBytes
+    );
+    const objectContentAddress = await this.primitives.stringEncoder.encode(
+      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 = dagCborDecode(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 = dagCborEncode(value);
+    const expectedValueBytes = dagCborEncode(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 = custom(
+  (v) => v instanceof Uint8Array
+);
+const ObjectDataSchema = strictObject({
+  [VALUE_PROPERTY]: looseObject({}),
+  [CHANNEL_ATTESTATIONS_PROPERTY]: array(Uint8ArraySchema),
+  [ALLOWED_ATTESTATIONS_PROPERTY]: optional(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;
+}
+export {
+  GRAFFITI_OBJECT_URL_PREFIX,
+  MAX_OBJECT_SIZE_BYTES,
+  ObjectEncoding,
+  decodeObjectUrl,
+  decodeObjectUrlComponent,
+  encodeObjectUrl,
+  encodeObjectUrlComponent
+};
+//# sourceMappingURL=3-object-encoding.js.map

package/dist/esm/3-protocol/3-object-encoding.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/3-protocol/3-object-encoding.ts"],
+  "sourcesContent": ["import type { JSONSchema } from \"json-schema-to-ts\";\nimport type {\n  GraffitiObject,\n  GraffitiObjectBase,\n  GraffitiPostObject,\n} from \"@graffiti-garden/api\";\nimport type { ChannelAttestations } from \"../2-primitives/3-channel-attestations\";\nimport type { AllowedAttestations } from \"../2-primitives/4-allowed-attestations\";\nimport {\n  CONTENT_ADDRESS_METHOD_SHA256,\n  type ContentAddresses,\n} from \"../2-primitives/2-content-addresses\";\nimport { randomBytes } from \"@noble/hashes/utils.js\";\nimport {\n  encode as dagCborEncode,\n  decode as dagCborDecode,\n} from \"@ipld/dag-cbor\";\nimport {\n  type infer as infer_,\n  array,\n  custom,\n  looseObject,\n  optional,\n  strictObject,\n} from \"zod/mini\";\nimport { CHANNEL_ATTESTATION_METHOD_SHA256_ED25519 } from \"../2-primitives/3-channel-attestations\";\nimport { ALLOWED_ATTESTATION_METHOD_HMAC_SHA256 } from \"../2-primitives/4-allowed-attestations\";\nimport {\n  STRING_ENCODER_METHOD_BASE64URL,\n  type StringEncoder,\n} from \"../2-primitives/1-string-encoding\";\n\n// Objects have a max size of 32kb\n// If each channel and allowed actor takes 32 bytes\n// of space (i.e. they are hashed with 256 bit security)\n// then this means that the combined number of channels\n// and recipients of object has cannot exceed one thousand.\n// This seems like a reasonable limit and on par with\n// signal's group chat limit of 1000\nexport const MAX_OBJECT_SIZE_BYTES = 32 * 1024;\n\nexport class ObjectEncoding {\n  constructor(\n    protected readonly primitives: {\n      readonly stringEncoder: StringEncoder;\n      readonly channelAttestations: ChannelAttestations;\n      readonly allowedAttestations: AllowedAttestations;\n      readonly contentAddresses: ContentAddresses;\n    },\n  ) {}\n\n  async encode<Schema extends JSONSchema>(\n    partialObject: GraffitiPostObject<Schema>,\n    actor: string,\n  ): Promise<{\n    object: GraffitiObject<Schema>;\n    tags: Uint8Array[];\n    objectBytes: Uint8Array;\n    allowedTickets: Uint8Array[] | undefined;\n  }> {\n    // Clean out any undefineds\n    partialObject = cleanUndefined(partialObject);\n\n    // Create a verifiable attestation that the actor\n    // knows the included channels without\n    // directly revealing any channel to anyone who doesn't\n    // know the channel already\n    const channelAttestationAndPublicIds = await Promise.all(\n      partialObject.channels.map((channel) =>\n        this.primitives.channelAttestations.attest(\n          // TODO: get this from the DID document of the actor\n          CHANNEL_ATTESTATION_METHOD_SHA256_ED25519,\n          actor,\n          channel,\n        ),\n      ),\n    );\n    const channelAttestations = channelAttestationAndPublicIds.map(\n      (c) => c.attestation,\n    );\n    const channelPublicIds = channelAttestationAndPublicIds.map(\n      (c) => c.channelPublicId,\n    );\n\n    const objectData: infer_<typeof ObjectDataSchema> = {\n      [VALUE_PROPERTY]: partialObject.value,\n      [CHANNEL_ATTESTATIONS_PROPERTY]: channelAttestations,\n      [NONCE_PROPERTY]: randomBytes(32),\n    };\n\n    let allowedTickets: Uint8Array[] | undefined = undefined;\n\n    // If the object is private...\n    if (Array.isArray(partialObject.allowed)) {\n      // Create an attestation that the object's allowed list\n      // includes the given actors, without revealing the\n      // presence of an actor on the list to anyone except\n      // that actor themselves. Each actor will receive a\n      // \"ticket\" that they can use to verify their own membership\n      // on the allowed list.\n      const allowedAttestations = await Promise.all(\n        partialObject.allowed.map(async (allowedActor) =>\n          this.primitives.allowedAttestations.attest(\n            // TODO: get this from the DID document of the actor\n            ALLOWED_ATTESTATION_METHOD_HMAC_SHA256,\n            allowedActor,\n          ),\n        ),\n      );\n      objectData[ALLOWED_ATTESTATIONS_PROPERTY] = allowedAttestations.map(\n        (a) => a.attestation,\n      );\n      allowedTickets = allowedAttestations.map((a) => a.ticket);\n    }\n\n    // Encode the mixed JSON/binary data using CBOR\n    const objectBytes = dagCborEncode(objectData);\n    if (objectBytes.byteLength > MAX_OBJECT_SIZE_BYTES) {\n      throw new Error(\"The object is too large\");\n    }\n\n    // Compute a public identifier (hash) of the object data\n    const objectContentAddressBytes =\n      await this.primitives.contentAddresses.register(\n        // TODO: get this from the DID document of the actor\n        CONTENT_ADDRESS_METHOD_SHA256,\n        objectBytes,\n      );\n    const objectContentAddress = await this.primitives.stringEncoder.encode(\n      STRING_ENCODER_METHOD_BASE64URL,\n      objectContentAddressBytes,\n    );\n    // Use it to compute the object's URL\n    const objectUrl = encodeObjectUrl(actor, objectContentAddress);\n\n    const tags = [new TextEncoder().encode(objectUrl), ...channelPublicIds];\n\n    const object: GraffitiObject<Schema> = {\n      value: partialObject.value,\n      channels: partialObject.channels,\n      url: objectUrl,\n      actor,\n      ...(partialObject.allowed\n        ? {\n            allowed: partialObject.allowed,\n          }\n        : {}),\n    } as GraffitiObject<Schema>;\n\n    // Return object URL and allowed secrets\n    return {\n      object,\n      tags,\n      objectBytes,\n      allowedTickets,\n    };\n  }\n\n  async validate(\n    object: GraffitiObjectBase,\n    tags: Uint8Array[],\n    objectBytes: Uint8Array,\n    privateObjectInfo?:\n      | {\n          recipient: string;\n          allowedTicket: Uint8Array;\n          allowedIndex: number;\n        }\n      | {\n          allowedTickets: Uint8Array[];\n        },\n  ): Promise<void> {\n    if (objectBytes.byteLength > MAX_OBJECT_SIZE_BYTES) {\n      throw new Error(\"Object is too big\");\n    }\n    const { actor, contentAddress } = decodeObjectUrl(object.url);\n    if (actor !== object.actor) {\n      throw new Error(\"Object actor does not match URL actor\");\n    }\n\n    const objectUrlTag = tags.at(0);\n    if (!objectUrlTag) {\n      throw new Error(\"No object URL tag\");\n    }\n    if (new TextDecoder().decode(objectUrlTag) !== object.url) {\n      throw new Error(\"Object URL tag does not match object URL\");\n    }\n    const channelPublicIds = tags.slice(1);\n\n    // Make sure the object content address matches the object content\n    const contentAddressBytes =\n      await this.primitives.stringEncoder.decode(contentAddress);\n    const contentAddressMethod =\n      await this.primitives.contentAddresses.getMethod(contentAddressBytes);\n    const expectedContentAddress =\n      await this.primitives.contentAddresses.register(\n        contentAddressMethod,\n        objectBytes,\n      );\n    if (\n      expectedContentAddress.length !== contentAddressBytes.length ||\n      !expectedContentAddress.every((b, i) => b === contentAddressBytes[i])\n    ) {\n      throw new Error(\"Content address is invalid\");\n    }\n\n    // Convert the raw object data from CBOR\n    // back to a javascript object\n    const objectDataUnknown = dagCborDecode(objectBytes);\n    const objectData = ObjectDataSchema.parse(objectDataUnknown);\n\n    // And extract the values\n    const value = objectData[VALUE_PROPERTY];\n    const channelAttestations = objectData[CHANNEL_ATTESTATIONS_PROPERTY];\n    const allowedAttestations = objectData[ALLOWED_ATTESTATIONS_PROPERTY];\n\n    // Validate that the object's value matches\n    const valueBytes = dagCborEncode(value);\n    const expectedValueBytes = dagCborEncode(object.value);\n    if (\n      valueBytes.length !== expectedValueBytes.length ||\n      !valueBytes.every((b, i) => b === expectedValueBytes[i])\n    ) {\n      throw new Error(\"Object value does not match storage value\");\n    }\n\n    // Validate the object's channels\n    if (channelAttestations.length !== channelPublicIds.length) {\n      throw new Error(\"Not as many channel attestations and public ids\");\n    }\n    for (const [index, attestation] of channelAttestations.entries()) {\n      const channelPublicId = channelPublicIds[index];\n      const isValid = await this.primitives.channelAttestations.validate(\n        attestation,\n        actor,\n        channelPublicId,\n      );\n      if (!isValid) {\n        throw new Error(\"Invalid channel attestation\");\n      }\n    }\n    if (object.channels.length) {\n      // If any channels are included, they all must be included\n      if (object.channels.length !== channelPublicIds.length) {\n        throw new Error(\n          \"Number of claimed channels does not match attestations/public IDs\",\n        );\n      }\n      const channelAttestationMethod =\n        await this.primitives.channelAttestations.getMethod(\n          channelPublicIds[0],\n        );\n      const expectedChannelPublicIds = await Promise.all(\n        object.channels.map((channel) =>\n          this.primitives.channelAttestations.register(\n            channelAttestationMethod,\n            channel,\n          ),\n        ),\n      );\n      for (const [\n        index,\n        expectedPublicId,\n      ] of expectedChannelPublicIds.entries()) {\n        const actualPublicId = channelPublicIds[index];\n        if (\n          expectedPublicId.length !== actualPublicId.length ||\n          !expectedPublicId.every((b, i) => b === actualPublicId[i])\n        ) {\n          throw new Error(\"Channel public id does not match expected\");\n        }\n      }\n    }\n\n    // Validate the recipient\n    if (privateObjectInfo) {\n      if (!allowedAttestations) {\n        throw new Error(\"Object is public but thought to be private\");\n      }\n\n      let recipients: string[];\n      let allowedTickets: Uint8Array[];\n      let attestations: Uint8Array[];\n      if (\"recipient\" in privateObjectInfo) {\n        recipients = [privateObjectInfo.recipient];\n        allowedTickets = [privateObjectInfo.allowedTicket];\n        attestations = allowedAttestations.filter(\n          (_, i) => i === privateObjectInfo.allowedIndex,\n        );\n      } else {\n        recipients = [...(object.allowed ?? [])];\n        allowedTickets = privateObjectInfo.allowedTickets;\n        attestations = allowedAttestations;\n      }\n\n      // All recipients must be in the allowed list\n      if (recipients.length !== object.allowed?.length) {\n        throw new Error(\"Recipient count does not match object allowed list\");\n      }\n      if (!recipients.every((r) => object.allowed?.includes(r))) {\n        throw new Error(\"Recipient not in object allowed list\");\n      }\n\n      for (const [index, recipient] of recipients.entries()) {\n        const allowedTicket = allowedTickets.at(index);\n        const allowedAttestation = attestations.at(index);\n        if (!allowedTicket) {\n          throw new Error(\"Missing allowed ticket for recipient\");\n        }\n        if (!allowedAttestation) {\n          throw new Error(\"Missing allowed attestation for recipient\");\n        }\n        const isValid = await this.primitives.allowedAttestations.validate(\n          allowedAttestation,\n          recipient,\n          allowedTicket,\n        );\n\n        if (!isValid) {\n          throw new Error(\"Invalid allowed attestation for recipient\");\n        }\n      }\n    } else if (allowedAttestations) {\n      throw new Error(\"Object is private but no recipient info provided\");\n    }\n  }\n}\n\n// A compact data representation of the object data\nconst VALUE_PROPERTY = \"v\";\nconst CHANNEL_ATTESTATIONS_PROPERTY = \"c\";\nconst ALLOWED_ATTESTATIONS_PROPERTY = \"a\";\nconst NONCE_PROPERTY = \"n\";\n\nconst Uint8ArraySchema = custom<Uint8Array>(\n  (v): v is Uint8Array => v instanceof Uint8Array,\n);\n\nconst ObjectDataSchema = strictObject({\n  [VALUE_PROPERTY]: looseObject({}),\n  [CHANNEL_ATTESTATIONS_PROPERTY]: array(Uint8ArraySchema),\n  [ALLOWED_ATTESTATIONS_PROPERTY]: optional(array(Uint8ArraySchema)),\n  [NONCE_PROPERTY]: Uint8ArraySchema,\n});\n\nexport const GRAFFITI_OBJECT_URL_PREFIX = \"graffiti:\";\n\n// Methods to encode and decode object URLs\nexport function encodeObjectUrlComponent(value: string) {\n  const replaced = value.replace(/:/g, \"!\").replace(/\\//g, \"~\");\n  return encodeURIComponent(replaced);\n}\nexport function decodeObjectUrlComponent(value: string) {\n  const decoded = decodeURIComponent(value);\n  return decoded.replace(/!/g, \":\").replace(/~/g, \"/\");\n}\nexport function encodeObjectUrl(actor: string, contentAddress: string) {\n  return `${GRAFFITI_OBJECT_URL_PREFIX}${encodeObjectUrlComponent(actor)}:${encodeObjectUrlComponent(contentAddress)}`;\n}\nexport function decodeObjectUrl(objectUrl: string) {\n  if (!objectUrl.startsWith(GRAFFITI_OBJECT_URL_PREFIX)) {\n    throw new Error(\"Invalid object URL\");\n  }\n\n  const rest = objectUrl.slice(GRAFFITI_OBJECT_URL_PREFIX.length);\n  const parts = rest.split(\":\");\n\n  if (parts.length !== 2) {\n    throw new Error(\"Invalid object URL format\");\n  }\n\n  const [actor, contentAddress] = parts;\n\n  return {\n    actor: decodeObjectUrlComponent(actor),\n    contentAddress: decodeObjectUrlComponent(contentAddress),\n  };\n}\n\nfunction cleanUndefined(value: any): any {\n  if (value === undefined) return null;\n\n  if (Array.isArray(value)) {\n    return value.map(cleanUndefined);\n  }\n\n  if (typeof value === \"object\") {\n    return Object.fromEntries(\n      Object.entries(value)\n        .filter(([, v]) => v !== undefined)\n        .map(([k, v]) => [k, cleanUndefined(v)]),\n    );\n  }\n\n  return value;\n}\n"],
+  "mappings": "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",
+  "names": []
+}