stated-protocol 5.0.0

package/src/hash.ts

@@ -0,0 +1,99 @@
+/**
+ * Universal hash utilities using @noble/hashes
+ * Works in both browser and Node.js environments
+ */
+
+import { sha256 as nobleSha256 } from '@noble/hashes/sha2.js';
+
+/**
+ * Compute SHA-256 hash of a string and return it as URL-safe base64
+ * Works in both browser and Node.js environments
+ * @param input - The string or buffer to hash
+ * @returns URL-safe base64 encoded hash
+ */
+export const sha256 = (input: string | Uint8Array): string => {
+  let data: Uint8Array;
+
+  if (typeof input === 'string') {
+    const encoder = new TextEncoder();
+    data = encoder.encode(input);
+  } else {
+    data = input;
+  }
+
+  // Use @noble/hashes for consistent cross-platform hashing
+  const hashArray = nobleSha256(data);
+
+  // Convert to base64
+  const base64 = bytesToBase64(hashArray);
+
+  // Make URL-safe: remove padding and replace + with - and / with _
+  const urlSafe = base64.replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+
+  return urlSafe;
+};
+
+/**
+ * Verify that content matches a given hash
+ * @param content - The content to verify
+ * @param hash - The expected hash
+ * @returns True if the hash matches
+ */
+export const verify = (content: string | Uint8Array, hash: string): boolean => {
+  const computed = sha256(content);
+  return computed === hash;
+};
+
+/**
+ * Convert URL-safe base64 back to standard base64
+ * @param urlSafe - URL-safe base64 string
+ * @returns Standard base64 string with padding
+ */
+export const fromUrlSafeBase64 = (urlSafe: string): string => {
+  const base64 = urlSafe.replace(/-/g, '+').replace(/_/g, '/');
+  // Add padding if needed
+  const padding = '='.repeat((4 - (base64.length % 4)) % 4);
+  return base64 + padding;
+};
+
+/**
+ * Convert standard base64 to URL-safe base64
+ * @param base64 - Standard base64 string
+ * @returns URL-safe base64 string without padding
+ */
+export const toUrlSafeBase64 = (base64: string): string => {
+  return base64.replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+};
+
+/**
+ * Convert bytes to base64 string
+ * @param bytes - Uint8Array to convert
+ * @returns Base64 string
+ */
+function bytesToBase64(bytes: Uint8Array): string {
+  // Use btoa if available (browser), otherwise use Buffer (Node.js)
+  if (typeof btoa !== 'undefined') {
+    return btoa(String.fromCharCode(...Array.from(bytes)));
+  } else {
+    return Buffer.from(bytes).toString('base64');
+  }
+}
+
+/**
+ * Convert base64 string to bytes
+ * @param base64 - Base64 string to convert
+ * @returns Uint8Array
+ */
+export function base64ToBytes(base64: string): Uint8Array {
+  // Use atob if available (browser), otherwise use Buffer (Node.js)
+  if (typeof atob !== 'undefined') {
+    const binaryString = atob(base64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+  } else {
+    return new Uint8Array(Buffer.from(base64, 'base64'));
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './protocol';
+export * from './hash';
+export * from './signature';
+export * from './constants';
+export * from './types';

package/src/organisation-verification.test.ts

@@ -0,0 +1,50 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { parseOrganisationVerification, buildOrganisationVerificationContent } from './protocol';
+
+const randomUnicodeString = () =>
+  Array.from({ length: 20 }, () => String.fromCharCode(Math.floor(Math.random() * 65536)))
+    .join('')
+    .replace(/[\n;>=<"''\\]/g, '');
+
+describe('Organisation verification building', () => {
+  it('build & parse function compatibility: input=parse(build(input))', () => {
+    const [name, englishName, city, domain, foreignDomain, serialNumber, reliabilityPolicy] =
+      Array.from({ length: 7 }, randomUnicodeString);
+    const pictureHash = 'abc123_-XYZ.png';
+    const country = 'Germany';
+    const province = 'Bayern';
+    const legalForm = 'corporation';
+    const employeeCount = '100-1000';
+    const confidence = 0.8;
+    const verificationContent = buildOrganisationVerificationContent({
+      name,
+      englishName,
+      country,
+      city,
+      province,
+      legalForm,
+      domain,
+      pictureHash,
+      foreignDomain,
+      serialNumber,
+      confidence,
+      reliabilityPolicy,
+      employeeCount,
+    });
+    const parsedVerification = parseOrganisationVerification(verificationContent);
+    assert.strictEqual(parsedVerification.name, name);
+    assert.strictEqual(parsedVerification.englishName, englishName);
+    assert.strictEqual(parsedVerification.country, country);
+    assert.strictEqual(parsedVerification.city, city);
+    assert.strictEqual(parsedVerification.province, province);
+    assert.strictEqual(parsedVerification.legalForm, legalForm);
+    assert.strictEqual(parsedVerification.domain, domain);
+    assert.strictEqual(parsedVerification.foreignDomain, foreignDomain);
+    assert.strictEqual(parsedVerification.serialNumber, serialNumber);
+    assert.strictEqual(parsedVerification.confidence, confidence);
+    assert.strictEqual(parsedVerification.pictureHash, pictureHash);
+    assert.strictEqual(parsedVerification.reliabilityPolicy, reliabilityPolicy);
+    assert.strictEqual(parsedVerification.employeeCount, employeeCount);
+  });
+});

package/src/person-verification.test.ts

@@ -0,0 +1,55 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { parsePersonVerification, buildPersonVerificationContent } from './protocol';
+
+const randomUnicodeString = () =>
+  Array.from({ length: 20 }, () => String.fromCharCode(Math.floor(Math.random() * 65536)))
+    .join('')
+    .replace(/[\n;>=<"''\\]/g, '');
+
+describe('Person verification building', () => {
+  it('build & parse function compatibility: input=parse(build(input))', () => {
+    const [
+      name,
+      ownDomain,
+      foreignDomain,
+      jobTitle,
+      employer,
+      verificationMethod,
+      picture,
+      reliabilityPolicy,
+    ] = Array.from({ length: 12 }, randomUnicodeString);
+    const countryOfBirth = 'Germany';
+    const cityOfBirth = 'Berlin';
+    const confidence = Math.random();
+    const dateOfBirth = new Date(0);
+    const personVerificationContent = buildPersonVerificationContent({
+      name,
+      countryOfBirth,
+      cityOfBirth,
+      ownDomain,
+      foreignDomain,
+      dateOfBirth,
+      jobTitle,
+      employer,
+      verificationMethod,
+      confidence,
+      picture,
+      reliabilityPolicy,
+    });
+
+    const parsedVerification = parsePersonVerification(personVerificationContent);
+    assert.strictEqual(parsedVerification.name, name);
+    assert.strictEqual(parsedVerification.ownDomain, ownDomain);
+    assert.strictEqual(parsedVerification.foreignDomain, foreignDomain);
+    assert.strictEqual(parsedVerification.dateOfBirth.toUTCString(), dateOfBirth.toUTCString());
+    assert.strictEqual(parsedVerification.jobTitle, jobTitle);
+    assert.strictEqual(parsedVerification.employer, employer);
+    assert.strictEqual(parsedVerification.verificationMethod, verificationMethod);
+    assert.strictEqual(parsedVerification.confidence, confidence);
+    assert.strictEqual(parsedVerification.picture, picture);
+    assert.strictEqual(parsedVerification.reliabilityPolicy, reliabilityPolicy);
+    assert.strictEqual(parsedVerification.countryOfBirth, countryOfBirth);
+    assert.strictEqual(parsedVerification.cityOfBirth, cityOfBirth);
+  });
+});

package/src/poll.test.ts

@@ -0,0 +1,28 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { parsePoll, buildPollContent } from './protocol';
+
+const randomUnicodeString = () =>
+  Array.from({ length: 20 }, () => String.fromCharCode(Math.floor(Math.random() * 65536)))
+    .join('')
+    .replace(/[\n;>=<"''\\]/g, '');
+
+describe('Poll building', () => {
+  it('build & parse function compatibility: input=parse(build(input))', () => {
+    const [poll, scopeDescription] = Array.from({ length: 2 }, randomUnicodeString);
+    const options = Array.from({ length: 2 }, randomUnicodeString);
+    const deadline = new Date('Thu, 01 Dec 2022 13:38:26 GMT');
+    const pollContent = buildPollContent({
+      deadline,
+      poll,
+      options,
+      scopeDescription,
+    });
+    const parsedPoll = parsePoll(pollContent, '5');
+    assert.strictEqual(parsedPoll.poll, poll);
+    assert.strictEqual(parsedPoll.scopeDescription, scopeDescription);
+    assert.strictEqual(parsedPoll.deadline?.toUTCString(), deadline.toUTCString());
+    assert.strictEqual(parsedPoll.options[0], options[0]);
+    assert.strictEqual(parsedPoll.options[1], options[1]);
+  });
+});