stated-protocol-parser 1.0.7 → 5.0.0

package/src/protocol.ts

@@ -1,666 +1,871 @@
-/* eslint-disable no-useless-concat */
-import { legalForms, UTCFormat, peopleCountBuckets } from './constants'
-import { parsePollV3 } from './v3'
-import { monthIndex, birthDateFormat, minPeopleCountToRange } from './utils'
+import { legalForms, UTCFormat, peopleCountBuckets } from './constants';
+import { monthIndex, birthDateFormat } from './utils';
+import { verifySignature } from './signature';
+import { sha256 } from './hash';
 import type {
-    Statement,
-    Quotation,
-    Poll,
-    OrganisationVerification,
-    PersonVerification,
-    Vote,
-    DisputeAuthenticity,
-    DisputeContent,
-    ResponseContent,
-    PDFSigning,
-    Rating,
-    RatingSubjectTypeValue,
-    Bounty,
-    Observation,
-    Boycott
-} from './types'
-
-const fallBackVersion = 3
-const version = 4
-
-export * from './types'
-export * from './constants'
-export * from './utils'
-export * from './v3'
-
-export const buildStatement = ({ domain, author, time, tags, content, representative, supersededStatement }: Statement) => {
-    if (content.match(/\nPublishing domain: /)) throw (new Error("Statement must not contain 'Publishing domain: ', as this marks the beginning of a new statement."))
-    if (content.match(/\n\n/)) throw (new Error("Statement must not contain two line breaks in a row, as this is used for separating statements."))
-    if (typeof time !== 'object' || !time.toUTCString) throw (new Error("Time must be a Date object."))
-    if (!domain) throw (new Error("Publishing domain missing."))
-    const statement = "Publishing domain: " + domain + "\n" +
-        "Author: " + (author || "") + "\n" +
-        (representative && representative?.length > 0 ? "Authorized signing representative: " + (representative || "") + "\n" : '') +
-        "Time: " + time.toUTCString() + "\n" +
-        (tags && tags.length > 0 ? "Tags: " + tags.join(', ') + "\n" : '') +
-        (supersededStatement && supersededStatement?.length > 0 ? "Superseded statement: " + (supersededStatement || "") + "\n" : '') +
-        "Format version: " + version + "\n" +
-        "Statement content: " + content + (content.match(/\n$/) ? '' : "\n");
-    if (statement.length > 3000) throw (new Error("Statement must not be longer than 3,000 characters."))
-    return statement
-}
-
-export const parseStatement = ({ statement: s, allowNoVersion = false }: { statement: string, allowNoVersion?: boolean })
-    : Statement & { type?: string, formatVersion: string } => {
-    if (s.length > 3000) throw (new Error("Statement must not be longer than 3,000 characters."))
-    if (s.match(/\n\n/)) throw new Error("Statements cannot contain two line breaks in a row, as this is used for separating statements.")
-    const statementRegex = new RegExp(''
-        + /^Publishing domain: (?<domain>[^\n]+?)\n/.source
-        + /Author: (?<author>[^\n]+?)\n/.source
-        + /(?:Authorized signing representative: (?<representative>[^\n]*?)\n)?/.source
-        + /Time: (?<time>[^\n]+?)\n/.source
-        + /(?:Tags: (?<tags>[^\n]*?)\n)?/.source
-        + /(?:Superseded statement: (?<supersededStatement>[^\n]*?)\n)?/.source
-        + /(?:Format version: (?<formatVersion>[^\n]*?)\n)?/.source
-        + /Statement content: (?:(?<typedContent>\n\tType: (?<type>[^\n]+?)\n[\s\S]+?\n$)|(?<content>[\s\S]+?\n$))/.source
+  Statement,
+  Poll,
+  OrganisationVerification,
+  PersonVerification,
+  Vote,
+  DisputeAuthenticity,
+  DisputeContent,
+  ResponseContent,
+  PDFSigning,
+  Rating,
+  RatingSubjectTypeValue,
+} from './types';
+import { isLegalForm, isPeopleCountBucket, isRatingValue } from './types';
+
+const version = 5;
+
+export * from './types';
+export * from './constants';
+export * from './utils';
+
+export const buildStatement = ({
+  domain,
+  author,
+  time,
+  tags,
+  content,
+  representative,
+  supersededStatement,
+  translations,
+  attachments,
+}: Statement) => {
+  if (content.match(/\nPublishing domain: /))
+    throw new Error(
+      "Statement must not contain 'Publishing domain: ', as this marks the beginning of a new statement."
     );
-    const match = s.match(statementRegex)
-    if (!match) throw new Error("Invalid statement format:" + s)
-    
-    const m: Partial<Statement> & { type?: string, formatVersion: string, timeStr: string, tagsStr: string } = {
-        domain: match[1], author: match[2], representative: match[3], timeStr: match[4], tagsStr: match[5],
-        supersededStatement: match[6], formatVersion: match[7], content: match[8] || match[10],
-        type: match[9] ? match[9].toLowerCase().replace(' ', '_') : undefined
-    }
-    if (!(m['timeStr'].match(UTCFormat))) throw new Error("Invalid statement format: time must be in UTC")
-    if (!m['domain']) throw new Error("Invalid statement format: domain is required")
-    if (!m['author']) throw new Error("Invalid statement format: author is required")
-    if (!m['content']) throw new Error("Invalid statement format: statement content is required")
-    if (!allowNoVersion && !m['formatVersion']) throw new Error("Invalid statement format: format version is required")
-
-    const tags = m['tagsStr']?.split(', ')
-    const time = new Date(m['timeStr'])
-    return {
-        domain: m['domain'],
-        author: m['author'],
-        representative: m['representative'],
-        time,
-        tags: (tags && tags.length > 0) ? tags : undefined,
-        supersededStatement: m['supersededStatement'],
-        formatVersion: m['formatVersion'] || ('' + fallBackVersion),
-        content: m['content'],
-        type: m['type']?.toLowerCase().replace(' ', '_'),
-    }
-}
-
-export const buildQuotationContent = ({ originalAuthor, authorVerification, originalTime, source,
-    quotation, paraphrasedStatement, picture, confidence }: Quotation) => {
-    if (quotation && quotation.match(/\n/)) throw (new Error("Quotation must not contain line breaks."))
-    if (!paraphrasedStatement && !quotation) throw (new Error("Quotation must contain either a quotation or a paraphrased statement."))
-    const content = "\n" +
-        "\t" + "Type: Quotation" + "\n" +
-        "\t" + "Original author: " + originalAuthor + "\n" +
-        "\t" + "Author verification: " + authorVerification + "\n" +
-        (originalTime && originalTime?.length > 0 ? "\t" + "Original publication time: " + originalTime + "\n" : "") +
-        (source && source?.length > 0 ? "\t" + "Source: " + (source || "") + "\n" : '') +
-        (picture && picture.length > 0 ? "\t" + "Picture proof: " + (picture || "") + "\n" : '') +
-        (confidence && confidence?.length > 0 ? "\t" + "Confidence: " + (confidence || "") + "\n" : '') +
-        (quotation && quotation?.length > 0 ? "\t" + "Quotation: " + (quotation || "") + "\n" : '') +
-        (paraphrasedStatement && paraphrasedStatement?.length > 0 ? "\t" + "Paraphrased statement: " +
-            (paraphrasedStatement || "").replace(/\n\t([^\t])/, '\n\t\t($1)') + "\n" : '') +
-        ""
-    return content
-}
-
-export const parseQuotation = (s: string): Quotation & { type: string | undefined } => {
-    const voteRegex = new RegExp(''
-        + /^\n\tType: Quotation\n/.source
-        + /\tOriginal author: (?<originalAuthor>[^\n]+?)\n/.source
-        + /\tAuthor verification: (?<authorVerification>[^\n]+?)\n/.source
-        + /(?:\tOriginal publication time: (?<originalTime>[^\n]+?)\n)?/.source
-        + /(?:\tSource: (?<source>[^\n]+?)\n)?/.source
-        + /(?:\tPicture proof: (?<picture>[^\n]+?)\n)?/.source
-        + /(?:\tConfidence: (?<confidence>[^\n]+?)\n)?/.source
-        + /(?:\tQuotation: (?<quotation>[^\n]+?)\n)?/.source
-        + /(?:\tParaphrased statement: (?:(?<paraphrasedTypedStatement>\n\t\tType: (?<type>[^\n]+?)\n[\s\S]+?)|(?<paraphrasedStatement>[\s\S]+?)))/.source
-        + /$/.source
+  if (content.match(/\n\n/))
+    throw new Error(
+      'Statement content must not contain two line breaks in a row, as this is used for separating statements.'
     );
-    let match = s.match(voteRegex)
-    if (!match) throw new Error("Invalid quotation format: " + s)
-    let m = {} as Quotation & { type: string | undefined }
-    m = {
-        originalAuthor: match[1], authorVerification: match[2], originalTime: match[3], source: match[4],
-        picture: match[5], confidence: match[6], quotation: match[7], paraphrasedStatement: match[8] || match[10],
-        type: match[9] ? match[9].toLowerCase().replace(' ', '_') : undefined
-    }
-    return {
-        originalAuthor: m['originalAuthor'],
-        authorVerification: m['authorVerification'],
-        originalTime: m['originalTime'],
-        source: m['source'],
-        picture: m['picture'],
-        confidence: m['confidence'],
-        quotation: m['quotation'],
-        paraphrasedStatement: (m['paraphrasedStatement']?.replace(/\n\t\t/g, "\n\t")),
-        type: m['type']?.toLowerCase().replace(' ', '_'),
-    }
-}
-
-export const buildPollContent = ({ country, city, legalEntity, domainScope, judges, deadline, poll,
-    scopeDescription, scopeQueryLink, options, allowArbitraryVote, requiredProperty: propertyScope, requiredPropertyObserver: propertyScopeObserver }: Poll) => {
-    if (!poll) throw (new Error("Poll must contain a poll question."))
-    const scopeContent =
-        (scopeDescription ? "\t\t" + "Description: " + scopeDescription + "\n" : "") +
-        (country ? "\t\t" + "Country scope: " + country + "\n" : "") +
-        (city ? "\t\t" + "City scope: " + city + "\n" : "") +
-        (legalEntity ? "\t\t" + "Legal form scope: " + legalEntity + "\n" : "") +
-        (domainScope && domainScope?.length > 0 ? "\t\t" + "Domain scope: " + domainScope.join(', ') + "\n" : "") +
-        (propertyScope ? "\t\t" + "All entities with the following property: " + propertyScope + "\n" : "") +
-        (propertyScopeObserver ? "\t\t" + "As observed by: " + propertyScopeObserver + "\n" : "") +
-        (scopeQueryLink ? "\t\t" + "Link to query defining who can vote: " + scopeQueryLink + "\n" : "")
-    if (scopeContent.length > 0 && !scopeDescription) throw (new Error("Poll must contain a description of who can vote."))
-    const content = "\n" +
-        "\t" + "Type: Poll" + "\n" +
-        (judges ? "\t" + "The poll outcome is finalized when the following nodes agree: " + judges + "\n" : "") +
-        (deadline ? "\t" + "Voting deadline: " + deadline.toUTCString() + "\n" : "") +
-        "\t" + "Poll: " + poll + "\n" +
-        (options.length > 0 && options[0] ? "\t" + "Option 1: " + options[0] + "\n" : "") +
-        (options.length > 1 && options[1] ? "\t" + "Option 2: " + options[1] + "\n" : "") +
-        (options.length > 2 && options[2] ? "\t" + "Option 3: " + options[2] + "\n" : "") +
-        (options.length > 3 && options[3] ? "\t" + "Option 4: " + options[3] + "\n" : "") +
-        (options.length > 4 && options[4] ? "\t" + "Option 5: " + options[4] + "\n" : "") +
-        ((allowArbitraryVote === true || allowArbitraryVote === false) ? ("\t" + "Allow free text votes: " + (allowArbitraryVote ? 'Yes' : 'No') + "\n") : "") +
-        (scopeContent ? "\t" + "Who can vote: \n" + scopeContent : "") +
-        ""
-    return content
-}
-
-export const parsePoll = (s: string, version?: string): Poll => {
-    if (version && version === '3') return parsePollV3(s)
-    if (version && version !== '4') throw new Error("Invalid version " + version)
-    const pollRegex = new RegExp(''
-        + /^\n\tType: Poll\n/.source
-        + /(?:\tThe poll outcome is finalized when the following nodes agree: (?<judges>[^\n]+?)\n)?/.source
-        + /(?:\tVoting deadline: (?<deadline>[^\n]+?)\n)?/.source
-        + /\tPoll: (?<poll>[^\n]+?)\n/.source
-        + /(?:\tOption 1: (?<option1>[^\n]+?)\n)?/.source
-        + /(?:\tOption 2: (?<option2>[^\n]+?)\n)?/.source
-        + /(?:\tOption 3: (?<option3>[^\n]+?)\n)?/.source
-        + /(?:\tOption 4: (?<option4>[^\n]+?)\n)?/.source
-        + /(?:\tOption 5: (?<option5>[^\n]+?)\n)?/.source
-        + /(?:\tAllow free text votes: (?<allowArbitraryVote>Yes|No)\n)?/.source
-        + /(?:\tWho can vote: (?<whoCanVote>\n[\s\S]+?\n))?/.source
-        + /$/.source)
-    let m: any = s.match(pollRegex)
-    if (!m) throw new Error("Invalid poll format: " + s)
-
-    m = {
-        judges: m[1], deadline: m[2], poll: m[3],
-        option1: m[4], option2: m[5], option3: m[6], option4: m[7], option5: m[8],
-        allowArbitraryVote: m[9],
-        whoCanVote: m[10]
-    }
-    const whoCanVoteParsed: Partial<Poll> & { domainScopeStr?: string } = {}
-    if (m.whoCanVote) {
-        const whoCanVoteRegex = new RegExp(''
-            + /^\n\t\tDescription: (?<scopeDescription>[^\n]+?)\n/.source
-            + /(?:\t\tCountry scope: (?<countryScope>[^\n]+?)\n)?/.source
-            + /(?:\t\tCity scope: (?<cityScope>[^\n]+?)\n)?/.source
-            + /(?:\t\tLegal form scope: (?<legalEntity>[^\n]+?)\n)?/.source
-            + /(?:\t\tDomain scope: (?<domainScope>[^\n]+?)\n)?/.source
-            + /(?:\t\tAll entities with the following property: (?<propertyScope>[^\n]+?)\n)?/.source
-            + /(?:\t\tAs observed by: (?<propertyScopeObserver>[^\n]+?)\n)?/.source
-            + /(?:\t\tLink to query defining who can vote: (?<scopeQueryLink>[^\n]+?)\n)?/.source
-            + /$/.source)
-        let m2: any = m.whoCanVote.match(whoCanVoteRegex)
-        if (!m2) throw new Error("Invalid who can vote section: " + m.whoCanVote)
-        whoCanVoteParsed['scopeDescription'] = m2[1]
-        whoCanVoteParsed['country'] = m2[2]
-        whoCanVoteParsed['city'] = m2[3]
-        whoCanVoteParsed['legalEntity'] = m2[4]
-        whoCanVoteParsed['domainScopeStr'] = m2[5]
-        whoCanVoteParsed['requiredProperty'] = m2[6]
-        whoCanVoteParsed['requiredPropertyObserver'] = m2[7]
-        whoCanVoteParsed['scopeQueryLink'] = m2[8]
-    }
-    const options = [m.option1, m.option2, m.option3, m.option4, m.option5].filter(o => o)
-    const domainScope = (whoCanVoteParsed.domainScopeStr as string | undefined)?.split(', ')
-    const allowArbitraryVote = (m['allowArbitraryVote'] === 'Yes' ? true :
-        (m['allowArbitraryVote'] === 'No' ? false : undefined))
-    const deadlineStr = m.deadline
-    if (deadlineStr && !deadlineStr.match(UTCFormat)) throw new Error("Invalid poll, deadline must be in UTC: " + deadlineStr)
-    return {
-        judges: m['judges'],
-        deadline: deadlineStr ? new Date(deadlineStr) : undefined,
-        poll: m['poll'],
-        options,
-        allowArbitraryVote,
-        country: whoCanVoteParsed['country'],
-        scopeDescription: whoCanVoteParsed['scopeDescription'],
-        requiredProperty: whoCanVoteParsed['requiredProperty'],
-        requiredPropertyObserver: whoCanVoteParsed['requiredPropertyObserver'],
-        scopeQueryLink: whoCanVoteParsed['scopeQueryLink'],
-        city: whoCanVoteParsed['city'],
-        legalEntity: whoCanVoteParsed['legalEntity'],
-        domainScope: (domainScope && domainScope.length > 0) ? domainScope : undefined,
-    }
-}
-
-export const buildOrganisationVerificationContent = (
-    { name, englishName, country, city, province, legalForm, department, domain, foreignDomain, serialNumber,
-        confidence, reliabilityPolicy, employeeCount, pictureHash, latitude, longitude, population }: OrganisationVerification) => {
-    if (!name || !country || !legalForm || (!domain && !foreignDomain)) throw new Error("Missing required fields")
-    if (!Object.values(legalForms).includes(legalForm)) throw new Error("Invalid legal form " + legalForm)
-    if (employeeCount && !Object.values(peopleCountBuckets).includes(employeeCount)) throw new Error("Invalid employee count " + employeeCount)
-    if (population && !Object.values(peopleCountBuckets).includes(population)) throw new Error("Invalid population " + population)
-    if (confidence && !('' + confidence)?.match(/^[0-9.]+$/)) throw new Error("Invalid confidence " + confidence)
-
-    return "\n" +
-        "\t" + "Type: Organisation verification" + "\n" +
-        "\t" + "Description: We verified the following information about an organisation." + "\n" +
-        "\t" + "Name: " + name + "\n" +
-        (englishName ? "\t" + "English name: " + englishName + "\n" : "") +
-        "\t" + "Country: " + country + "\n" +
-        "\t" + "Legal form: " + legalForm + "\n" +
-        (domain ? "\t" + "Owner of the domain: " + domain + "\n" : "") +
-        (foreignDomain ? "\t" + "Foreign domain used for publishing statements: " + foreignDomain + "\n" : "") +
-        (department ? "\t" + "Department using the domain: " + department + "\n" : "") +
-        (province ? "\t" + "Province or state: " + province + "\n" : "") +
-        (serialNumber ? "\t" + "Business register number: " + serialNumber + "\n" : "") +
-        (city ? "\t" + "City: " + city + "\n" : "") +
-        (latitude ? "\t" + "Latitude: " + latitude + "\n" : "") +
-        (longitude ? "\t" + "Longitude: " + longitude + "\n" : "") +
-        (population ? "\t" + "Population: " + population + "\n" : "") +
-        (pictureHash ? "\t" + "Logo: " + pictureHash + "\n" : "") +
-        (employeeCount ? "\t" + "Employee count: " + employeeCount + "\n" : "") +
-        (reliabilityPolicy ? "\t" + "Reliability policy: " + reliabilityPolicy + "\n" : "") +
-        (confidence ? "\t" + "Confidence: " + confidence + "\n" : "") +
-        ""
-}
-
-export const parseOrganisationVerification = (s: string): OrganisationVerification => {
-    const organisationVerificationRegex = new RegExp(''
-        + /^\n\tType: Organisation verification\n/.source
-        + /\tDescription: We verified the following information about an organisation.\n/.source
-        + /\tName: (?<name>[^\n]+?)\n/.source
-        + /(?:\tEnglish name: (?<englishName>[^\n]+?)\n)?/.source
-        + /\tCountry: (?<country>[^\n]+?)\n/.source
-        + /\tLegal (?:form|entity): (?<legalForm>[^\n]+?)\n/.source
-        + /(?:\tOwner of the domain: (?<domain>[^\n]+?)\n)?/.source
-        + /(?:\tForeign domain used for publishing statements: (?<foreignDomain>[^\n]+?)\n)?/.source
-        + /(?:\tDepartment using the domain: (?<department>[^\n]+?)\n)?/.source
-        + /(?:\tProvince or state: (?<province>[^\n]+?)\n)?/.source
-        + /(?:\tBusiness register number: (?<serialNumber>[^\n]+?)\n)?/.source
-        + /(?:\tCity: (?<city>[^\n]+?)\n)?/.source
-        + /(?:\tLatitude: (?<latitude>[^\n]+?)\n)?/.source
-        + /(?:\tLongitude: (?<longitude>[^\n]+?)\n)?/.source
-        + /(?:\tPopulation: (?<population>[^\n]+?)\n)?/.source
-        + /(?:\tLogo: (?<pictureHash>[^\n]+?)\n)?/.source
-        + /(?:\tEmployee count: (?<employeeCount>[01,+-]+?)\n)?/.source
-        + /(?:\tReliability policy: (?<reliabilityPolicy>[^\n]+?)\n)?/.source
-        + /(?:\tConfidence: (?<confidence>[0-9.]+?)\n)?/.source
-        + /$/.source
+  if (content.match(/\nTranslation [a-z]{2,3}:\n/))
+    throw new Error(
+      "Statement content must not contain 'Translation XX:\\n' pattern, as this is reserved for translations."
     );
-    const m = s.match(organisationVerificationRegex)
-    if (!m) throw new Error("Invalid organisation verification format: " + s)
-    return {
-        name: m[1],
-        englishName: m[2],
-        country: m[3],
-        legalForm: m[4],
-        domain: m[5],
-        foreignDomain: m[6],
-        department: m[7],
-        province: m[8],
-        serialNumber: m[9],
-        city: m[10],
-        latitude: m[11] ? parseFloat(m[11]) : undefined,
-        longitude: m[12] ? parseFloat(m[12]) : undefined,
-        population: m[13],
-        pictureHash: m[14],
-        employeeCount: m[15],
-        reliabilityPolicy: m[16],
-        confidence: m[17] ? parseFloat(m[17]) : undefined,
-    }
-}
-
-export const buildPersonVerificationContent = (
-    { name, countryOfBirth, cityOfBirth, ownDomain, foreignDomain,
-        dateOfBirth, jobTitle, employer, verificationMethod, confidence,
-        picture, reliabilityPolicy }: PersonVerification) => {
-    if (!name || !countryOfBirth || !cityOfBirth || !dateOfBirth || (!ownDomain && !foreignDomain)) {
-        console.log("Missing required fields: ", { name, countryOfBirth, cityOfBirth, dateOfBirth, ownDomain, foreignDomain })
-        return ""
+  if (content.match(/\nAttachments: /))
+    throw new Error(
+      "Statement content must not contain 'Attachments: ' on a new line, as this is reserved for file attachments."
+    );
+  if (typeof time !== 'object' || !time.toUTCString) throw new Error('Time must be a Date object.');
+  if (!domain) throw new Error('Publishing domain missing.');
+  if (attachments && attachments.length > 5) throw new Error('Maximum 5 attachments allowed.');
+  if (attachments) {
+    attachments.forEach((attachment, index) => {
+      if (!attachment.match(/^[A-Za-z0-9_-]+\.[a-zA-Z0-9]+$/)) {
+        throw new Error(
+          `Attachment ${index + 1} must be in format 'base64hash.extension' (URL-safe base64)`
+        );
+      }
+    });
+  }
+
+  if (translations) {
+    for (const [lang, translation] of Object.entries(translations)) {
+      if (translation.match(/\nPublishing domain: /))
+        throw new Error(`Translation for ${lang} must not contain 'Publishing domain: '.`);
+      if (translation.match(/Translation [a-z]{2,3}:\n/))
+        throw new Error(`Translation for ${lang} must not contain 'Translation XX:\\n' pattern.`);
     }
-    const [day, month, year] = dateOfBirth.toUTCString().split(' ').filter((i, j) => [1, 2, 3].includes(j))
-    let content = "\n" +
-        "\t" + "Type: Person verification" + "\n" +
-        "\t" + "Description: We verified the following information about a person." + "\n" +
-        "\t" + "Name: " + name + "\n" +
-        "\t" + "Date of birth: " + [day.replace(/$0/, ''), month, year].join(' ') + "\n" +
-        "\t" + "City of birth: " + cityOfBirth + "\n" +
-        "\t" + "Country of birth: " + countryOfBirth + "\n" +
-        (jobTitle ? "\t" + "Job title: " + jobTitle + "\n" : "") +
-        (employer ? "\t" + "Employer: " + employer + "\n" : "") +
-        (ownDomain ? "\t" + "Owner of the domain: " + ownDomain + "\n" : "") +
-        (foreignDomain ? "\t" + "Foreign domain used for publishing statements: " + foreignDomain + "\n" : "") +
-        (picture ? "\t" + "Picture: " + picture + "\n" : "") +
-        (verificationMethod ? "\t" + "Verification method: " + verificationMethod + "\n" : "") +
-        (confidence ? "\t" + "Confidence: " + confidence + "\n" : "") +
-        (reliabilityPolicy ? "\t" + "Reliability policy: " + reliabilityPolicy + "\n" : "") +
-        ""
-    return content
-}
-
-export const parsePersonVerification = (s: string): PersonVerification => {
-    const domainVerificationRegex = new RegExp(''
-        + /^\n\tType: Person verification\n/.source
-        + /\tDescription: We verified the following information about a person.\n/.source
-        + /\tName: (?<name>[^\n]+?)\n/.source
-        + /\tDate of birth: (?<dateOfBirth>[^\n]+?)\n/.source
-        + /\tCity of birth: (?<cityOfBirth>[^\n]+?)\n/.source
-        + /\tCountry of birth: (?<countryOfBirth>[^\n]+?)\n/.source
-        + /(?:\tJob title: (?<jobTitle>[^\n]+?)\n)?/.source
-        + /(?:\tEmployer: (?<employer>[^\n]+?)\n)?/.source
-        + /(?:\tOwner of the domain: (?<domain>[^\n]+?)\n)?/.source
-        + /(?:\tForeign domain used for publishing statements: (?<foreignDomain>[^\n]+?)\n)?/.source
-        + /(?:\tPicture: (?<picture>[^\n]+?)\n)?/.source
-        + /(?:\tVerification method: (?<verificationMethod>[^\n]+?)\n)?/.source
-        + /(?:\tConfidence: (?<confidence>[^\n]+?)\n)?/.source
-        + /(?:\tReliability policy: (?<reliabilityPolicy>[^\n]+?)\n)?/.source
-        + /$/.source
+  }
+
+  const translationLines = translations
+    ? Object.entries(translations)
+        .map(([lang, translation]) => {
+          const translationWithNewline = translation + (translation.match(/\n$/) ? '' : '\n');
+          const indentedTranslation = translationWithNewline
+            .split('\n')
+            .map((line) => (line ? '    ' + line : line))
+            .join('\n');
+          return `Translation ${lang}:\n${indentedTranslation}`;
+        })
+        .join('')
+    : '';
+
+  const attachmentLines =
+    attachments && attachments.length > 0 ? 'Attachments: ' + attachments.join(', ') + '\n' : '';
+
+  const contentWithNewline = content + (content.match(/\n$/) ? '' : '\n');
+  // Only indent plain content (non-typed statements). Typed statements already have indentation from build functions.
+  const isTypedContent = contentWithNewline.trim().startsWith('Type:');
+  const finalContent = isTypedContent
+    ? contentWithNewline
+    : contentWithNewline
+        .split('\n')
+        .map((line) => (line ? '    ' + line : line))
+        .join('\n');
+
+  const statement =
+    'Stated protocol version: ' +
+    version +
+    '\n' +
+    'Publishing domain: ' +
+    domain +
+    '\n' +
+    'Author: ' +
+    (author || '') +
+    '\n' +
+    (representative && representative?.length > 0
+      ? 'Authorized signing representative: ' + (representative || '') + '\n'
+      : '') +
+    'Time: ' +
+    time.toUTCString() +
+    '\n' +
+    (tags && tags.length > 0 ? 'Tags: ' + tags.join(', ') + '\n' : '') +
+    (supersededStatement && supersededStatement?.length > 0
+      ? 'Superseded statement: ' + (supersededStatement || '') + '\n'
+      : '') +
+    'Statement content:\n' +
+    finalContent +
+    translationLines +
+    attachmentLines;
+  if (statement.length > 3000)
+    throw new Error('Statement must not be longer than 3,000 characters.');
+  return statement;
+};
+
+export const parseStatement = ({
+  statement: input,
+}: {
+  statement: string;
+}): Statement & { type?: string; formatVersion: string } => {
+  if (input.length > 3000) throw new Error('Statement must not be longer than 3,000 characters.');
+  const beforeTranslations = input.split(/\nTranslation [a-z]{2,3}:\n/)[0];
+  if (beforeTranslations.match(/\n\n/))
+    throw new Error(
+      'Statements cannot contain two line breaks in a row before translations, as this is used for separating statements.'
     );
-    const m = s.match(domainVerificationRegex)
-    if (!m) throw new Error("Invalid person verification format: " + s)
-    if (m[2] && !m[2].match(birthDateFormat)) throw new Error("Invalid birth date format: " + m[2])
-    let { d, month, y } = m[2].match(birthDateFormat)?.groups || {}
-    if (!d || !month || !y) throw new Error("Invalid birth date format: " + m[2])
-    return {
-        name: m[1],
-        dateOfBirth: new Date(Date.UTC(parseInt(y), monthIndex(month), parseInt(d))),
-        cityOfBirth: m[3],
-        countryOfBirth: m[4],
-        jobTitle: m[5],
-        employer: m[6],
-        ownDomain: m[7],
-        foreignDomain: m[8],
-        picture: m[9],
-        verificationMethod: m[10],
-        confidence: m[11] ? parseFloat(m[11]) : undefined,
-        reliabilityPolicy: m[12]
+
+  const signatureRegex = new RegExp(
+    '' +
+      /^(?<statement>[\s\S]+?)---\n/.source +
+      /Statement hash: (?<statementHash>[A-Za-z0-9_-]+)\n/.source +
+      /Public key: (?<publicKey>[A-Za-z0-9_-]+)\n/.source +
+      /Signature: (?<signature>[A-Za-z0-9_-]+)\n/.source +
+      /Algorithm: (?<algorithm>[^\n]+)\n/.source +
+      /$/.source
+  );
+  const signatureMatch = input.match(signatureRegex);
+
+  let statementToVerify = input;
+  let publicKey: string | undefined;
+  let signature: string | undefined;
+
+  if (signatureMatch && signatureMatch.groups) {
+    statementToVerify = signatureMatch.groups.statement;
+    const statementHash = signatureMatch.groups.statementHash;
+    publicKey = signatureMatch.groups.publicKey;
+    signature = signatureMatch.groups.signature;
+    const algorithm = signatureMatch.groups.algorithm;
+
+    if (algorithm !== 'Ed25519') {
+      throw new Error('Unsupported signature algorithm: ' + algorithm);
     }
-}
 
-export const buildVoteContent = ({ pollHash, poll, vote }: Vote) => {
-    const content = "\n" +
-        "\t" + "Type: Vote" + "\n" +
-        "\t" + "Poll id: " + pollHash + "\n" +
-        "\t" + "Poll: " + poll + "\n" +
-        "\t" + "Option: " + vote + "\n" +
-        ""
-    return content
-}
-
-export const parseVote = (s: string): Vote => {
-    const voteRegex = new RegExp(''
-        + /^\n\tType: Vote\n/.source
-        + /\tPoll id: (?<pollHash>[^\n]+?)\n/.source
-        + /\tPoll: (?<poll>[^\n]+?)\n/.source
-        + /\tOption: (?<vote>[^\n]+?)\n/.source
-        + /$/.source
-    );
-    const m = s.match(voteRegex)
-    if (!m) throw new Error("Invalid vote format: " + s)
-    return {
-        pollHash: m[1],
-        poll: m[2],
-        vote: m[3]
+    const computedHash = sha256(statementToVerify);
+    if (computedHash !== statementHash) {
+      throw new Error('Statement hash mismatch');
     }
-}
-
-export const buildDisputeAuthenticityContent = ({ hash, confidence, reliabilityPolicy }: DisputeAuthenticity) => {
-    const content = "\n" +
-        "\t" + "Type: Dispute statement authenticity" + "\n" +
-        "\t" + "Description: We think that the referenced statement is not authentic.\n" +
-        "\t" + "Hash of referenced statement: " + hash + "\n" +
-        (confidence ? "\t" + "Confidence: " + confidence + "\n" : "") +
-        (reliabilityPolicy ? "\t" + "Reliability policy: " + reliabilityPolicy + "\n" : "") +
-        ""
-    return content
-}
-
-export const parseDisputeAuthenticity = (s: string): DisputeAuthenticity => {
-    const disputeRegex = new RegExp(''
-        + /^\n\tType: Dispute statement authenticity\n/.source
-        + /\tDescription: We think that the referenced statement is not authentic.\n/.source
-        + /\tHash of referenced statement: (?<hash>[^\n]+?)\n/.source
-        + /(?:\tConfidence: (?<confidence>[^\n]*?)\n)?/.source
-        + /(?:\tReliability policy: (?<reliabilityPolicy>[^\n]+?)\n)?/.source
-        + /$/.source
-    );
-    const m = s.match(disputeRegex)
-    if (!m) throw new Error("Invalid dispute authenticity format: " + s)
-    return {
-        hash: m[1],
-        confidence: m[2] ? parseFloat(m[2]) : undefined,
-        reliabilityPolicy: m[3]
+
+    const isValid = verifySignature(statementToVerify, signature, publicKey);
+    if (!isValid) {
+      throw new Error('Invalid cryptographic signature');
     }
-}
-
-export const buildDisputeContentContent = ({ hash, confidence, reliabilityPolicy }: DisputeContent) => {
-    const content = "\n" +
-        "\t" + "Type: Dispute statement content" + "\n" +
-        "\t" + "Description: We think that the content of the referenced statement is false.\n" +
-        "\t" + "Hash of referenced statement: " + hash + "\n" +
-        (confidence ? "\t" + "Confidence: " + confidence + "\n" : "") +
-        (reliabilityPolicy ? "\t" + "Reliability policy: " + reliabilityPolicy + "\n" : "") +
-        ""
-    return content
-}
-
-export const parseDisputeContent = (s: string): DisputeContent => {
-    const disputeRegex = new RegExp(''
-        + /^\n\tType: Dispute statement content\n/.source
-        + /\tDescription: We think that the content of the referenced statement is false.\n/.source
-        + /\tHash of referenced statement: (?<hash>[^\n]+?)\n/.source
-        + /(?:\tConfidence: (?<confidence>[^\n]*?)\n)?/.source
-        + /(?:\tReliability policy: (?<reliabilityPolicy>[^\n]+?)\n)?/.source
-        + /$/.source
+  }
+
+  const statementRegex = new RegExp(
+    '' +
+      /^Stated protocol version: (?<formatVersion>[^\n]+?)\n/.source +
+      /Publishing domain: (?<domain>[^\n]+?)\n/.source +
+      /Author: (?<author>[^\n]+?)\n/.source +
+      /(?:Authorized signing representative: (?<representative>[^\n]*?)\n)?/.source +
+      /Time: (?<time>[^\n]+?)\n/.source +
+      /(?:Tags: (?<tags>[^\n]*?)\n)?/.source +
+      /(?:Superseded statement: (?<supersededStatement>[^\n]*?)\n)?/.source +
+      /Statement content:\n/.source +
+      /(?:(?<typedContent>    Type: (?<type>[^\n]+?)\n[\s\S]+?)(?=\nTranslation [a-z]{2,3}:\n|Attachments: |$)|(?<content>(?:    [\s\S]+?)?))/
+        .source +
+      /(?=\nTranslation [a-z]{2,3}:\n|Attachments: |$)/.source +
+      /(?<translations>(?:\nTranslation [a-z]{2,3}:\n[\s\S]+?)*)/.source +
+      /(?:Attachments: (?<attachments>[^\n]+?)\n)?/.source +
+      /$/.source
+  );
+  const match = statementToVerify.match(statementRegex);
+  if (!match || !match.groups) throw new Error('Invalid statement format: ' + input);
+
+  const {
+    domain,
+    author,
+    representative,
+    time: timeStr,
+    tags: tagsStr,
+    supersededStatement,
+    attachments: attachmentsStr,
+    formatVersion,
+    content,
+    typedContent,
+    type,
+    translations: translationsStr,
+  } = match.groups;
+
+  const parsed = {
+    domain,
+    author,
+    representative,
+    timeStr,
+    tagsStr,
+    supersededStatement,
+    formatVersion,
+    content: content
+      ? content
+          .split('\n')
+          .map((line) => (line.startsWith('    ') ? line.substring(4) : line))
+          .join('\n')
+          .replace(/\n$/, '')
+      : typedContent,
+    type: type ? type.toLowerCase().replace(' ', '_') : undefined,
+    translationsStr,
+  };
+  if (!parsed.timeStr.match(UTCFormat))
+    throw new Error('Invalid statement format: time must be in UTC');
+  if (!parsed.domain) throw new Error('Invalid statement format: domain is required');
+  if (!parsed.author) throw new Error('Invalid statement format: author is required');
+  if (!parsed.content) throw new Error('Invalid statement format: statement content is required');
+  if (!parsed.formatVersion)
+    throw new Error('Invalid statement format: format version is required');
+  if (parsed.formatVersion !== '5')
+    throw new Error(
+      `Invalid statement format: only version 5 is supported, got version ${parsed.formatVersion}`
     );
-    const m = s.match(disputeRegex)
-    if (!m) throw new Error("Invalid dispute content format: " + s)
-    return {
-        hash: m[1],
-        confidence: m[2] ? parseFloat(m[2]) : undefined,
-        reliabilityPolicy: m[3]
+
+  const tags = parsed.tagsStr?.split(', ');
+  const time = new Date(parsed.timeStr);
+
+  let attachments: string[] | undefined = undefined;
+  if (attachmentsStr && attachmentsStr.length > 0) {
+    attachments = attachmentsStr.split(', ').map((a) => a.trim());
+    if (attachments.length > 5) {
+      throw new Error('Maximum 5 attachments allowed');
     }
-}
+  }
+
+  let translations: Record<string, string> | undefined = undefined;
+  if (parsed.translationsStr && parsed.translationsStr.length > 0) {
+    translations = {};
+    const translationParts = parsed.translationsStr
+      .split(/\nTranslation ([a-z]{2,3}):\n/)
+      .filter((part) => part.length > 0);
+    for (let i = 0; i < translationParts.length; i += 2) {
+      if (i + 1 < translationParts.length) {
+        const lang = translationParts[i];
+        const rawTranslation = translationParts[i + 1];
+        // Strip indentation from translation content
+        const translation = rawTranslation
+          .split('\n')
+          .map((line) => (line.startsWith('    ') ? line.substring(4) : line))
+          .join('\n')
+          .replace(/\n$/, '');
+        translations[lang] = translation;
+      }
+    }
+  }
+
+  return {
+    domain: parsed.domain,
+    author: parsed.author,
+    representative: parsed.representative,
+    time,
+    tags: tags && tags.length > 0 ? tags : undefined,
+    supersededStatement: parsed.supersededStatement,
+    formatVersion: parsed.formatVersion,
+    content: parsed.content,
+    type: parsed.type?.toLowerCase().replace(' ', '_'),
+    translations: translations && Object.keys(translations).length > 0 ? translations : undefined,
+    attachments: attachments && attachments.length > 0 ? attachments : undefined,
+  };
+};
+
+export const buildPollContent = ({
+  deadline,
+  poll,
+  scopeDescription,
+  options,
+  allowArbitraryVote,
+}: Poll) => {
+  if (!poll) throw new Error('Poll must contain a poll question.');
+  if (poll.includes('\n')) throw new Error('Poll question must be single line.');
+  if (scopeDescription && scopeDescription.includes('\n'))
+    throw new Error('Scope description must be single line.');
+  options.forEach((option, index) => {
+    if (option && option.includes('\n'))
+      throw new Error(`Option ${index + 1} must be single line.`);
+  });
+  const content =
+    '    Type: Poll\n' +
+    (deadline ? '    Voting deadline: ' + deadline.toUTCString() + '\n' : '') +
+    '    Poll: ' +
+    poll +
+    '\n' +
+    (options.length > 0 && options[0] ? '    Option 1: ' + options[0] + '\n' : '') +
+    (options.length > 1 && options[1] ? '    Option 2: ' + options[1] + '\n' : '') +
+    (options.length > 2 && options[2] ? '    Option 3: ' + options[2] + '\n' : '') +
+    (options.length > 3 && options[3] ? '    Option 4: ' + options[3] + '\n' : '') +
+    (options.length > 4 && options[4] ? '    Option 5: ' + options[4] + '\n' : '') +
+    (allowArbitraryVote === true || allowArbitraryVote === false
+      ? '    Allow free text votes: ' + (allowArbitraryVote ? 'Yes' : 'No') + '\n'
+      : '') +
+    (scopeDescription ? '    Who can vote: ' + scopeDescription + '\n' : '');
+  return content;
+};
+
+export const parsePoll = (content: string, version?: string): Poll => {
+  if (version !== '5') throw new Error('Invalid version ' + version);
+  const pollRegex = new RegExp(
+    '' +
+      /^    Type: Poll\n/.source +
+      /(?:    Voting deadline: (?<deadline>[^\n]+?)\n)?/.source +
+      /    Poll: (?<poll>[^\n]+?)\n/.source +
+      /(?:    Option 1: (?<option1>[^\n]+?)\n)?/.source +
+      /(?:    Option 2: (?<option2>[^\n]+?)\n)?/.source +
+      /(?:    Option 3: (?<option3>[^\n]+?)\n)?/.source +
+      /(?:    Option 4: (?<option4>[^\n]+?)\n)?/.source +
+      /(?:    Option 5: (?<option5>[^\n]+?)\n)?/.source +
+      /(?:    Allow free text votes: (?<allowArbitraryVote>Yes|No)\n)?/.source +
+      /(?:    Who can vote: (?<scopeDescription>[^\n]+?)\n)?/.source +
+      /$/.source
+  );
+  const match = content.match(pollRegex);
+  if (!match || !match.groups) throw new Error('Invalid poll format: ' + content);
+
+  const {
+    deadline,
+    poll,
+    option1,
+    option2,
+    option3,
+    option4,
+    option5,
+    allowArbitraryVote: allowArbitraryVoteStr,
+    scopeDescription,
+  } = match.groups;
+
+  const options = [option1, option2, option3, option4, option5].filter((o) => o);
+  const allowArbitraryVote =
+    allowArbitraryVoteStr === 'Yes' ? true : allowArbitraryVoteStr === 'No' ? false : undefined;
+  const deadlineStr = deadline;
+  if (deadlineStr && !deadlineStr.match(UTCFormat))
+    throw new Error('Invalid poll, deadline must be in UTC: ' + deadlineStr);
+  return {
+    deadline: deadlineStr ? new Date(deadlineStr) : undefined,
+    poll,
+    options,
+    allowArbitraryVote,
+    scopeDescription,
+  };
+};
+
+export const buildOrganisationVerificationContent = ({
+  name,
+  englishName,
+  country,
+  city,
+  province,
+  legalForm,
+  department,
+  domain,
+  foreignDomain,
+  serialNumber,
+  confidence,
+  reliabilityPolicy,
+  employeeCount,
+  pictureHash,
+  latitude,
+  longitude,
+  population,
+  publicKey,
+}: OrganisationVerification) => {
+  if (!name || !country || !legalForm || (!domain && !foreignDomain))
+    throw new Error('Missing required fields');
+  if (!Object.values(legalForms).includes(legalForm))
+    throw new Error('Invalid legal form ' + legalForm);
+  if (employeeCount && !Object.values(peopleCountBuckets).includes(employeeCount))
+    throw new Error('Invalid employee count ' + employeeCount);
+  if (population && !Object.values(peopleCountBuckets).includes(population))
+    throw new Error('Invalid population ' + population);
+  if (confidence && !('' + confidence)?.match(/^[0-9.]+$/))
+    throw new Error('Invalid confidence ' + confidence);
+  if (pictureHash && !pictureHash.match(/^[A-Za-z0-9_-]+\.[a-zA-Z0-9]+$/)) {
+    throw new Error("Logo must be in format 'base64hash.extension' (URL-safe base64)");
+  }
+  if (publicKey && !publicKey.match(/^[A-Za-z0-9_-]+$/)) {
+    throw new Error('Public key must be in URL-safe base64 format (A-Z, a-z, 0-9, _, -)');
+  }
+
+  return (
+    '    Type: Organisation verification\n' +
+    '    Description: We verified the following information about an organisation.\n' +
+    '    Name: ' +
+    name +
+    '\n' +
+    (englishName ? '    English name: ' + englishName + '\n' : '') +
+    '    Country: ' +
+    country +
+    '\n' +
+    '    Legal form: ' +
+    legalForm +
+    '\n' +
+    (domain ? '    Owner of the domain: ' + domain + '\n' : '') +
+    (foreignDomain
+      ? '    Foreign domain used for publishing statements: ' + foreignDomain + '\n'
+      : '') +
+    (department ? '    Department using the domain: ' + department + '\n' : '') +
+    (province ? '    Province or state: ' + province + '\n' : '') +
+    (serialNumber ? '    Business register number: ' + serialNumber + '\n' : '') +
+    (city ? '    City: ' + city + '\n' : '') +
+    (latitude ? '    Latitude: ' + latitude + '\n' : '') +
+    (longitude ? '    Longitude: ' + longitude + '\n' : '') +
+    (population ? '    Population: ' + population + '\n' : '') +
+    (pictureHash ? '    Logo: ' + pictureHash + '\n' : '') +
+    (employeeCount ? '    Employee count: ' + employeeCount + '\n' : '') +
+    (publicKey ? '    Public key: ' + publicKey + '\n' : '') +
+    (reliabilityPolicy ? '    Reliability policy: ' + reliabilityPolicy + '\n' : '') +
+    (confidence ? '    Confidence: ' + confidence + '\n' : '')
+  );
+};
+
+export const parseOrganisationVerification = (content: string): OrganisationVerification => {
+  const organisationVerificationRegex = new RegExp(
+    '' +
+      /^    Type: Organisation verification\n/.source +
+      /    Description: We verified the following information about an organisation.\n/.source +
+      /    Name: (?<name>[^\n]+?)\n/.source +
+      /(?:    English name: (?<englishName>[^\n]+?)\n)?/.source +
+      /    Country: (?<country>[^\n]+?)\n/.source +
+      /    Legal (?:form|entity): (?<legalForm>[^\n]+?)\n/.source +
+      /(?:    Owner of the domain: (?<domain>[^\n]+?)\n)?/.source +
+      /(?:    Foreign domain used for publishing statements: (?<foreignDomain>[^\n]+?)\n)?/.source +
+      /(?:    Department using the domain: (?<department>[^\n]+?)\n)?/.source +
+      /(?:    Province or state: (?<province>[^\n]+?)\n)?/.source +
+      /(?:    Business register number: (?<serialNumber>[^\n]+?)\n)?/.source +
+      /(?:    City: (?<city>[^\n]+?)\n)?/.source +
+      /(?:    Latitude: (?<latitude>[^\n]+?)\n)?/.source +
+      /(?:    Longitude: (?<longitude>[^\n]+?)\n)?/.source +
+      /(?:    Population: (?<population>[^\n]+?)\n)?/.source +
+      /(?:    Logo: (?<pictureHash>[A-Za-z0-9_-]+\.[a-zA-Z0-9]+)\n)?/.source +
+      /(?:    Employee count: (?<employeeCount>[01,+-]+?)\n)?/.source +
+      /(?:    Public key: (?<publicKey>[A-Za-z0-9_-]+)\n)?/.source +
+      /(?:    Reliability policy: (?<reliabilityPolicy>[^\n]+?)\n)?/.source +
+      /(?:    Confidence: (?<confidence>[0-9.]+?))?/.source +
+      /\n?$/.source
+  );
+  const match = content.match(organisationVerificationRegex);
+  if (!match || !match.groups)
+    throw new Error('Invalid organisation verification format: ' + content);
+
+  const {
+    name,
+    englishName,
+    country,
+    legalForm,
+    domain,
+    foreignDomain,
+    department,
+    province,
+    serialNumber,
+    city,
+    latitude,
+    longitude,
+    population,
+    pictureHash,
+    employeeCount,
+    publicKey,
+    reliabilityPolicy,
+    confidence,
+  } = match.groups;
+
+  if (!isLegalForm(legalForm)) {
+    throw new Error('Invalid legal form after validation: ' + legalForm);
+  }
+
+  return {
+    name,
+    englishName,
+    country,
+    legalForm,
+    domain,
+    foreignDomain,
+    department,
+    province,
+    serialNumber,
+    city,
+    latitude: latitude ? parseFloat(latitude) : undefined,
+    longitude: longitude ? parseFloat(longitude) : undefined,
+    population: population && isPeopleCountBucket(population) ? population : undefined,
+    pictureHash,
+    employeeCount: employeeCount && isPeopleCountBucket(employeeCount) ? employeeCount : undefined,
+    publicKey,
+    reliabilityPolicy,
+    confidence: confidence ? parseFloat(confidence) : undefined,
+  };
+};
+
+export const buildPersonVerificationContent = ({
+  name,
+  countryOfBirth,
+  cityOfBirth,
+  ownDomain,
+  foreignDomain,
+  dateOfBirth,
+  jobTitle,
+  employer,
+  verificationMethod,
+  confidence,
+  picture,
+  reliabilityPolicy,
+  publicKey,
+}: PersonVerification) => {
+  if (!name || !countryOfBirth || !cityOfBirth || !dateOfBirth || (!ownDomain && !foreignDomain)) {
+    throw new Error('Missing required fields for person verification');
+  }
+  if (publicKey && !publicKey.match(/^[A-Za-z0-9_-]+$/)) {
+    throw new Error('Public key must be in URL-safe base64 format (A-Z, a-z, 0-9, _, -)');
+  }
+  const [day, month, year] = dateOfBirth
+    .toUTCString()
+    .split(' ')
+    .filter((_i, j) => [1, 2, 3].includes(j));
+  const content =
+    '    Type: Person verification\n' +
+    '    Description: We verified the following information about a person.\n' +
+    '    Name: ' +
+    name +
+    '\n' +
+    '    Date of birth: ' +
+    [day.replace(/^0/, ''), month, year].join(' ') +
+    '\n' +
+    '    City of birth: ' +
+    cityOfBirth +
+    '\n' +
+    '    Country of birth: ' +
+    countryOfBirth +
+    '\n' +
+    (jobTitle ? '    Job title: ' + jobTitle + '\n' : '') +
+    (employer ? '    Employer: ' + employer + '\n' : '') +
+    (ownDomain ? '    Owner of the domain: ' + ownDomain + '\n' : '') +
+    (foreignDomain
+      ? '    Foreign domain used for publishing statements: ' + foreignDomain + '\n'
+      : '') +
+    (picture ? '    Picture: ' + picture + '\n' : '') +
+    (verificationMethod ? '    Verification method: ' + verificationMethod + '\n' : '') +
+    (publicKey ? '    Public key: ' + publicKey + '\n' : '') +
+    (confidence ? '    Confidence: ' + confidence + '\n' : '') +
+    (reliabilityPolicy ? '    Reliability policy: ' + reliabilityPolicy + '\n' : '');
+  return content;
+};
+
+export const parsePersonVerification = (content: string): PersonVerification => {
+  const domainVerificationRegex = new RegExp(
+    '' +
+      /^    Type: Person verification\n/.source +
+      /    Description: We verified the following information about a person.\n/.source +
+      /    Name: (?<name>[^\n]+?)\n/.source +
+      /    Date of birth: (?<dateOfBirth>[^\n]+?)\n/.source +
+      /    City of birth: (?<cityOfBirth>[^\n]+?)\n/.source +
+      /    Country of birth: (?<countryOfBirth>[^\n]+?)\n/.source +
+      /(?:    Job title: (?<jobTitle>[^\n]+?)\n)?/.source +
+      /(?:    Employer: (?<employer>[^\n]+?)\n)?/.source +
+      /(?:    Owner of the domain: (?<domain>[^\n]+?)\n)?/.source +
+      /(?:    Foreign domain used for publishing statements: (?<foreignDomain>[^\n]+?)\n)?/.source +
+      /(?:    Picture: (?<picture>[^\n]+?)\n)?/.source +
+      /(?:    Verification method: (?<verificationMethod>[^\n]+?)\n)?/.source +
+      /(?:    Public key: (?<publicKey>[A-Za-z0-9_-]+)\n)?/.source +
+      /(?:    Confidence: (?<confidence>[^\n]+?)\n)?/.source +
+      /(?:    Reliability policy: (?<reliabilityPolicy>[^\n]+?)\n)?/.source +
+      /$/.source
+  );
+  const match = content.match(domainVerificationRegex);
+  if (!match || !match.groups) throw new Error('Invalid person verification format: ' + content);
+
+  const {
+    name,
+    dateOfBirth: dateOfBirthStr,
+    cityOfBirth,
+    countryOfBirth,
+    jobTitle,
+    employer,
+    domain,
+    foreignDomain,
+    picture,
+    verificationMethod,
+    publicKey,
+    confidence,
+    reliabilityPolicy,
+  } = match.groups;
+
+  if (dateOfBirthStr && !dateOfBirthStr.match(birthDateFormat))
+    throw new Error('Invalid birth date format: ' + dateOfBirthStr);
+  const { d, month, y } = dateOfBirthStr.match(birthDateFormat)?.groups || {};
+  if (!d || !month || !y) throw new Error('Invalid birth date format: ' + dateOfBirthStr);
+
+  return {
+    name,
+    dateOfBirth: new Date(Date.UTC(parseInt(y), monthIndex(month), parseInt(d))),
+    cityOfBirth,
+    countryOfBirth,
+    jobTitle,
+    employer,
+    ownDomain: domain,
+    foreignDomain,
+    picture,
+    verificationMethod,
+    publicKey,
+    confidence: confidence ? parseFloat(confidence) : undefined,
+    reliabilityPolicy,
+  };
+};
+
+export const buildVoteContent = ({ pollHash, poll, vote }: Vote) => {
+  const content =
+    '    Type: Vote\n' +
+    '    Poll id: ' +
+    pollHash +
+    '\n' +
+    '    Poll:\n        ' +
+    poll +
+    '\n' +
+    '    Option:\n        ' +
+    vote +
+    '\n';
+  return content;
+};
+
+export const parseVote = (content: string): Vote => {
+  const voteRegex = new RegExp(
+    '' +
+      /^    Type: Vote\n/.source +
+      /    Poll id: (?<pollHash>[^\n]+?)\n/.source +
+      /    Poll:\n        (?<poll>[^\n]+?)\n/.source +
+      /    Option:\n        (?<vote>[^\n]+?)\n/.source +
+      /$/.source
+  );
+  const match = content.match(voteRegex);
+  if (!match || !match.groups) throw new Error('Invalid vote format: ' + content);
+
+  const { pollHash, poll, vote } = match.groups;
+  return { pollHash, poll, vote };
+};
+
+export const buildDisputeAuthenticityContent = ({
+  hash,
+  confidence,
+  reliabilityPolicy,
+}: DisputeAuthenticity) => {
+  const content =
+    '    Type: Dispute statement authenticity\n' +
+    '    Description: We think that the referenced statement is not authentic.\n' +
+    '    Hash of referenced statement: ' +
+    hash +
+    '\n' +
+    (confidence ? '    Confidence: ' + confidence + '\n' : '') +
+    (reliabilityPolicy ? '    Reliability policy: ' + reliabilityPolicy + '\n' : '');
+  return content;
+};
+
+export const parseDisputeAuthenticity = (content: string): DisputeAuthenticity => {
+  const disputeRegex = new RegExp(
+    '' +
+      /^    Type: Dispute statement authenticity\n/.source +
+      /    Description: We think that the referenced statement is not authentic.\n/.source +
+      /    Hash of referenced statement: (?<hash>[^\n]+?)\n/.source +
+      /(?:    Confidence: (?<confidence>[^\n]*?)\n)?/.source +
+      /(?:    Reliability policy: (?<reliabilityPolicy>[^\n]+?)\n)?/.source +
+      /$/.source
+  );
+  const match = content.match(disputeRegex);
+  if (!match || !match.groups) throw new Error('Invalid dispute authenticity format: ' + content);
+
+  const { hash, confidence, reliabilityPolicy } = match.groups;
+  return {
+    hash,
+    confidence: confidence ? parseFloat(confidence) : undefined,
+    reliabilityPolicy,
+  };
+};
+
+export const buildDisputeContentContent = ({
+  hash,
+  confidence,
+  reliabilityPolicy,
+}: DisputeContent) => {
+  const content =
+    '    Type: Dispute statement content\n' +
+    '    Description: We think that the content of the referenced statement is false.\n' +
+    '    Hash of referenced statement: ' +
+    hash +
+    '\n' +
+    (confidence ? '    Confidence: ' + confidence + '\n' : '') +
+    (reliabilityPolicy ? '    Reliability policy: ' + reliabilityPolicy + '\n' : '');
+  return content;
+};
+
+export const parseDisputeContent = (content: string): DisputeContent => {
+  const disputeRegex = new RegExp(
+    '' +
+      /^    Type: Dispute statement content\n/.source +
+      /    Description: We think that the content of the referenced statement is false.\n/.source +
+      /    Hash of referenced statement: (?<hash>[^\n]+?)\n/.source +
+      /(?:    Confidence: (?<confidence>[^\n]*?)\n)?/.source +
+      /(?:    Reliability policy: (?<reliabilityPolicy>[^\n]+?)\n)?/.source +
+      /$/.source
+  );
+  const match = content.match(disputeRegex);
+  if (!match || !match.groups) throw new Error('Invalid dispute content format: ' + content);
+
+  const { hash, confidence, reliabilityPolicy } = match.groups;
+  return {
+    hash,
+    confidence: confidence ? parseFloat(confidence) : undefined,
+    reliabilityPolicy,
+  };
+};
 
 export const buildResponseContent = ({ hash, response }: ResponseContent) => {
-    const content = "\n" +
-        "\t" + "Type: Response" + "\n" +
-        "\t" + "Hash of referenced statement: " + hash + "\n" +
-        "\t" + "Response: " + response + "\n" +
-        ""
-    return content
-}
-
-export const parseResponseContent = (s: string): ResponseContent => {
-    const disputeRegex = new RegExp(''
-        + /^\n\tType: Response\n/.source
-        + /\tHash of referenced statement: (?<hash>[^\n]+?)\n/.source
-        + /\tResponse: (?<response>[^\n]*?)\n/.source
-        + /$/.source
-    );
-    const m = s.match(disputeRegex)
-    if (!m) throw new Error("Invalid response content format: " + s)
-    return {
-        hash: m[1],
-        response: m[2]
-    }
-}
+  const content =
+    '    Type: Response\n' +
+    '    Hash of referenced statement: ' +
+    hash +
+    '\n' +
+    '    Response:\n        ' +
+    response +
+    '\n';
+  return content;
+};
+
+export const parseResponseContent = (content: string): ResponseContent => {
+  const responseRegex = new RegExp(
+    '' +
+      /^    Type: Response\n/.source +
+      /    Hash of referenced statement: (?<hash>[^\n]+?)\n/.source +
+      /    Response:\n        (?<response>[^\n]*?)\n/.source +
+      /$/.source
+  );
+  const match = content.match(responseRegex);
+  if (!match || !match.groups) throw new Error('Invalid response content format: ' + content);
+
+  const { hash, response } = match.groups;
+  return { hash, response };
+};
 
 export const buildPDFSigningContent = ({ hash }: PDFSigning) => {
-    const content = "\n" +
-        "\t" + "Type: Sign PDF" + "\n" +
-        "\t" + "Description: We hereby digitally sign the referenced PDF file.\n" +
-        "\t" + "PDF file hash: " + hash + "\n" +
-        ""
-    return content
-}
-
-export const parsePDFSigning = (s: string): PDFSigning => {
-    const signingRegex = new RegExp(''
-        + /^\n\tType: Sign PDF\n/.source
-        + /\tDescription: We hereby digitally sign the referenced PDF file.\n/.source
-        + /\tPDF file hash: (?<hash>[^\n]+?)\n/.source
-        + /$/.source
-    );
-    const m = s.match(signingRegex)
-    if (!m) throw new Error("Invalid PDF signing format: " + s)
-    return {
-        hash: m[1]
-    }
-}
-
-export const buildRating = ({ subjectName, subjectType, subjectReference, documentFileHash, rating, quality, comment }: Rating) => {
-    if (![1, 2, 3, 4, 5].includes(rating)) throw new Error("Invalid rating: " + rating)
-    const content = "\n" +
-        "\t" + "Type: Rating" + "\n" +
-        (subjectType ? "\t" + "Subject type: " + subjectType + "\n" : "") +
-        "\t" + "Subject name: " + subjectName + "\n" +
-        (subjectReference ? "\t" + "URL that identifies the subject: " + subjectReference + "\n" : "") +
-        (documentFileHash ? "\t" + "Document file hash: " + documentFileHash + "\n" : "") +
-        (quality ? "\t" + "Rated quality: " + quality + "\n" : "") +
-        "\t" + "Our rating: " + rating + "/5 Stars\n" +
-        (comment ? "\t" + "Comment: " + comment + "\n" : "") +
-        ""
-    return content
-}
-
-export const parseRating = (s: string): Rating => {
-    const ratingRegex = new RegExp(''
-        + /^\n\tType: Rating\n/.source
-        + /(?:\tSubject type: (?<subjectType>[^\n]*?)\n)?/.source
-        + /\tSubject name: (?<subjectName>[^\n]*?)\n/.source
-        + /(?:\tURL that identifies the subject: (?<subjectReference>[^\n]*?)\n)?/.source
-        + /(?:\tDocument file hash: (?<documentFileHash>[^\n]*?)\n)?/.source
-        + /(?:\tRated quality: (?<quality>[^\n]*?)\n)?/.source
-        + /\tOur rating: (?<rating>[1-5])\/5 Stars\n/.source
-        + /(?:\tComment: (?<comment>[\s\S]+?)\n)?/.source
-        + /$/.source
-    );
-    const m = s.match(ratingRegex)
-    if (!m) throw new Error("Invalid rating format: " + s)
-    const rating = parseInt(m[6])
-    if (![1, 2, 3, 4, 5].includes(rating)) throw new Error("Invalid rating: " + m[6])
-    if (m[1] && !['Organisation', 'Policy proposal', 'Regulation',
-        'Treaty draft', 'Product', 'Research publication'].includes(m[1])) throw new Error("Invalid subject type: " + m[1])
-    if (!m[2]) throw new Error("Missing subject name")
-    return {
-        subjectType: m[1] as RatingSubjectTypeValue,
-        subjectName: m[2],
-        subjectReference: m[3],
-        documentFileHash: m[4],
-        quality: m[5],
-        rating,
-        comment: m[7]
-    }
-}
-
-export const buildBounty = ({ motivation, bounty, reward, judge, judgePay }: Bounty) => {
-    const content = "\n" +
-        "\t" + "Type: Bounty" + "\n" +
-        (motivation ? "\t" + "In order to: " + motivation + "\n" : "") +
-        "\t" + "We will reward any entity that: " + bounty + "\n" +
-        "\t" + "The reward is: " + reward + "\n" +
-        "\t" + "In case of dispute, bounty claims are judged by: " + judge + "\n" +
-        (judgePay ? "\t" + "The judge will be paid per investigated case with a maxium of: " + judgePay + "\n" : "") +
-        ""
-    return content
-}
-
-export const parseBounty = (s: string): Bounty => {
-    const bountyRegex = new RegExp(''
-        + /^\n\tType: Bounty\n/.source
-        + /(?:\tIn order to: (?<motivation>[^\n]*?)\n)?/.source
-        + /\tWe will reward any entity that: (?<bounty>[^\n]*?)\n/.source
-        + /\tThe reward is: (?<reward>[^\n]*?)\n/.source
-        + /\tIn case of dispute, bounty claims are judged by: (?<judge>[^\n]*?)\n/.source
-        + /(?:\tThe judge will be paid per investigated case with a maxium of: (?<judgePay>[^\n]*?)\n)?/.source
-        + /$/.source
-    );
-    const m = s.match(bountyRegex)
-    if (!m) throw new Error("Invalid bounty format: " + s)
-    return {
-        motivation: m[1],
-        bounty: m[2],
-        reward: m[3],
-        judge: m[4],
-        judgePay: m[5]
-    }
-}
-
-export const buildObservation = ({ approach, confidence, reliabilityPolicy, subject, subjectReference, observationReference, property, value }: Observation) => {
-    const content = "\n" +
-        "\t" + "Type: Observation" + "\n" +
-        (approach ? "\t" + "Approach: " + approach + "\n" : "") +
-        (confidence ? "\t" + "Confidence: " + confidence + "\n" : "") +
-        (reliabilityPolicy ? "\t" + "Reliability policy: " + reliabilityPolicy + "\n" : "") +
-        "\t" + "Subject: " + subject + "\n" +
-        (subjectReference ? "\t" + "Subject identity reference: " + subjectReference + "\n" : "") +
-        (observationReference ? "\t" + "Observation reference: " + observationReference + "\n" : "") +
-        "\t" + "Observed property: " + property + "\n" +
-        (value ? "\t" + "Observed value: " + value + "\n" : "") +
-        ""
-    return content
-}
-
-export const parseObservation = (s: string): Observation => {
-    const observationRegex = new RegExp(''
-        + /^\n\tType: Observation\n/.source
-        + /(?:\tApproach: (?<approach>[^\n]*?)\n)?/.source
-        + /(?:\tConfidence: (?<confidence>[^\n]*?)\n)?/.source
-        + /(?:\tReliability policy: (?<reliabilityPolicy>[^\n]+?)\n)?/.source
-        + /\tSubject: (?<subject>[^\n]*?)\n/.source
-        + /(?:\tSubject identity reference: (?<subjectReference>[^\n]*?)\n)?/.source
-        + /(?:\tObservation reference: (?<observationReference>[^\n]*?)\n)?/.source
-        + /\tObserved property: (?<property>[^\n]*?)\n/.source
-        + /(?:\tObserved value: (?<value>[\s\S]+?)\n)?/.source
-        + /$/.source
-    );
-    const m = s.match(observationRegex)
-    if (!m) throw new Error("Invalid observation format: " + s)
-    return {
-        approach: m[1],
-        confidence: m[2] ? parseFloat(m[2]) : undefined,
-        reliabilityPolicy: m[3],
-        subject: m[4],
-        subjectReference: m[5],
-        observationReference: m[6],
-        property: m[7],
-        value: m[8]
-    }
-}
-
-export const buildBoycott = ({ description, subject, subjectReference }: Boycott) => {
-    const content = "\n" +
-        "\t" + "Type: Boycott" + "\n" +
-        (description ? "\t" + "Description: " + description + "\n" : "") +
-        "\t" + "Subject: " + subject + "\n" +
-        (subjectReference ? "\t" + "Subject identity reference: " + subjectReference + "\n" : "") +
-        ""
-    return content
-}
-
-export const parseBoycott = (s: string): Boycott => {
-    const observationRegex = new RegExp(''
-        + /^\n\tType: Boycott\n/.source
-        + /(?:\tDescription: (?<description>[^\n]*?)\n)?/.source
-        + /\tSubject: (?<subject>[^\n]*?)\n/.source
-        + /(?:\tSubject identity reference: (?<subjectReference>[^\n]*?)\n)?/.source
-        + /$/.source
-    );
-    const m = s.match(observationRegex)
-    if (!m) throw new Error("Invalid observation format: " + s)
-    return {
-        description: m[1],
-        subject: m[2],
-        subjectReference: m[3],
-    }
-}
+  if (!hash.match(/^[A-Za-z0-9_-]+$/)) {
+    throw new Error('PDF file hash must be in URL-safe base64 format (A-Z, a-z, 0-9, _, -)');
+  }
+  const content =
+    '    Type: Sign PDF\n' +
+    '    Description: We hereby digitally sign the referenced PDF file.\n' +
+    '    PDF file hash: ' +
+    hash +
+    '\n';
+  return content;
+};
+
+export const parsePDFSigning = (content: string): PDFSigning => {
+  const signingRegex = new RegExp(
+    '' +
+      /^    Type: Sign PDF\n/.source +
+      /    Description: We hereby digitally sign the referenced PDF file.\n/.source +
+      /    PDF file hash: (?<hash>[A-Za-z0-9_-]+)\n/.source +
+      /$/.source
+  );
+  const match = content.match(signingRegex);
+  if (!match || !match.groups) throw new Error('Invalid PDF signing format: ' + content);
+
+  const { hash } = match.groups;
+  return { hash };
+};
+
+export const buildRating = ({
+  subjectName,
+  subjectType,
+  subjectReference,
+  documentFileHash,
+  rating,
+  quality,
+  comment,
+}: Rating) => {
+  if (![1, 2, 3, 4, 5].includes(rating)) throw new Error('Invalid rating: ' + rating);
+  const content =
+    '    Type: Rating\n' +
+    (subjectType ? '    Subject type: ' + subjectType + '\n' : '') +
+    '    Subject name: ' +
+    subjectName +
+    '\n' +
+    (subjectReference ? '    URL that identifies the subject: ' + subjectReference + '\n' : '') +
+    (documentFileHash ? '    Document file hash: ' + documentFileHash + '\n' : '') +
+    (quality ? '    Rated quality: ' + quality + '\n' : '') +
+    '    Our rating: ' +
+    rating +
+    '/5 Stars\n' +
+    (comment ? '    Comment:\n        ' + comment + '\n' : '');
+  return content;
+};
+
+export const parseRating = (content: string): Rating => {
+  const ratingRegex = new RegExp(
+    '' +
+      /^    Type: Rating\n/.source +
+      /(?:    Subject type: (?<subjectType>[^\n]*?)\n)?/.source +
+      /    Subject name: (?<subjectName>[^\n]*?)\n/.source +
+      /(?:    URL that identifies the subject: (?<subjectReference>[^\n]*?)\n)?/.source +
+      /(?:    Document file hash: (?<documentFileHash>[^\n]*?)\n)?/.source +
+      /(?:    Rated quality: (?<quality>[^\n]*?)\n)?/.source +
+      /    Our rating: (?<rating>[1-5])\/5 Stars\n/.source +
+      /(?:    Comment:\n        (?<comment>[\s\S]+?)\n)?/.source +
+      /$/.source
+  );
+  const match = content.match(ratingRegex);
+  if (!match || !match.groups) throw new Error('Invalid rating format: ' + content);
+
+  const {
+    subjectType,
+    subjectName,
+    subjectReference,
+    documentFileHash,
+    quality,
+    rating: ratingStr,
+    comment,
+  } = match.groups;
+
+  const rating = parseInt(ratingStr);
+  if (![1, 2, 3, 4, 5].includes(rating)) throw new Error('Invalid rating: ' + ratingStr);
+  if (
+    subjectType &&
+    ![
+      'Organisation',
+      'Policy proposal',
+      'Regulation',
+      'Treaty draft',
+      'Product',
+      'Research publication',
+    ].includes(subjectType)
+  )
+    throw new Error('Invalid subject type: ' + subjectType);
+  if (!subjectName) throw new Error('Missing subject name');
+
+  if (!isRatingValue(rating)) {
+    throw new Error('Invalid rating after validation: ' + rating);
+  }
+
+  return {
+    subjectType: subjectType as RatingSubjectTypeValue,
+    subjectName,
+    subjectReference,
+    documentFileHash,
+    quality,
+    rating,
+    comment,
+  };
+};