stated-protocol 5.0.0

package/src/utils.test.ts

@@ -0,0 +1,140 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { buildStatement } from './protocol';
+import {
+  generateFileHash,
+  validateFileHash,
+  generateStatementContentHash,
+  validateStatementContentHash,
+  generateStatementHash,
+  validateStatementHash,
+  generateStatementsFile,
+  parseStatementsFile,
+  generateStatementFilename,
+  generateAttachmentFilename,
+} from './utils';
+
+describe('Statement Utils', () => {
+  const testContent = 'test content';
+  const testFileContent = Buffer.from('test file content');
+
+  describe('File Hash Functions', () => {
+    it('should generate file hash', () => {
+      const hash = generateFileHash(testFileContent);
+      assert.ok(hash);
+      assert.strictEqual(typeof hash, 'string');
+    });
+
+    it('should validate file hash', () => {
+      const hash = generateFileHash(testFileContent);
+      assert.strictEqual(validateFileHash(testFileContent, hash), true);
+      assert.strictEqual(validateFileHash(testFileContent, 'invalid-hash'), false);
+    });
+
+    it('should generate attachment filename', () => {
+      const filename = generateAttachmentFilename(testFileContent, 'pdf');
+      assert.ok(/^[A-Za-z0-9_-]+\.pdf$/.test(filename));
+    });
+
+    it('should handle extension with dot', () => {
+      const filename = generateAttachmentFilename(testFileContent, '.jpg');
+      assert.ok(/^[A-Za-z0-9_-]+\.jpg$/.test(filename));
+    });
+  });
+
+  describe('Statement Content Hash Functions', () => {
+    it('should generate statement content hash', () => {
+      const hash = generateStatementContentHash(testContent);
+      assert.ok(hash);
+      assert.strictEqual(typeof hash, 'string');
+    });
+
+    it('should validate statement content hash', () => {
+      const hash = generateStatementContentHash(testContent);
+      assert.strictEqual(validateStatementContentHash(testContent, hash), true);
+      assert.strictEqual(validateStatementContentHash(testContent, 'invalid-hash'), false);
+    });
+  });
+
+  describe('Statement Hash Functions', () => {
+    const statement = buildStatement({
+      domain: 'example.com',
+      author: 'Test Author',
+      time: new Date('2023-06-15T20:01:26.000Z'),
+      content: 'Test statement content',
+    });
+
+    it('should generate statement hash', () => {
+      const hash = generateStatementHash(statement);
+      assert.ok(hash);
+      assert.strictEqual(typeof hash, 'string');
+    });
+
+    it('should validate statement hash', () => {
+      const hash = generateStatementHash(statement);
+      assert.strictEqual(validateStatementHash(statement, hash), true);
+      assert.strictEqual(validateStatementHash(statement, 'invalid-hash'), false);
+    });
+
+    it('should generate statement filename', () => {
+      const filename = generateStatementFilename(statement);
+      assert.ok(/^[A-Za-z0-9_-]+\.txt$/.test(filename));
+    });
+
+    it('should exclude signature fields from hash', () => {
+      const signedStatement =
+        statement +
+        '---\n' +
+        'Statement hash: test-hash\n' +
+        'Public key: test-key\n' +
+        'Signature: test-signature\n' +
+        'Algorithm: Ed25519\n';
+
+      const hash = generateStatementHash(signedStatement);
+      const hashWithoutSignature = generateStatementHash(statement);
+      assert.strictEqual(hash, hashWithoutSignature);
+    });
+  });
+
+  describe('Statements File Functions', () => {
+    const statement1 = buildStatement({
+      domain: 'example.com',
+      author: 'Test Author',
+      time: new Date('2023-06-15T20:01:26.000Z'),
+      content: 'First statement',
+    });
+
+    const statement2 = buildStatement({
+      domain: 'example.com',
+      author: 'Test Author',
+      time: new Date('2023-06-16T10:30:00.000Z'),
+      content: 'Second statement',
+    });
+
+    it('should generate statements file', () => {
+      const statementsFile = generateStatementsFile([statement1, statement2]);
+      assert.ok(statementsFile.includes(statement1));
+      assert.ok(statementsFile.includes(statement2));
+      assert.ok(statementsFile.includes('\n\n'));
+    });
+
+    it('should parse statements file', () => {
+      const statementsFile = generateStatementsFile([statement1, statement2]);
+      const parsed = parseStatementsFile(statementsFile);
+      assert.strictEqual(parsed.length, 2);
+      assert.strictEqual(parsed[0], statement1);
+      assert.strictEqual(parsed[1], statement2);
+    });
+
+    it('should throw error for invalid statement in file', () => {
+      const invalidFile = 'Invalid statement\n\nAnother invalid statement';
+      assert.throws(() => parseStatementsFile(invalidFile));
+    });
+
+    it('should filter empty statements', () => {
+      const fileWithEmpty = statement1 + '\n\n\n\n' + statement2;
+      const parsed = parseStatementsFile(fileWithEmpty);
+      assert.strictEqual(parsed.length, 2);
+    });
+  });
+});

package/src/utils.ts

@@ -0,0 +1,104 @@
+import { peopleCountBuckets } from './constants';
+
+import { sha256, verify } from './hash';
+import { parseStatement } from './protocol';
+
+export const generateFileHash = (fileContent: Buffer | string): string => {
+  return sha256(fileContent);
+};
+
+export const validateFileHash = (fileContent: Buffer | string, expectedHash: string): boolean => {
+  return verify(fileContent, expectedHash);
+};
+
+export const generateStatementContentHash = (statementContent: string): string => {
+  return sha256(statementContent);
+};
+
+export const validateStatementContentHash = (
+  statementContent: string,
+  expectedHash: string
+): boolean => {
+  return verify(statementContent, expectedHash);
+};
+
+export const generateStatementHash = (statement: string): string => {
+  const signatureRegex = /^([\s\S]+?)---\n[\s\S]+$/;
+  const match = statement.match(signatureRegex);
+
+  if (match && match[1]) {
+    return sha256(match[1]);
+  }
+
+  return sha256(statement);
+};
+
+export const validateStatementHash = (statement: string, expectedHash: string): boolean => {
+  const computedHash = generateStatementHash(statement);
+  return computedHash === expectedHash;
+};
+
+export const generateStatementsFile = (statements: string[]): string => {
+  return statements.join('\n\n');
+};
+
+export const parseStatementsFile = (statementsFileContent: string): string[] => {
+  const statementParts = statementsFileContent.split(/\n\nStated protocol version: /);
+  const statements: string[] = [];
+
+  for (let i = 0; i < statementParts.length; i++) {
+    let statement = statementParts[i];
+
+    if (i === 0 && statement.trim().length === 0) continue;
+
+    if (i > 0) {
+      statement = 'Stated protocol version: ' + statement;
+    }
+
+    statement = statement.replace(/\n+$/, '\n');
+
+    try {
+      parseStatement({ statement });
+      statements.push(statement);
+    } catch (error) {
+      throw new Error(
+        `Invalid statement at index ${i}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  return statements;
+};
+
+export const generateStatementFilename = (statement: string): string => {
+  const hash = generateStatementHash(statement);
+  return `${hash}.txt`;
+};
+
+export const generateAttachmentFilename = (
+  fileContent: Buffer | string,
+  extension: string
+): string => {
+  const hash = generateFileHash(fileContent);
+  const ext = extension.startsWith('.') ? extension.substring(1) : extension;
+  return `${hash}.${ext}`;
+};
+
+export const minPeopleCountToRange = (n: number): string | undefined => {
+  if (n >= 10000000) return peopleCountBuckets['10000000'];
+  if (n >= 1000000) return peopleCountBuckets['1000000'];
+  if (n >= 100000) return peopleCountBuckets['100000'];
+  if (n >= 10000) return peopleCountBuckets['10000'];
+  if (n >= 1000) return peopleCountBuckets['1000'];
+  if (n >= 100) return peopleCountBuckets['100'];
+  if (n >= 10) return peopleCountBuckets['10'];
+  if (n >= 0) return peopleCountBuckets['0'];
+};
+
+export const monthIndex = (month: string): number =>
+  ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'].indexOf(
+    month.toLowerCase().substr(0, 3)
+  );
+
+export const birthDateFormat: RegExp =
+  /(?<d>\d{1,2})\s(?<month>Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(?<y>\d{4})/;