@graffiti-garden/implementation-decentralized 0.0.1

package/dist/cjs/1-services/utilities.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/1-services/utilities.ts"],
+  "sourcesContent": ["import {\n  GraffitiErrorCursorExpired,\n  GraffitiErrorForbidden,\n  GraffitiErrorNotFound,\n  GraffitiErrorTooLarge,\n} from \"@graffiti-garden/api\";\n\nconst SERVICE_ENDPOINT_PREFIX_HTTPS = \"https://\";\nexport function verifyHTTPSEndpoint(endpoint: string): void {\n  if (!endpoint.startsWith(SERVICE_ENDPOINT_PREFIX_HTTPS)) {\n    throw new Error(\"Unrecognized storage bucket endpoint type\");\n  }\n}\n\nexport async function getAuthorizationEndpoint(\n  serviceEndpoint: string,\n): Promise<string> {\n  verifyHTTPSEndpoint(serviceEndpoint);\n  const authUrl = `${serviceEndpoint}/auth`;\n\n  const response = await fetch(authUrl);\n  if (!response.ok) {\n    throw new Error(\"Failed to get storage bucket authorization endpoint\");\n  }\n  return await response.text();\n}\n\nexport class GraffitiErrorUnauthorized extends Error {\n  constructor(message?: string) {\n    super(message);\n    this.name = \"GraffitiErrorUnauthorized\";\n    Object.setPrototypeOf(this, GraffitiErrorUnauthorized.prototype);\n  }\n}\n\nexport async function fetchWithErrorHandling(\n  ...args: Parameters<typeof fetch>\n) {\n  const response = await fetch(...args);\n\n  if (!response.ok) {\n    let errorText: string;\n    try {\n      errorText = await response.text();\n    } catch {\n      errorText = response.statusText;\n    }\n\n    if (response.status === 401) {\n      throw new GraffitiErrorUnauthorized(errorText);\n    } else if (response.status === 403) {\n      throw new GraffitiErrorForbidden(errorText);\n    } else if (response.status === 404) {\n      throw new GraffitiErrorNotFound(errorText);\n    } else if (response.status === 410) {\n      throw new GraffitiErrorCursorExpired(errorText);\n    } else if (response.status === 413) {\n      throw new GraffitiErrorTooLarge(errorText);\n    } else {\n      throw new Error(errorText);\n    }\n  }\n\n  return response;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAKO;AAEP,MAAM,gCAAgC;AAC/B,SAAS,oBAAoB,UAAwB;AAC1D,MAAI,CAAC,SAAS,WAAW,6BAA6B,GAAG;AACvD,UAAM,IAAI,MAAM,2CAA2C;AAAA,EAC7D;AACF;AAEA,eAAsB,yBACpB,iBACiB;AACjB,sBAAoB,eAAe;AACnC,QAAM,UAAU,GAAG,eAAe;AAElC,QAAM,WAAW,MAAM,MAAM,OAAO;AACpC,MAAI,CAAC,SAAS,IAAI;AAChB,UAAM,IAAI,MAAM,qDAAqD;AAAA,EACvE;AACA,SAAO,MAAM,SAAS,KAAK;AAC7B;AAEO,MAAM,kCAAkC,MAAM;AAAA,EACnD,YAAY,SAAkB;AAC5B,UAAM,OAAO;AACb,SAAK,OAAO;AACZ,WAAO,eAAe,MAAM,0BAA0B,SAAS;AAAA,EACjE;AACF;AAEA,eAAsB,0BACjB,MACH;AACA,QAAM,WAAW,MAAM,MAAM,GAAG,IAAI;AAEpC,MAAI,CAAC,SAAS,IAAI;AAChB,QAAI;AACJ,QAAI;AACF,kBAAY,MAAM,SAAS,KAAK;AAAA,IAClC,QAAQ;AACN,kBAAY,SAAS;AAAA,IACvB;AAEA,QAAI,SAAS,WAAW,KAAK;AAC3B,YAAM,IAAI,0BAA0B,SAAS;AAAA,IAC/C,WAAW,SAAS,WAAW,KAAK;AAClC,YAAM,IAAI,kCAAuB,SAAS;AAAA,IAC5C,WAAW,SAAS,WAAW,KAAK;AAClC,YAAM,IAAI,iCAAsB,SAAS;AAAA,IAC3C,WAAW,SAAS,WAAW,KAAK;AAClC,YAAM,IAAI,sCAA2B,SAAS;AAAA,IAChD,WAAW,SAAS,WAAW,KAAK;AAClC,YAAM,IAAI,iCAAsB,SAAS;AAAA,IAC3C,OAAO;AACL,YAAM,IAAI,MAAM,SAAS;AAAA,IAC3B;AAAA,EACF;AAEA,SAAO;AACT;",
+  "names": []
+}

package/dist/cjs/2-primitives/1-string-encoding-tests.js

@@ -0,0 +1,50 @@
+"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 string_encoding_tests_exports = {};
+__export(string_encoding_tests_exports, {
+  stringEncodingTests: () => stringEncodingTests
+});
+module.exports = __toCommonJS(string_encoding_tests_exports);
+var import_vitest = require("vitest");
+var import_string_encoding = require("./1-string-encoding");
+var import_utils = require("@noble/hashes/utils.js");
+function stringEncodingTests() {
+  (0, import_vitest.describe)("String encoding tests", () => {
+    const stringEncodingMethods = [import_string_encoding.STRING_ENCODER_METHOD_BASE64URL];
+    const stringEncoder = new import_string_encoding.StringEncoder();
+    (0, import_vitest.test)("Invalid string decoding method", async () => {
+      const bytes = (0, import_utils.randomBytes)();
+      await (0, import_vitest.expect)(
+        () => stringEncoder.encode("invalid-method", bytes)
+      ).rejects.toThrow();
+    });
+    for (const method of stringEncodingMethods) {
+      (0, import_vitest.describe)(`String Encoding Method: ${method}`, () => {
+        (0, import_vitest.test)("encodes and decodes strings correctly", async () => {
+          const bytes = (0, import_utils.randomBytes)();
+          const encoded = await stringEncoder.encode(method, bytes);
+          const decoded = await stringEncoder.decode(encoded);
+          (0, import_vitest.expect)(decoded).toEqual(bytes);
+          (0, import_vitest.expect)(decoded).not.toEqual((0, import_utils.randomBytes)());
+        });
+      });
+    }
+  });
+}
+//# sourceMappingURL=1-string-encoding-tests.js.map

package/dist/cjs/2-primitives/1-string-encoding-tests.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/2-primitives/1-string-encoding-tests.ts"],
+  "sourcesContent": ["import { describe, expect, test } from \"vitest\";\nimport {\n  STRING_ENCODER_METHOD_BASE64URL,\n  StringEncoder,\n} from \"./1-string-encoding\";\nimport { randomBytes } from \"@noble/hashes/utils.js\";\n\nexport function stringEncodingTests() {\n  describe(\"String encoding tests\", () => {\n    const stringEncodingMethods = [STRING_ENCODER_METHOD_BASE64URL];\n    const stringEncoder = new StringEncoder();\n\n    test(\"Invalid string decoding method\", async () => {\n      const bytes = randomBytes();\n      await expect(() =>\n        stringEncoder.encode(\"invalid-method\", bytes),\n      ).rejects.toThrow();\n    });\n\n    for (const method of stringEncodingMethods) {\n      describe(`String Encoding Method: ${method}`, () => {\n        test(\"encodes and decodes strings correctly\", async () => {\n          const bytes = randomBytes();\n          const encoded = await stringEncoder.encode(method, bytes);\n          const decoded = await stringEncoder.decode(encoded);\n\n          expect(decoded).toEqual(bytes);\n          expect(decoded).not.toEqual(randomBytes());\n        });\n      });\n    }\n  });\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAuC;AACvC,6BAGO;AACP,mBAA4B;AAErB,SAAS,sBAAsB;AACpC,8BAAS,yBAAyB,MAAM;AACtC,UAAM,wBAAwB,CAAC,sDAA+B;AAC9D,UAAM,gBAAgB,IAAI,qCAAc;AAExC,4BAAK,kCAAkC,YAAY;AACjD,YAAM,YAAQ,0BAAY;AAC1B,gBAAM;AAAA,QAAO,MACX,cAAc,OAAO,kBAAkB,KAAK;AAAA,MAC9C,EAAE,QAAQ,QAAQ;AAAA,IACpB,CAAC;AAED,eAAW,UAAU,uBAAuB;AAC1C,kCAAS,2BAA2B,MAAM,IAAI,MAAM;AAClD,gCAAK,yCAAyC,YAAY;AACxD,gBAAM,YAAQ,0BAAY;AAC1B,gBAAM,UAAU,MAAM,cAAc,OAAO,QAAQ,KAAK;AACxD,gBAAM,UAAU,MAAM,cAAc,OAAO,OAAO;AAElD,oCAAO,OAAO,EAAE,QAAQ,KAAK;AAC7B,oCAAO,OAAO,EAAE,IAAI,YAAQ,0BAAY,CAAC;AAAA,QAC3C,CAAC;AAAA,MACH,CAAC;AAAA,IACH;AAAA,EACF,CAAC;AACH;",
+  "names": []
+}

package/dist/cjs/2-primitives/1-string-encoding.js

@@ -0,0 +1,46 @@
+"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 string_encoding_exports = {};
+__export(string_encoding_exports, {
+  STRING_ENCODER_METHOD_BASE64URL: () => STRING_ENCODER_METHOD_BASE64URL,
+  StringEncoder: () => StringEncoder
+});
+module.exports = __toCommonJS(string_encoding_exports);
+const STRING_ENCODER_METHOD_BASE64URL = "base64url";
+const STRING_ENCODER_PREFIX_BASE64URL = "u";
+class StringEncoder {
+  async encode(method, bytes) {
+    if (method !== STRING_ENCODER_METHOD_BASE64URL) {
+      throw new Error(`Unsupported string encoding method: ${method}`);
+    }
+    const base64 = btoa(String.fromCodePoint(...bytes));
+    const encoded = base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/\=+$/, "");
+    return STRING_ENCODER_PREFIX_BASE64URL + encoded;
+  }
+  async decode(base64Url) {
+    if (!base64Url.startsWith(STRING_ENCODER_PREFIX_BASE64URL)) {
+      throw new Error(`Unsupported string encoding prefix: ${base64Url[0]}`);
+    }
+    base64Url = base64Url.slice(1);
+    let base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
+    while (base64.length % 4 !== 0) base64 += "=";
+    return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
+  }
+}
+//# sourceMappingURL=1-string-encoding.js.map

package/dist/cjs/2-primitives/1-string-encoding.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/2-primitives/1-string-encoding.ts"],
+  "sourcesContent": ["// https://github.com/multiformats/multibase/blob/master/multibase.csv\nexport const STRING_ENCODER_METHOD_BASE64URL = \"base64url\";\nconst STRING_ENCODER_PREFIX_BASE64URL = \"u\";\n\nexport class StringEncoder {\n  async encode(method: string, bytes: Uint8Array): Promise<string> {\n    if (method !== STRING_ENCODER_METHOD_BASE64URL) {\n      throw new Error(`Unsupported string encoding method: ${method}`);\n    }\n    // Convert it to base64\n    const base64 = btoa(String.fromCodePoint(...bytes));\n    // Make sure it is url safe\n    const encoded = base64\n      .replace(/\\+/g, \"-\")\n      .replace(/\\//g, \"_\")\n      .replace(/\\=+$/, \"\");\n    // Append method prefix\n    return STRING_ENCODER_PREFIX_BASE64URL + encoded;\n  }\n\n  async decode(base64Url: string): Promise<Uint8Array> {\n    if (!base64Url.startsWith(STRING_ENCODER_PREFIX_BASE64URL)) {\n      throw new Error(`Unsupported string encoding prefix: ${base64Url[0]}`);\n    }\n    base64Url = base64Url.slice(1);\n    // Undo url-safe base64\n    let base64 = base64Url.replace(/-/g, \"+\").replace(/_/g, \"/\");\n    // Add padding if necessary\n    while (base64.length % 4 !== 0) base64 += \"=\";\n    // Decode\n    return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACO,MAAM,kCAAkC;AAC/C,MAAM,kCAAkC;AAEjC,MAAM,cAAc;AAAA,EACzB,MAAM,OAAO,QAAgB,OAAoC;AAC/D,QAAI,WAAW,iCAAiC;AAC9C,YAAM,IAAI,MAAM,uCAAuC,MAAM,EAAE;AAAA,IACjE;AAEA,UAAM,SAAS,KAAK,OAAO,cAAc,GAAG,KAAK,CAAC;AAElD,UAAM,UAAU,OACb,QAAQ,OAAO,GAAG,EAClB,QAAQ,OAAO,GAAG,EAClB,QAAQ,QAAQ,EAAE;AAErB,WAAO,kCAAkC;AAAA,EAC3C;AAAA,EAEA,MAAM,OAAO,WAAwC;AACnD,QAAI,CAAC,UAAU,WAAW,+BAA+B,GAAG;AAC1D,YAAM,IAAI,MAAM,uCAAuC,UAAU,CAAC,CAAC,EAAE;AAAA,IACvE;AACA,gBAAY,UAAU,MAAM,CAAC;AAE7B,QAAI,SAAS,UAAU,QAAQ,MAAM,GAAG,EAAE,QAAQ,MAAM,GAAG;AAE3D,WAAO,OAAO,SAAS,MAAM,EAAG,WAAU;AAE1C,WAAO,WAAW,KAAK,KAAK,MAAM,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;AAAA,EAC7D;AACF;",
+  "names": []
+}

package/dist/cjs/2-primitives/2-content-addresses-tests.js

@@ -0,0 +1,62 @@
+"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 content_addresses_tests_exports = {};
+__export(content_addresses_tests_exports, {
+  contentAddressesTests: () => contentAddressesTests
+});
+module.exports = __toCommonJS(content_addresses_tests_exports);
+var import_vitest = require("vitest");
+var import_content_addresses = require("./2-content-addresses");
+var import_utils = require("@noble/hashes/utils.js");
+function contentAddressesTests() {
+  (0, import_vitest.describe)("Content Address Tests", () => {
+    const contentAddressMethods = [import_content_addresses.CONTENT_ADDRESS_METHOD_SHA256];
+    const contentAddresses = new import_content_addresses.ContentAddresses();
+    (0, import_vitest.test)("Invalid content address method", async () => {
+      const bytes = (0, import_utils.randomBytes)();
+      await (0, import_vitest.expect)(
+        () => contentAddresses.register("invalid-method", bytes)
+      ).rejects.toThrow();
+    });
+    for (const method of contentAddressMethods) {
+      (0, import_vitest.describe)(`Content Address Method: ${method}`, () => {
+        (0, import_vitest.test)("idempotent addresses", async () => {
+          const bytes = (0, import_utils.randomBytes)();
+          const address1 = await contentAddresses.register(method, bytes);
+          const address2 = await contentAddresses.register(method, bytes);
+          (0, import_vitest.expect)(address1).toEqual(address2);
+        });
+        (0, import_vitest.test)("unique adddresses", async () => {
+          const bytes1 = (0, import_utils.randomBytes)();
+          const bytes2 = (0, import_utils.randomBytes)();
+          const address1 = await contentAddresses.register(method, bytes1);
+          const address2 = await contentAddresses.register(method, bytes2);
+          (0, import_vitest.expect)(address1).not.toEqual(address2);
+        });
+        (0, import_vitest.test)("get method", async () => {
+          const bytes = (0, import_utils.randomBytes)();
+          const address = await contentAddresses.register(method, bytes);
+          const retrievedMethod = await contentAddresses.getMethod(address);
+          (0, import_vitest.expect)(retrievedMethod).toEqual(method);
+        });
+      });
+    }
+  });
+}
+//# sourceMappingURL=2-content-addresses-tests.js.map

package/dist/cjs/2-primitives/2-content-addresses-tests.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/2-primitives/2-content-addresses-tests.ts"],
+  "sourcesContent": ["import { describe, expect, test } from \"vitest\";\nimport {\n  CONTENT_ADDRESS_METHOD_SHA256,\n  ContentAddresses,\n} from \"./2-content-addresses\";\nimport { randomBytes } from \"@noble/hashes/utils.js\";\n\nexport function contentAddressesTests() {\n  describe(\"Content Address Tests\", () => {\n    const contentAddressMethods = [CONTENT_ADDRESS_METHOD_SHA256];\n    const contentAddresses = new ContentAddresses();\n\n    test(\"Invalid content address method\", async () => {\n      const bytes = randomBytes();\n      await expect(() =>\n        contentAddresses.register(\"invalid-method\", bytes),\n      ).rejects.toThrow();\n    });\n\n    for (const method of contentAddressMethods) {\n      describe(`Content Address Method: ${method}`, () => {\n        test(\"idempotent addresses\", async () => {\n          const bytes = randomBytes();\n          const address1 = await contentAddresses.register(method, bytes);\n          const address2 = await contentAddresses.register(method, bytes);\n          expect(address1).toEqual(address2);\n        });\n\n        test(\"unique adddresses\", async () => {\n          const bytes1 = randomBytes();\n          const bytes2 = randomBytes();\n          const address1 = await contentAddresses.register(method, bytes1);\n          const address2 = await contentAddresses.register(method, bytes2);\n          expect(address1).not.toEqual(address2);\n        });\n\n        test(\"get method\", async () => {\n          const bytes = randomBytes();\n          const address = await contentAddresses.register(method, bytes);\n          const retrievedMethod = await contentAddresses.getMethod(address);\n          expect(retrievedMethod).toEqual(method);\n        });\n      });\n    }\n  });\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAuC;AACvC,+BAGO;AACP,mBAA4B;AAErB,SAAS,wBAAwB;AACtC,8BAAS,yBAAyB,MAAM;AACtC,UAAM,wBAAwB,CAAC,sDAA6B;AAC5D,UAAM,mBAAmB,IAAI,0CAAiB;AAE9C,4BAAK,kCAAkC,YAAY;AACjD,YAAM,YAAQ,0BAAY;AAC1B,gBAAM;AAAA,QAAO,MACX,iBAAiB,SAAS,kBAAkB,KAAK;AAAA,MACnD,EAAE,QAAQ,QAAQ;AAAA,IACpB,CAAC;AAED,eAAW,UAAU,uBAAuB;AAC1C,kCAAS,2BAA2B,MAAM,IAAI,MAAM;AAClD,gCAAK,wBAAwB,YAAY;AACvC,gBAAM,YAAQ,0BAAY;AAC1B,gBAAM,WAAW,MAAM,iBAAiB,SAAS,QAAQ,KAAK;AAC9D,gBAAM,WAAW,MAAM,iBAAiB,SAAS,QAAQ,KAAK;AAC9D,oCAAO,QAAQ,EAAE,QAAQ,QAAQ;AAAA,QACnC,CAAC;AAED,gCAAK,qBAAqB,YAAY;AACpC,gBAAM,aAAS,0BAAY;AAC3B,gBAAM,aAAS,0BAAY;AAC3B,gBAAM,WAAW,MAAM,iBAAiB,SAAS,QAAQ,MAAM;AAC/D,gBAAM,WAAW,MAAM,iBAAiB,SAAS,QAAQ,MAAM;AAC/D,oCAAO,QAAQ,EAAE,IAAI,QAAQ,QAAQ;AAAA,QACvC,CAAC;AAED,gCAAK,cAAc,YAAY;AAC7B,gBAAM,YAAQ,0BAAY;AAC1B,gBAAM,UAAU,MAAM,iBAAiB,SAAS,QAAQ,KAAK;AAC7D,gBAAM,kBAAkB,MAAM,iBAAiB,UAAU,OAAO;AAChE,oCAAO,eAAe,EAAE,QAAQ,MAAM;AAAA,QACxC,CAAC;AAAA,MACH,CAAC;AAAA,IACH;AAAA,EACF,CAAC;AACH;",
+  "names": []
+}

package/dist/cjs/2-primitives/2-content-addresses.js

@@ -0,0 +1,53 @@
+"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 content_addresses_exports = {};
+__export(content_addresses_exports, {
+  CONTENT_ADDRESS_METHOD_SHA256: () => CONTENT_ADDRESS_METHOD_SHA256,
+  ContentAddresses: () => ContentAddresses,
+  MULTIHASH_CODE_SHA256: () => MULTIHASH_CODE_SHA256,
+  MULTIHASH_LENGTH_SHA256: () => MULTIHASH_LENGTH_SHA256
+});
+module.exports = __toCommonJS(content_addresses_exports);
+var import_webcrypto = require("@noble/hashes/webcrypto.js");
+const CONTENT_ADDRESS_METHOD_SHA256 = "sha2-256";
+const MULTIHASH_CODE_SHA256 = 18;
+const MULTIHASH_LENGTH_SHA256 = 32;
+class ContentAddresses {
+  async register(contentAddressMethod, data) {
+    if (contentAddressMethod !== CONTENT_ADDRESS_METHOD_SHA256) {
+      throw new Error(
+        `Unsupported content address method: ${contentAddressMethod}`
+      );
+    }
+    const hash = await (0, import_webcrypto.sha256)(data);
+    const prefixedHash = new Uint8Array(2 + hash.length);
+    prefixedHash[0] = MULTIHASH_CODE_SHA256;
+    prefixedHash[1] = MULTIHASH_LENGTH_SHA256;
+    prefixedHash.set(hash, 2);
+    return prefixedHash;
+  }
+  async getMethod(contentAddress) {
+    if (contentAddress[0] === MULTIHASH_CODE_SHA256 && contentAddress[1] === MULTIHASH_LENGTH_SHA256 && contentAddress.length === 2 + MULTIHASH_LENGTH_SHA256) {
+      return CONTENT_ADDRESS_METHOD_SHA256;
+    } else {
+      throw new Error(`Unrecognized content address format.`);
+    }
+  }
+}
+//# sourceMappingURL=2-content-addresses.js.map

package/dist/cjs/2-primitives/2-content-addresses.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/2-primitives/2-content-addresses.ts"],
+  "sourcesContent": ["import { sha256 } from \"@noble/hashes/webcrypto.js\";\n\nexport const CONTENT_ADDRESS_METHOD_SHA256 = \"sha2-256\";\n\n// Multihash code and length for SHA2-256\n// https://multiformats.io/multihash/#sha2-256---256-bits-aka-sha256\nexport const MULTIHASH_CODE_SHA256 = 0x12;\nexport const MULTIHASH_LENGTH_SHA256 = 32;\n\nexport class ContentAddresses {\n  async register(\n    contentAddressMethod: string,\n    data: Uint8Array,\n  ): Promise<Uint8Array> {\n    if (contentAddressMethod !== CONTENT_ADDRESS_METHOD_SHA256) {\n      throw new Error(\n        `Unsupported content address method: ${contentAddressMethod}`,\n      );\n    }\n\n    const hash = await sha256(data);\n\n    const prefixedHash = new Uint8Array(2 + hash.length);\n    prefixedHash[0] = MULTIHASH_CODE_SHA256;\n    prefixedHash[1] = MULTIHASH_LENGTH_SHA256;\n    prefixedHash.set(hash, 2);\n\n    return prefixedHash;\n  }\n\n  async getMethod(contentAddress: Uint8Array): Promise<string> {\n    if (\n      contentAddress[0] === MULTIHASH_CODE_SHA256 &&\n      contentAddress[1] === MULTIHASH_LENGTH_SHA256 &&\n      contentAddress.length === 2 + MULTIHASH_LENGTH_SHA256\n    ) {\n      return CONTENT_ADDRESS_METHOD_SHA256;\n    } else {\n      throw new Error(`Unrecognized content address format.`);\n    }\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAAuB;AAEhB,MAAM,gCAAgC;AAItC,MAAM,wBAAwB;AAC9B,MAAM,0BAA0B;AAEhC,MAAM,iBAAiB;AAAA,EAC5B,MAAM,SACJ,sBACA,MACqB;AACrB,QAAI,yBAAyB,+BAA+B;AAC1D,YAAM,IAAI;AAAA,QACR,uCAAuC,oBAAoB;AAAA,MAC7D;AAAA,IACF;AAEA,UAAM,OAAO,UAAM,yBAAO,IAAI;AAE9B,UAAM,eAAe,IAAI,WAAW,IAAI,KAAK,MAAM;AACnD,iBAAa,CAAC,IAAI;AAClB,iBAAa,CAAC,IAAI;AAClB,iBAAa,IAAI,MAAM,CAAC;AAExB,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,UAAU,gBAA6C;AAC3D,QACE,eAAe,CAAC,MAAM,yBACtB,eAAe,CAAC,MAAM,2BACtB,eAAe,WAAW,IAAI,yBAC9B;AACA,aAAO;AAAA,IACT,OAAO;AACL,YAAM,IAAI,MAAM,sCAAsC;AAAA,IACxD;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/cjs/2-primitives/3-channel-attestations-tests.js

@@ -0,0 +1,130 @@
+"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 channel_attestations_tests_exports = {};
+__export(channel_attestations_tests_exports, {
+  channelAttestationTests: () => channelAttestationTests
+});
+module.exports = __toCommonJS(channel_attestations_tests_exports);
+var import_vitest = require("vitest");
+var import_channel_attestations = require("./3-channel-attestations");
+var import_utils = require("@noble/hashes/utils.js");
+var import_string_encoding = require("./1-string-encoding");
+function channelAttestationTests() {
+  (0, import_vitest.describe)("Channel Attestation Tests", () => {
+    const allowedAttestationMethods = [
+      import_channel_attestations.CHANNEL_ATTESTATION_METHOD_SHA256_ED25519
+    ];
+    const channelAttestations = new import_channel_attestations.ChannelAttestations();
+    async function randomActor() {
+      const bytes = (0, import_utils.randomBytes)();
+      const str = await new import_string_encoding.StringEncoder().encode(
+        import_string_encoding.STRING_ENCODER_METHOD_BASE64URL,
+        bytes
+      );
+      return `did:web:${str}.com`;
+    }
+    async function randomChannel() {
+      const bytes = (0, import_utils.randomBytes)();
+      return await new import_string_encoding.StringEncoder().encode(
+        import_string_encoding.STRING_ENCODER_METHOD_BASE64URL,
+        bytes
+      );
+    }
+    (0, import_vitest.test)("Invalid attestation method", async () => {
+      const actor = await randomActor();
+      await (0, import_vitest.expect)(
+        () => channelAttestations.register("invalid-method", actor)
+      ).rejects.toThrow();
+    });
+    for (const method of allowedAttestationMethods) {
+      (0, import_vitest.describe)(`Attestation Method: ${method}`, () => {
+        (0, import_vitest.test)("get method", async () => {
+          const channel = await randomChannel();
+          const publicId = await channelAttestations.register(method, channel);
+          const methodReturned = await channelAttestations.getMethod(publicId);
+          (0, import_vitest.expect)(methodReturned).toEqual(method);
+        });
+        (0, import_vitest.test)("Idempotent public Ids", async () => {
+          const channel = await randomChannel();
+          const publicId1 = await channelAttestations.register(method, channel);
+          const publicId2 = await channelAttestations.register(method, channel);
+          (0, import_vitest.expect)(publicId1).toEqual(publicId2);
+        });
+        (0, import_vitest.test)("Unique public ids", async () => {
+          const channel1 = await randomChannel();
+          const channel2 = await randomChannel();
+          const publicId1 = await channelAttestations.register(
+            method,
+            channel1
+          );
+          const publicId2 = await channelAttestations.register(
+            method,
+            channel2
+          );
+          (0, import_vitest.expect)(publicId1).not.toEqual(publicId2);
+        });
+        (0, import_vitest.test)("Valid attestation", async () => {
+          const actor = await randomActor();
+          const channel = await randomChannel();
+          const { attestation, channelPublicId } = await channelAttestations.attest(method, actor, channel);
+          const isValid = await channelAttestations.validate(
+            attestation,
+            actor,
+            channelPublicId
+          );
+          (0, import_vitest.expect)(isValid).toBe(true);
+          const channelPublicIdSeperate = await channelAttestations.register(
+            method,
+            channel
+          );
+          (0, import_vitest.expect)(channelPublicId).toEqual(channelPublicIdSeperate);
+        });
+        (0, import_vitest.test)("Invalid attestation with wrong actor", async () => {
+          const actor = await randomActor();
+          const wrongActor = await randomActor();
+          const channel = await randomChannel();
+          const { attestation, channelPublicId } = await channelAttestations.attest(method, actor, channel);
+          const isValid = await channelAttestations.validate(
+            attestation,
+            wrongActor,
+            channelPublicId
+          );
+          (0, import_vitest.expect)(isValid).toBe(false);
+        });
+        (0, import_vitest.test)("Invalid attestation with wrong channel", async () => {
+          const actor = await randomActor();
+          const channel = await randomChannel();
+          const wrongChannel = await randomChannel();
+          const { attestation, channelPublicId } = await channelAttestations.attest(method, actor, channel);
+          const wrongChannelPublicId = await channelAttestations.register(
+            method,
+            wrongChannel
+          );
+          const isValid = await channelAttestations.validate(
+            attestation,
+            actor,
+            wrongChannelPublicId
+          );
+          (0, import_vitest.expect)(isValid).toBe(false);
+        });
+      });
+    }
+  });
+}
+//# sourceMappingURL=3-channel-attestations-tests.js.map

package/dist/cjs/2-primitives/3-channel-attestations-tests.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/2-primitives/3-channel-attestations-tests.ts"],
+  "sourcesContent": ["import { describe, expect, test } from \"vitest\";\nimport {\n  CHANNEL_ATTESTATION_METHOD_SHA256_ED25519,\n  ChannelAttestations,\n} from \"./3-channel-attestations\";\nimport { randomBytes } from \"@noble/hashes/utils.js\";\nimport {\n  StringEncoder,\n  STRING_ENCODER_METHOD_BASE64URL,\n} from \"./1-string-encoding\";\n\nexport function channelAttestationTests() {\n  describe(\"Channel Attestation Tests\", () => {\n    const allowedAttestationMethods = [\n      CHANNEL_ATTESTATION_METHOD_SHA256_ED25519,\n    ];\n    const channelAttestations = new ChannelAttestations();\n\n    async function randomActor() {\n      const bytes = randomBytes();\n      const str = await new StringEncoder().encode(\n        STRING_ENCODER_METHOD_BASE64URL,\n        bytes,\n      );\n      return `did:web:${str}.com`;\n    }\n    async function randomChannel() {\n      const bytes = randomBytes();\n      return await new StringEncoder().encode(\n        STRING_ENCODER_METHOD_BASE64URL,\n        bytes,\n      );\n    }\n\n    test(\"Invalid attestation method\", async () => {\n      const actor = await randomActor();\n      await expect(() =>\n        channelAttestations.register(\"invalid-method\", actor),\n      ).rejects.toThrow();\n    });\n\n    for (const method of allowedAttestationMethods) {\n      describe(`Attestation Method: ${method}`, () => {\n        test(\"get method\", async () => {\n          const channel = await randomChannel();\n          const publicId = await channelAttestations.register(method, channel);\n          const methodReturned = await channelAttestations.getMethod(publicId);\n          expect(methodReturned).toEqual(method);\n        });\n\n        test(\"Idempotent public Ids\", async () => {\n          const channel = await randomChannel();\n          const publicId1 = await channelAttestations.register(method, channel);\n          const publicId2 = await channelAttestations.register(method, channel);\n          expect(publicId1).toEqual(publicId2);\n        });\n\n        test(\"Unique public ids\", async () => {\n          const channel1 = await randomChannel();\n          const channel2 = await randomChannel();\n          const publicId1 = await channelAttestations.register(\n            method,\n            channel1,\n          );\n          const publicId2 = await channelAttestations.register(\n            method,\n            channel2,\n          );\n          expect(publicId1).not.toEqual(publicId2);\n        });\n\n        test(\"Valid attestation\", async () => {\n          const actor = await randomActor();\n          const channel = await randomChannel();\n          const { attestation, channelPublicId } =\n            await channelAttestations.attest(method, actor, channel);\n          const isValid = await channelAttestations.validate(\n            attestation,\n            actor,\n            channelPublicId,\n          );\n          expect(isValid).toBe(true);\n\n          const channelPublicIdSeperate = await channelAttestations.register(\n            method,\n            channel,\n          );\n          expect(channelPublicId).toEqual(channelPublicIdSeperate);\n        });\n\n        test(\"Invalid attestation with wrong actor\", async () => {\n          const actor = await randomActor();\n          const wrongActor = await randomActor();\n          const channel = await randomChannel();\n          const { attestation, channelPublicId } =\n            await channelAttestations.attest(method, actor, channel);\n          const isValid = await channelAttestations.validate(\n            attestation,\n            wrongActor,\n            channelPublicId,\n          );\n          expect(isValid).toBe(false);\n        });\n\n        test(\"Invalid attestation with wrong channel\", async () => {\n          const actor = await randomActor();\n          const channel = await randomChannel();\n          const wrongChannel = await randomChannel();\n          const { attestation, channelPublicId } =\n            await channelAttestations.attest(method, actor, channel);\n          const wrongChannelPublicId = await channelAttestations.register(\n            method,\n            wrongChannel,\n          );\n          const isValid = await channelAttestations.validate(\n            attestation,\n            actor,\n            wrongChannelPublicId,\n          );\n          expect(isValid).toBe(false);\n        });\n      });\n    }\n  });\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/2-primitives/3-channel-attestations.js

@@ -0,0 +1,84 @@
+"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 channel_attestations_exports = {};
+__export(channel_attestations_exports, {
+  CHANNEL_ATTESTATION_METHOD_SHA256_ED25519: () => CHANNEL_ATTESTATION_METHOD_SHA256_ED25519,
+  ChannelAttestations: () => ChannelAttestations
+});
+module.exports = __toCommonJS(channel_attestations_exports);
+var import_ed25519 = require("@noble/ed25519");
+var import_webcrypto = require("@noble/hashes/webcrypto.js");
+import_ed25519.hashes.sha512Async = import_webcrypto.sha512;
+const CHANNEL_ATTESTATION_METHOD_SHA256_ED25519 = "pk:sha2-256+ed25519";
+const CHANNEL_ATTESTATION_METHOD_PREFIX_SHA256_ED25519 = 0;
+class ChannelAttestations {
+  async register(channelAttestationMethod, channel) {
+    if (channelAttestationMethod !== CHANNEL_ATTESTATION_METHOD_SHA256_ED25519) {
+      throw new Error(
+        `Unsupported channel attestation method: ${channelAttestationMethod}`
+      );
+    }
+    const privateKey = await this.channelToPrivateKey(channel);
+    return await this.channelPublicIdFromPrivateKey(privateKey);
+  }
+  async getMethod(channelPublicId) {
+    if (channelPublicId[0] === CHANNEL_ATTESTATION_METHOD_PREFIX_SHA256_ED25519) {
+      return CHANNEL_ATTESTATION_METHOD_SHA256_ED25519;
+    } else {
+      throw new Error(`Unrecognized channel attestation method.`);
+    }
+  }
+  async channelToPrivateKey(channel) {
+    const channelBytes = new TextEncoder().encode(channel);
+    return await (0, import_webcrypto.sha256)(channelBytes);
+  }
+  async channelPublicIdFromPrivateKey(privateKey) {
+    const channelPublicIdRaw = await (0, import_ed25519.getPublicKeyAsync)(privateKey);
+    const channelPublicId = new Uint8Array(channelPublicIdRaw.length + 1);
+    channelPublicId[0] = CHANNEL_ATTESTATION_METHOD_PREFIX_SHA256_ED25519;
+    channelPublicId.set(channelPublicIdRaw, 1);
+    return channelPublicId;
+  }
+  async attest(channelAttestationMethod, actor, channel) {
+    if (channelAttestationMethod !== CHANNEL_ATTESTATION_METHOD_SHA256_ED25519) {
+      throw new Error(
+        `Unsupported channel attestation method: ${channelAttestationMethod}`
+      );
+    }
+    const privateKey = await this.channelToPrivateKey(channel);
+    const channelPublicId = await this.channelPublicIdFromPrivateKey(privateKey);
+    const actorBytes = new TextEncoder().encode(actor);
+    const attestation = await (0, import_ed25519.signAsync)(actorBytes, privateKey);
+    return { attestation, channelPublicId };
+  }
+  async validate(attestation, actor, channelPublicId) {
+    const prefix = channelPublicId[0];
+    if (prefix !== CHANNEL_ATTESTATION_METHOD_PREFIX_SHA256_ED25519) {
+      throw new Error(
+        `Unrecognized channel attestation method prefix: ${prefix}`
+      );
+    }
+    return await (0, import_ed25519.verifyAsync)(
+      attestation,
+      new TextEncoder().encode(actor),
+      channelPublicId.slice(1)
+    );
+  }
+}
+//# sourceMappingURL=3-channel-attestations.js.map

package/dist/cjs/2-primitives/3-channel-attestations.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/2-primitives/3-channel-attestations.ts"],
+  "sourcesContent": ["import {\n  getPublicKeyAsync,\n  signAsync,\n  verifyAsync,\n  hashes,\n} from \"@noble/ed25519\";\nimport { sha256, sha512 } from \"@noble/hashes/webcrypto.js\";\nhashes.sha512Async = sha512;\n\nexport const CHANNEL_ATTESTATION_METHOD_SHA256_ED25519 = \"pk:sha2-256+ed25519\";\nconst CHANNEL_ATTESTATION_METHOD_PREFIX_SHA256_ED25519 = 0;\n\nexport class ChannelAttestations {\n  async register(\n    channelAttestationMethod: string,\n    channel: string,\n  ): Promise<Uint8Array> {\n    if (\n      channelAttestationMethod !== CHANNEL_ATTESTATION_METHOD_SHA256_ED25519\n    ) {\n      throw new Error(\n        `Unsupported channel attestation method: ${channelAttestationMethod}`,\n      );\n    }\n    const privateKey = await this.channelToPrivateKey(channel);\n    return await this.channelPublicIdFromPrivateKey(privateKey);\n  }\n\n  async getMethod(channelPublicId: Uint8Array): Promise<string> {\n    if (\n      channelPublicId[0] === CHANNEL_ATTESTATION_METHOD_PREFIX_SHA256_ED25519\n    ) {\n      return CHANNEL_ATTESTATION_METHOD_SHA256_ED25519;\n    } else {\n      throw new Error(`Unrecognized channel attestation method.`);\n    }\n  }\n\n  protected async channelToPrivateKey(channel: string): Promise<Uint8Array> {\n    const channelBytes = new TextEncoder().encode(channel);\n    return await sha256(channelBytes);\n  }\n  protected async channelPublicIdFromPrivateKey(\n    privateKey: Uint8Array,\n  ): Promise<Uint8Array> {\n    const channelPublicIdRaw = await getPublicKeyAsync(privateKey);\n    const channelPublicId = new Uint8Array(channelPublicIdRaw.length + 1);\n    channelPublicId[0] = CHANNEL_ATTESTATION_METHOD_PREFIX_SHA256_ED25519;\n    channelPublicId.set(channelPublicIdRaw, 1);\n    return channelPublicId;\n  }\n\n  async attest(\n    channelAttestationMethod: string,\n    actor: string,\n    channel: string,\n  ): Promise<{\n    attestation: Uint8Array;\n    channelPublicId: Uint8Array;\n  }> {\n    if (\n      channelAttestationMethod !== CHANNEL_ATTESTATION_METHOD_SHA256_ED25519\n    ) {\n      throw new Error(\n        `Unsupported channel attestation method: ${channelAttestationMethod}`,\n      );\n    }\n    const privateKey = await this.channelToPrivateKey(channel);\n    const channelPublicId =\n      await this.channelPublicIdFromPrivateKey(privateKey);\n\n    const actorBytes = new TextEncoder().encode(actor);\n    const attestation = await signAsync(actorBytes, privateKey);\n    return { attestation, channelPublicId };\n  }\n\n  async validate(\n    attestation: Uint8Array,\n    actor: string,\n    channelPublicId: Uint8Array,\n  ): Promise<boolean> {\n    const prefix = channelPublicId[0];\n    if (prefix !== CHANNEL_ATTESTATION_METHOD_PREFIX_SHA256_ED25519) {\n      throw new Error(\n        `Unrecognized channel attestation method prefix: ${prefix}`,\n      );\n    }\n\n    return await verifyAsync(\n      attestation,\n      new TextEncoder().encode(actor),\n      channelPublicId.slice(1),\n    );\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAKO;AACP,uBAA+B;AAC/B,sBAAO,cAAc;AAEd,MAAM,4CAA4C;AACzD,MAAM,mDAAmD;AAElD,MAAM,oBAAoB;AAAA,EAC/B,MAAM,SACJ,0BACA,SACqB;AACrB,QACE,6BAA6B,2CAC7B;AACA,YAAM,IAAI;AAAA,QACR,2CAA2C,wBAAwB;AAAA,MACrE;AAAA,IACF;AACA,UAAM,aAAa,MAAM,KAAK,oBAAoB,OAAO;AACzD,WAAO,MAAM,KAAK,8BAA8B,UAAU;AAAA,EAC5D;AAAA,EAEA,MAAM,UAAU,iBAA8C;AAC5D,QACE,gBAAgB,CAAC,MAAM,kDACvB;AACA,aAAO;AAAA,IACT,OAAO;AACL,YAAM,IAAI,MAAM,0CAA0C;AAAA,IAC5D;AAAA,EACF;AAAA,EAEA,MAAgB,oBAAoB,SAAsC;AACxE,UAAM,eAAe,IAAI,YAAY,EAAE,OAAO,OAAO;AACrD,WAAO,UAAM,yBAAO,YAAY;AAAA,EAClC;AAAA,EACA,MAAgB,8BACd,YACqB;AACrB,UAAM,qBAAqB,UAAM,kCAAkB,UAAU;AAC7D,UAAM,kBAAkB,IAAI,WAAW,mBAAmB,SAAS,CAAC;AACpE,oBAAgB,CAAC,IAAI;AACrB,oBAAgB,IAAI,oBAAoB,CAAC;AACzC,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,OACJ,0BACA,OACA,SAIC;AACD,QACE,6BAA6B,2CAC7B;AACA,YAAM,IAAI;AAAA,QACR,2CAA2C,wBAAwB;AAAA,MACrE;AAAA,IACF;AACA,UAAM,aAAa,MAAM,KAAK,oBAAoB,OAAO;AACzD,UAAM,kBACJ,MAAM,KAAK,8BAA8B,UAAU;AAErD,UAAM,aAAa,IAAI,YAAY,EAAE,OAAO,KAAK;AACjD,UAAM,cAAc,UAAM,0BAAU,YAAY,UAAU;AAC1D,WAAO,EAAE,aAAa,gBAAgB;AAAA,EACxC;AAAA,EAEA,MAAM,SACJ,aACA,OACA,iBACkB;AAClB,UAAM,SAAS,gBAAgB,CAAC;AAChC,QAAI,WAAW,kDAAkD;AAC/D,YAAM,IAAI;AAAA,QACR,mDAAmD,MAAM;AAAA,MAC3D;AAAA,IACF;AAEA,WAAO,UAAM;AAAA,MACX;AAAA,MACA,IAAI,YAAY,EAAE,OAAO,KAAK;AAAA,MAC9B,gBAAgB,MAAM,CAAC;AAAA,IACzB;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/cjs/2-primitives/4-allowed-attestations-tests.js

@@ -0,0 +1,96 @@
+"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 allowed_attestations_tests_exports = {};
+__export(allowed_attestations_tests_exports, {
+  allowedAttestationTests: () => allowedAttestationTests
+});
+module.exports = __toCommonJS(allowed_attestations_tests_exports);
+var import_vitest = require("vitest");
+var import_allowed_attestations = require("./4-allowed-attestations");
+var import_utils = require("@noble/hashes/utils.js");
+var import_string_encoding = require("./1-string-encoding");
+function allowedAttestationTests() {
+  (0, import_vitest.describe)("Allowed Attestation Tests", () => {
+    const allowedAttestationMethods = [import_allowed_attestations.ALLOWED_ATTESTATION_METHOD_HMAC_SHA256];
+    const allowedAttestations = new import_allowed_attestations.AllowedAttestations();
+    async function randomActor() {
+      const bytes = (0, import_utils.randomBytes)();
+      const str = await new import_string_encoding.StringEncoder().encode(
+        import_string_encoding.STRING_ENCODER_METHOD_BASE64URL,
+        bytes
+      );
+      return `did:web:${str}.com`;
+    }
+    (0, import_vitest.test)("Invalid attestation method", async () => {
+      const actor = await randomActor();
+      await (0, import_vitest.expect)(
+        () => allowedAttestations.attest("invalid-method", actor)
+      ).rejects.toThrow();
+    });
+    for (const method of allowedAttestationMethods) {
+      (0, import_vitest.describe)(`Attestation Method: ${method}`, () => {
+        (0, import_vitest.test)("Valid attestation", async () => {
+          const actor = await randomActor();
+          const { attestation, ticket } = await allowedAttestations.attest(
+            method,
+            actor
+          );
+          const isValid = await allowedAttestations.validate(
+            attestation,
+            actor,
+            ticket
+          );
+          (0, import_vitest.expect)(isValid).toBe(true);
+        });
+        (0, import_vitest.test)("Wrong actor", async () => {
+          const actor = await randomActor();
+          const { attestation, ticket } = await allowedAttestations.attest(
+            method,
+            actor
+          );
+          const otherActor = await randomActor();
+          const isValid = await allowedAttestations.validate(
+            attestation,
+            otherActor,
+            ticket
+          );
+          (0, import_vitest.expect)(isValid).toBe(false);
+        });
+        (0, import_vitest.test)("Wrong ticket", async () => {
+          const actor = await randomActor();
+          const { attestation: attestation1, ticket: ticket1 } = await allowedAttestations.attest(method, actor);
+          const { attestation: attestation2, ticket: ticket2 } = await allowedAttestations.attest(method, actor);
+          const isValid1 = await allowedAttestations.validate(
+            attestation1,
+            actor,
+            ticket2
+          );
+          const isValid2 = await allowedAttestations.validate(
+            attestation2,
+            actor,
+            ticket1
+          );
+          (0, import_vitest.expect)(isValid1).toBe(false);
+          (0, import_vitest.expect)(isValid2).toBe(false);
+        });
+      });
+    }
+  });
+}
+//# sourceMappingURL=4-allowed-attestations-tests.js.map

package/dist/cjs/2-primitives/4-allowed-attestations-tests.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/2-primitives/4-allowed-attestations-tests.ts"],
+  "sourcesContent": ["import { describe, expect, test } from \"vitest\";\nimport {\n  ALLOWED_ATTESTATION_METHOD_HMAC_SHA256,\n  AllowedAttestations,\n} from \"./4-allowed-attestations\";\nimport { randomBytes } from \"@noble/hashes/utils.js\";\nimport {\n  StringEncoder,\n  STRING_ENCODER_METHOD_BASE64URL,\n} from \"./1-string-encoding\";\n\nexport function allowedAttestationTests() {\n  describe(\"Allowed Attestation Tests\", () => {\n    const allowedAttestationMethods = [ALLOWED_ATTESTATION_METHOD_HMAC_SHA256];\n    const allowedAttestations = new AllowedAttestations();\n\n    async function randomActor() {\n      const bytes = randomBytes();\n      const str = await new StringEncoder().encode(\n        STRING_ENCODER_METHOD_BASE64URL,\n        bytes,\n      );\n      return `did:web:${str}.com`;\n    }\n\n    test(\"Invalid attestation method\", async () => {\n      const actor = await randomActor();\n      await expect(() =>\n        allowedAttestations.attest(\"invalid-method\", actor),\n      ).rejects.toThrow();\n    });\n\n    for (const method of allowedAttestationMethods) {\n      describe(`Attestation Method: ${method}`, () => {\n        test(\"Valid attestation\", async () => {\n          const actor = await randomActor();\n          const { attestation, ticket } = await allowedAttestations.attest(\n            method,\n            actor,\n          );\n          const isValid = await allowedAttestations.validate(\n            attestation,\n            actor,\n            ticket,\n          );\n          expect(isValid).toBe(true);\n        });\n\n        test(\"Wrong actor\", async () => {\n          const actor = await randomActor();\n          const { attestation, ticket } = await allowedAttestations.attest(\n            method,\n            actor,\n          );\n          const otherActor = await randomActor();\n          const isValid = await allowedAttestations.validate(\n            attestation,\n            otherActor,\n            ticket,\n          );\n          expect(isValid).toBe(false);\n        });\n\n        test(\"Wrong ticket\", async () => {\n          const actor = await randomActor();\n          const { attestation: attestation1, ticket: ticket1 } =\n            await allowedAttestations.attest(method, actor);\n          const { attestation: attestation2, ticket: ticket2 } =\n            await allowedAttestations.attest(method, actor);\n          const isValid1 = await allowedAttestations.validate(\n            attestation1,\n            actor,\n            ticket2,\n          );\n          const isValid2 = await allowedAttestations.validate(\n            attestation2,\n            actor,\n            ticket1,\n          );\n          expect(isValid1).toBe(false);\n          expect(isValid2).toBe(false);\n        });\n      });\n    }\n  });\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAuC;AACvC,kCAGO;AACP,mBAA4B;AAC5B,6BAGO;AAEA,SAAS,0BAA0B;AACxC,8BAAS,6BAA6B,MAAM;AAC1C,UAAM,4BAA4B,CAAC,kEAAsC;AACzE,UAAM,sBAAsB,IAAI,gDAAoB;AAEpD,mBAAe,cAAc;AAC3B,YAAM,YAAQ,0BAAY;AAC1B,YAAM,MAAM,MAAM,IAAI,qCAAc,EAAE;AAAA,QACpC;AAAA,QACA;AAAA,MACF;AACA,aAAO,WAAW,GAAG;AAAA,IACvB;AAEA,4BAAK,8BAA8B,YAAY;AAC7C,YAAM,QAAQ,MAAM,YAAY;AAChC,gBAAM;AAAA,QAAO,MACX,oBAAoB,OAAO,kBAAkB,KAAK;AAAA,MACpD,EAAE,QAAQ,QAAQ;AAAA,IACpB,CAAC;AAED,eAAW,UAAU,2BAA2B;AAC9C,kCAAS,uBAAuB,MAAM,IAAI,MAAM;AAC9C,gCAAK,qBAAqB,YAAY;AACpC,gBAAM,QAAQ,MAAM,YAAY;AAChC,gBAAM,EAAE,aAAa,OAAO,IAAI,MAAM,oBAAoB;AAAA,YACxD;AAAA,YACA;AAAA,UACF;AACA,gBAAM,UAAU,MAAM,oBAAoB;AAAA,YACxC;AAAA,YACA;AAAA,YACA;AAAA,UACF;AACA,oCAAO,OAAO,EAAE,KAAK,IAAI;AAAA,QAC3B,CAAC;AAED,gCAAK,eAAe,YAAY;AAC9B,gBAAM,QAAQ,MAAM,YAAY;AAChC,gBAAM,EAAE,aAAa,OAAO,IAAI,MAAM,oBAAoB;AAAA,YACxD;AAAA,YACA;AAAA,UACF;AACA,gBAAM,aAAa,MAAM,YAAY;AACrC,gBAAM,UAAU,MAAM,oBAAoB;AAAA,YACxC;AAAA,YACA;AAAA,YACA;AAAA,UACF;AACA,oCAAO,OAAO,EAAE,KAAK,KAAK;AAAA,QAC5B,CAAC;AAED,gCAAK,gBAAgB,YAAY;AAC/B,gBAAM,QAAQ,MAAM,YAAY;AAChC,gBAAM,EAAE,aAAa,cAAc,QAAQ,QAAQ,IACjD,MAAM,oBAAoB,OAAO,QAAQ,KAAK;AAChD,gBAAM,EAAE,aAAa,cAAc,QAAQ,QAAQ,IACjD,MAAM,oBAAoB,OAAO,QAAQ,KAAK;AAChD,gBAAM,WAAW,MAAM,oBAAoB;AAAA,YACzC;AAAA,YACA;AAAA,YACA;AAAA,UACF;AACA,gBAAM,WAAW,MAAM,oBAAoB;AAAA,YACzC;AAAA,YACA;AAAA,YACA;AAAA,UACF;AACA,oCAAO,QAAQ,EAAE,KAAK,KAAK;AAC3B,oCAAO,QAAQ,EAAE,KAAK,KAAK;AAAA,QAC7B,CAAC;AAAA,MACH,CAAC;AAAA,IACH;AAAA,EACF,CAAC;AACH;",
+  "names": []
+}