stated-protocol-parser 1.0.7 → 5.0.0

package/dist/protocol.js

@@ -14,671 +14,664 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseBoycott = exports.buildBoycott = exports.parseObservation = exports.buildObservation = exports.parseBounty = exports.buildBounty = exports.parseRating = exports.buildRating = exports.parsePDFSigning = exports.buildPDFSigningContent = exports.parseResponseContent = exports.buildResponseContent = exports.parseDisputeContent = exports.buildDisputeContentContent = exports.parseDisputeAuthenticity = exports.buildDisputeAuthenticityContent = exports.parseVote = exports.buildVoteContent = exports.parsePersonVerification = exports.buildPersonVerificationContent = exports.parseOrganisationVerification = exports.buildOrganisationVerificationContent = exports.parsePoll = exports.buildPollContent = exports.parseQuotation = exports.buildQuotationContent = exports.parseStatement = exports.buildStatement = void 0;
-/* eslint-disable no-useless-concat */
+exports.parseRating = exports.buildRating = exports.parsePDFSigning = exports.buildPDFSigningContent = exports.parseResponseContent = exports.buildResponseContent = exports.parseDisputeContent = exports.buildDisputeContentContent = exports.parseDisputeAuthenticity = exports.buildDisputeAuthenticityContent = exports.parseVote = exports.buildVoteContent = exports.parsePersonVerification = exports.buildPersonVerificationContent = exports.parseOrganisationVerification = exports.buildOrganisationVerificationContent = exports.parsePoll = exports.buildPollContent = exports.parseStatement = exports.buildStatement = void 0;
 const constants_1 = require("./constants");
-const v3_1 = require("./v3");
 const utils_1 = require("./utils");
-const fallBackVersion = 3;
-const version = 4;
+const signature_1 = require("./signature");
+const hash_1 = require("./hash");
+const types_1 = require("./types");
+const version = 5;
 __exportStar(require("./types"), exports);
 __exportStar(require("./constants"), exports);
 __exportStar(require("./utils"), exports);
-__exportStar(require("./v3"), exports);
-const buildStatement = ({ domain, author, time, tags, content, representative, supersededStatement }) => {
+const buildStatement = ({ domain, author, time, tags, content, representative, supersededStatement, translations, attachments, }) => {
     if (content.match(/\nPublishing domain: /))
-        throw (new Error("Statement must not contain 'Publishing domain: ', as this marks the beginning of a new statement."));
+        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."));
+        throw new Error('Statement content must not contain two line breaks in a row, as this is used for separating statements.');
+    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.");
+    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."));
+        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");
+        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 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."));
+        throw new Error('Statement must not be longer than 3,000 characters.');
     return statement;
 };
 exports.buildStatement = buildStatement;
-const parseStatement = ({ statement: s, allowNoVersion = false }) => {
-    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);
-    const match = s.match(statementRegex);
-    if (!match)
-        throw new Error("Invalid statement format:" + s);
-    const m = {
-        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
+const parseStatement = ({ statement: input, }) => {
+    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 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;
+    let signature;
+    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);
+        }
+        const computedHash = (0, hash_1.sha256)(statementToVerify);
+        if (computedHash !== statementHash) {
+            throw new Error('Statement hash mismatch');
+        }
+        const isValid = (0, signature_1.verifySignature)(statementToVerify, signature, publicKey);
+        if (!isValid) {
+            throw new Error('Invalid cryptographic signature');
+        }
+    }
+    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 (!(m['timeStr'].match(constants_1.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']);
+    if (!parsed.timeStr.match(constants_1.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 tags = parsed.tagsStr?.split(', ');
+    const time = new Date(parsed.timeStr);
+    let attachments = 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 = 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: m['domain'],
-        author: m['author'],
-        representative: m['representative'],
+        domain: parsed.domain,
+        author: parsed.author,
+        representative: parsed.representative,
         time,
-        tags: (tags && tags.length > 0) ? tags : undefined,
-        supersededStatement: m['supersededStatement'],
-        formatVersion: m['formatVersion'] || ('' + fallBackVersion),
-        content: m['content'],
-        type: m['type']?.toLowerCase().replace(' ', '_'),
+        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,
     };
 };
 exports.parseStatement = parseStatement;
-const buildQuotationContent = ({ originalAuthor, authorVerification, originalTime, source, quotation, paraphrasedStatement, picture, confidence }) => {
-    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;
-};
-exports.buildQuotationContent = buildQuotationContent;
-const parseQuotation = (s) => {
-    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);
-    let match = s.match(voteRegex);
-    if (!match)
-        throw new Error("Invalid quotation format: " + s);
-    let m = {};
-    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(' ', '_'),
-    };
-};
-exports.parseQuotation = parseQuotation;
-const buildPollContent = ({ country, city, legalEntity, domainScope, judges, deadline, poll, scopeDescription, scopeQueryLink, options, allowArbitraryVote, requiredProperty: propertyScope, requiredPropertyObserver: propertyScopeObserver }) => {
+const buildPollContent = ({ deadline, poll, scopeDescription, options, allowArbitraryVote, }) => {
     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 : "") +
-        "";
+        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;
 };
 exports.buildPollContent = buildPollContent;
-const parsePoll = (s, version) => {
-    if (version && version === '3')
-        return (0, v3_1.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 = 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 = {};
-    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 = 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?.split(', ');
-    const allowArbitraryVote = (m['allowArbitraryVote'] === 'Yes' ? true :
-        (m['allowArbitraryVote'] === 'No' ? false : undefined));
-    const deadlineStr = m.deadline;
+const parsePoll = (content, version) => {
+    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(constants_1.UTCFormat))
-        throw new Error("Invalid poll, deadline must be in UTC: " + deadlineStr);
+        throw new Error('Invalid poll, deadline must be in UTC: ' + deadlineStr);
     return {
-        judges: m['judges'],
         deadline: deadlineStr ? new Date(deadlineStr) : undefined,
-        poll: m['poll'],
+        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,
+        scopeDescription,
     };
 };
 exports.parsePoll = parsePoll;
-const buildOrganisationVerificationContent = ({ name, englishName, country, city, province, legalForm, department, domain, foreignDomain, serialNumber, confidence, reliabilityPolicy, employeeCount, pictureHash, latitude, longitude, population }) => {
+const buildOrganisationVerificationContent = ({ name, englishName, country, city, province, legalForm, department, domain, foreignDomain, serialNumber, confidence, reliabilityPolicy, employeeCount, pictureHash, latitude, longitude, population, publicKey, }) => {
     if (!name || !country || !legalForm || (!domain && !foreignDomain))
-        throw new Error("Missing required fields");
+        throw new Error('Missing required fields');
     if (!Object.values(constants_1.legalForms).includes(legalForm))
-        throw new Error("Invalid legal form " + legalForm);
+        throw new Error('Invalid legal form ' + legalForm);
     if (employeeCount && !Object.values(constants_1.peopleCountBuckets).includes(employeeCount))
-        throw new Error("Invalid employee count " + employeeCount);
+        throw new Error('Invalid employee count ' + employeeCount);
     if (population && !Object.values(constants_1.peopleCountBuckets).includes(population))
-        throw new Error("Invalid population " + 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" : "") +
-        "";
+        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' : ''));
 };
 exports.buildOrganisationVerificationContent = buildOrganisationVerificationContent;
-const parseOrganisationVerification = (s) => {
-    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);
-    const m = s.match(organisationVerificationRegex);
-    if (!m)
-        throw new Error("Invalid organisation verification format: " + s);
+const parseOrganisationVerification = (content) => {
+    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 (!(0, types_1.isLegalForm)(legalForm)) {
+        throw new Error('Invalid legal form after validation: ' + legalForm);
+    }
     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,
+        name,
+        englishName,
+        country,
+        legalForm,
+        domain,
+        foreignDomain,
+        department,
+        province,
+        serialNumber,
+        city,
+        latitude: latitude ? parseFloat(latitude) : undefined,
+        longitude: longitude ? parseFloat(longitude) : undefined,
+        population: population && (0, types_1.isPeopleCountBucket)(population) ? population : undefined,
+        pictureHash,
+        employeeCount: employeeCount && (0, types_1.isPeopleCountBucket)(employeeCount) ? employeeCount : undefined,
+        publicKey,
+        reliabilityPolicy,
+        confidence: confidence ? parseFloat(confidence) : undefined,
     };
 };
 exports.parseOrganisationVerification = parseOrganisationVerification;
-const buildPersonVerificationContent = ({ name, countryOfBirth, cityOfBirth, ownDomain, foreignDomain, dateOfBirth, jobTitle, employer, verificationMethod, confidence, picture, reliabilityPolicy }) => {
+const buildPersonVerificationContent = ({ name, countryOfBirth, cityOfBirth, ownDomain, foreignDomain, dateOfBirth, jobTitle, employer, verificationMethod, confidence, picture, reliabilityPolicy, publicKey, }) => {
     if (!name || !countryOfBirth || !cityOfBirth || !dateOfBirth || (!ownDomain && !foreignDomain)) {
-        console.log("Missing required fields: ", { name, countryOfBirth, cityOfBirth, dateOfBirth, ownDomain, foreignDomain });
-        return "";
+        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));
-    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" : "") +
-        "";
+    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;
 };
 exports.buildPersonVerificationContent = buildPersonVerificationContent;
-const parsePersonVerification = (s) => {
-    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 m = s.match(domainVerificationRegex);
-    if (!m)
-        throw new Error("Invalid person verification format: " + s);
-    if (m[2] && !m[2].match(utils_1.birthDateFormat))
-        throw new Error("Invalid birth date format: " + m[2]);
-    let { d, month, y } = m[2].match(utils_1.birthDateFormat)?.groups || {};
+const parsePersonVerification = (content) => {
+    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(utils_1.birthDateFormat))
+        throw new Error('Invalid birth date format: ' + dateOfBirthStr);
+    const { d, month, y } = dateOfBirthStr.match(utils_1.birthDateFormat)?.groups || {};
     if (!d || !month || !y)
-        throw new Error("Invalid birth date format: " + m[2]);
+        throw new Error('Invalid birth date format: ' + dateOfBirthStr);
     return {
-        name: m[1],
+        name,
         dateOfBirth: new Date(Date.UTC(parseInt(y), (0, utils_1.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]
+        cityOfBirth,
+        countryOfBirth,
+        jobTitle,
+        employer,
+        ownDomain: domain,
+        foreignDomain,
+        picture,
+        verificationMethod,
+        publicKey,
+        confidence: confidence ? parseFloat(confidence) : undefined,
+        reliabilityPolicy,
     };
 };
 exports.parsePersonVerification = parsePersonVerification;
 const buildVoteContent = ({ pollHash, poll, vote }) => {
-    const content = "\n" +
-        "\t" + "Type: Vote" + "\n" +
-        "\t" + "Poll id: " + pollHash + "\n" +
-        "\t" + "Poll: " + poll + "\n" +
-        "\t" + "Option: " + vote + "\n" +
-        "";
+    const content = '    Type: Vote\n' +
+        '    Poll id: ' +
+        pollHash +
+        '\n' +
+        '    Poll:\n        ' +
+        poll +
+        '\n' +
+        '    Option:\n        ' +
+        vote +
+        '\n';
     return content;
 };
 exports.buildVoteContent = buildVoteContent;
-const parseVote = (s) => {
-    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 parseVote = (content) => {
+    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 };
 };
 exports.parseVote = parseVote;
-const buildDisputeAuthenticityContent = ({ hash, confidence, reliabilityPolicy }) => {
-    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" : "") +
-        "";
+const buildDisputeAuthenticityContent = ({ hash, confidence, reliabilityPolicy, }) => {
+    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;
 };
 exports.buildDisputeAuthenticityContent = buildDisputeAuthenticityContent;
-const parseDisputeAuthenticity = (s) => {
-    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);
+const parseDisputeAuthenticity = (content) => {
+    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: m[1],
-        confidence: m[2] ? parseFloat(m[2]) : undefined,
-        reliabilityPolicy: m[3]
+        hash,
+        confidence: confidence ? parseFloat(confidence) : undefined,
+        reliabilityPolicy,
     };
 };
 exports.parseDisputeAuthenticity = parseDisputeAuthenticity;
-const buildDisputeContentContent = ({ hash, confidence, reliabilityPolicy }) => {
-    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" : "") +
-        "";
+const buildDisputeContentContent = ({ hash, confidence, reliabilityPolicy, }) => {
+    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;
 };
 exports.buildDisputeContentContent = buildDisputeContentContent;
-const parseDisputeContent = (s) => {
-    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 m = s.match(disputeRegex);
-    if (!m)
-        throw new Error("Invalid dispute content format: " + s);
+const parseDisputeContent = (content) => {
+    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: m[1],
-        confidence: m[2] ? parseFloat(m[2]) : undefined,
-        reliabilityPolicy: m[3]
+        hash,
+        confidence: confidence ? parseFloat(confidence) : undefined,
+        reliabilityPolicy,
     };
 };
 exports.parseDisputeContent = parseDisputeContent;
 const buildResponseContent = ({ hash, response }) => {
-    const content = "\n" +
-        "\t" + "Type: Response" + "\n" +
-        "\t" + "Hash of referenced statement: " + hash + "\n" +
-        "\t" + "Response: " + response + "\n" +
-        "";
+    const content = '    Type: Response\n' +
+        '    Hash of referenced statement: ' +
+        hash +
+        '\n' +
+        '    Response:\n        ' +
+        response +
+        '\n';
     return content;
 };
 exports.buildResponseContent = buildResponseContent;
-const parseResponseContent = (s) => {
-    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 parseResponseContent = (content) => {
+    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 };
 };
 exports.parseResponseContent = parseResponseContent;
 const buildPDFSigningContent = ({ hash }) => {
-    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" +
-        "";
+    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;
 };
 exports.buildPDFSigningContent = buildPDFSigningContent;
-const parsePDFSigning = (s) => {
-    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]
-    };
+const parsePDFSigning = (content) => {
+    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 };
 };
 exports.parsePDFSigning = parsePDFSigning;
-const buildRating = ({ subjectName, subjectType, subjectReference, documentFileHash, rating, quality, comment }) => {
+const buildRating = ({ subjectName, subjectType, subjectReference, documentFileHash, rating, quality, comment, }) => {
     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" : "") +
-        "";
+        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;
 };
 exports.buildRating = buildRating;
-const parseRating = (s) => {
-    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]);
+const parseRating = (content) => {
+    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: " + 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");
+        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 (!(0, types_1.isRatingValue)(rating)) {
+        throw new Error('Invalid rating after validation: ' + rating);
+    }
     return {
-        subjectType: m[1],
-        subjectName: m[2],
-        subjectReference: m[3],
-        documentFileHash: m[4],
-        quality: m[5],
+        subjectType: subjectType,
+        subjectName,
+        subjectReference,
+        documentFileHash,
+        quality,
         rating,
-        comment: m[7]
+        comment,
     };
 };
 exports.parseRating = parseRating;
-const buildBounty = ({ motivation, bounty, reward, judge, judgePay }) => {
-    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;
-};
-exports.buildBounty = buildBounty;
-const parseBounty = (s) => {
-    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]
-    };
-};
-exports.parseBounty = parseBounty;
-const buildObservation = ({ approach, confidence, reliabilityPolicy, subject, subjectReference, observationReference, property, value }) => {
-    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;
-};
-exports.buildObservation = buildObservation;
-const parseObservation = (s) => {
-    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]
-    };
-};
-exports.parseObservation = parseObservation;
-const buildBoycott = ({ description, subject, subjectReference }) => {
-    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;
-};
-exports.buildBoycott = buildBoycott;
-const parseBoycott = (s) => {
-    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],
-    };
-};
-exports.parseBoycott = parseBoycott;
 //# sourceMappingURL=protocol.js.map