stated-protocol-parser 1.0.0

package/README.md

@@ -0,0 +1,198 @@
+# Stated Protocol Parser
+
+A TypeScript library for parsing and formatting statements in the Stated protocol - a decentralized statement verification system.
+
+## Installation
+
+```bash
+npm install stated-protocol-parser
+```
+
+## Features
+
+- **Statement Parsing & Formatting**: Parse and build statements with domain verification
+- **Multiple Statement Types**: Support for various statement types including:
+  - Basic statements
+  - Quotations
+  - Polls and votes
+  - Organisation and person verifications
+  - Disputes (authenticity and content)
+  - Ratings, bounties, observations, and boycotts
+  - PDF signing
+  - Responses
+- **Type Safety**: Full TypeScript support with comprehensive type definitions
+- **Version Support**: Handles multiple format versions (v3 and v4)
+- **Validation**: Built-in validation for all statement formats
+
+## Usage
+
+### Basic Statement
+
+```typescript
+import { buildStatement, parseStatement } from 'stated-protocol-parser';
+
+// Build a statement
+const statement = buildStatement({
+  domain: 'example.com',
+  author: 'Example Organization',
+  time: new Date(),
+  tags: ['announcement', 'update'],
+  content: 'This is our official statement.',
+});
+
+// Parse a statement
+const parsed = parseStatement({ statement });
+console.log(parsed.domain); // 'example.com'
+console.log(parsed.author); // 'Example Organization'
+```
+
+### Poll
+
+```typescript
+import { buildPollContent, parsePoll } from 'stated-protocol-parser';
+
+const pollContent = buildPollContent({
+  poll: 'Should we implement feature X?',
+  options: ['Yes', 'No', 'Need more information'],
+  deadline: new Date('2024-12-31'),
+  scopeDescription: 'All registered users',
+  country: undefined,
+  city: undefined,
+  legalEntity: undefined,
+  domainScope: undefined,
+});
+
+const parsed = parsePoll(pollContent);
+```
+
+### Organisation Verification
+
+```typescript
+import { buildOrganisationVerificationContent, parseOrganisationVerification } from 'stated-protocol-parser';
+
+const verification = buildOrganisationVerificationContent({
+  name: 'Example Corp',
+  country: 'United States',
+  city: 'New York',
+  legalForm: 'corporation',
+  domain: 'example.com',
+  // ... other fields
+});
+```
+
+### Person Verification
+
+```typescript
+import { buildPersonVerificationContent, parsePersonVerification } from 'stated-protocol-parser';
+
+const verification = buildPersonVerificationContent({
+  name: 'John Doe',
+  dateOfBirth: new Date('1990-01-01'),
+  cityOfBirth: 'New York',
+  countryOfBirth: 'United States',
+  ownDomain: 'johndoe.com',
+  // ... other fields
+});
+```
+
+## API Reference
+
+### Statement Functions
+
+- `buildStatement(params)` - Build a statement string
+- `parseStatement({ statement, allowNoVersion? })` - Parse a statement string
+
+### Content Type Functions
+
+Each content type has corresponding build and parse functions:
+
+- **Quotation**: `buildQuotationContent()`, `parseQuotation()`
+- **Poll**: `buildPollContent()`, `parsePoll()`
+- **Vote**: `buildVoteContent()`, `parseVote()`
+- **Organisation Verification**: `buildOrganisationVerificationContent()`, `parseOrganisationVerification()`
+- **Person Verification**: `buildPersonVerificationContent()`, `parsePersonVerification()`
+- **Dispute Authenticity**: `buildDisputeAuthenticityContent()`, `parseDisputeAuthenticity()`
+- **Dispute Content**: `buildDisputeContentContent()`, `parseDisputeContent()`
+- **Response**: `buildResponseContent()`, `parseResponseContent()`
+- **PDF Signing**: `buildPDFSigningContent()`, `parsePDFSigning()`
+- **Rating**: `buildRating()`, `parseRating()`
+- **Bounty**: `buildBounty()`, `parseBounty()`
+- **Observation**: `buildObservation()`, `parseObservation()`
+- **Boycott**: `buildBoycott()`, `parseBoycott()`
+
+### Constants
+
+```typescript
+import { 
+  statementTypes,
+  legalForms,
+  peopleCountBuckets,
+  UTCFormat 
+} from 'stated-protocol-parser';
+```
+
+### Types
+
+All TypeScript types are exported:
+
+```typescript
+import type {
+  Statement,
+  Quotation,
+  Poll,
+  OrganisationVerification,
+  PersonVerification,
+  Vote,
+  DisputeAuthenticity,
+  DisputeContent,
+  ResponseContent,
+  PDFSigning,
+  Rating,
+  Bounty,
+  Observation,
+  Boycott
+} from 'stated-protocol-parser';
+```
+
+## Format Specifications
+
+### Statement Format
+
+Statements follow a specific format with required fields:
+- Publishing domain
+- Author
+- Time (UTC format)
+- Format version
+- Statement content
+
+Optional fields:
+- Authorized signing representative
+- Tags
+- Superseded statement
+
+### Validation Rules
+
+- Statements must not exceed 3,000 characters
+- Statements cannot contain double line breaks (`\n\n`)
+- Time must be in UTC format
+- Domain, author, and content are required fields
+
+## Version Support
+
+The library supports multiple format versions:
+- **Version 3**: Legacy format with different poll structure
+- **Version 4**: Current format (default)
+
+Use `parsePoll(content, '3')` to parse version 3 polls.
+
+## Error Handling
+
+All parse functions throw descriptive errors when encountering invalid formats:
+
+```typescript
+try {
+  const parsed = parseStatement({ statement: invalidStatement });
+} catch (error) {
+  console.error('Invalid statement format:', error.message);
+}
+```

package/dist/constants.d.ts

@@ -0,0 +1,46 @@
+export declare const legalForms: {
+    local_government: string;
+    state_government: string;
+    foreign_affairs_ministry: string;
+    corporation: string;
+};
+export declare const statementTypes: {
+    statement: string;
+    quotation: string;
+    organisationVerification: string;
+    personVerification: string;
+    poll: string;
+    vote: string;
+    response: string;
+    disputeContent: string;
+    disputeAuthenticity: string;
+    boycott: string;
+    observation: string;
+    rating: string;
+    signPdf: string;
+    bounty: string;
+    unsupported: string;
+};
+export declare const peopleCountBuckets: {
+    "0": string;
+    "10": string;
+    "100": string;
+    "1000": string;
+    "10000": string;
+    "100000": string;
+    "1000000": string;
+    "10000000": string;
+};
+export declare const UTCFormat: RegExp;
+export declare const pollKeys: RegExp;
+export declare const organisationVerificationKeys: RegExp;
+export declare const personVerificationKeys: RegExp;
+export declare const voteKeys: RegExp;
+export declare const disputeAuthenticityKeys: RegExp;
+export declare const disputeContentKeys: RegExp;
+export declare const responseKeys: RegExp;
+export declare const PDFSigningKeys: RegExp;
+export declare const ratingKeys: RegExp;
+export declare const BountyKeys: RegExp;
+export declare const ObservationKeys: RegExp;
+export declare const BoycottKeys: RegExp;

package/dist/constants.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoycottKeys = exports.ObservationKeys = exports.BountyKeys = exports.ratingKeys = exports.PDFSigningKeys = exports.responseKeys = exports.disputeContentKeys = exports.disputeAuthenticityKeys = exports.voteKeys = exports.personVerificationKeys = exports.organisationVerificationKeys = exports.pollKeys = exports.UTCFormat = exports.peopleCountBuckets = exports.statementTypes = exports.legalForms = void 0;
+exports.legalForms = {
+    local_government: 'local government',
+    state_government: 'state government',
+    foreign_affairs_ministry: 'foreign affairs ministry',
+    corporation: 'corporation',
+};
+exports.statementTypes = {
+    statement: 'statement',
+    quotation: 'quotation',
+    organisationVerification: 'organisation_verification',
+    personVerification: 'person_verification',
+    poll: 'poll',
+    vote: 'vote',
+    response: 'response',
+    disputeContent: 'dispute_statement_content',
+    disputeAuthenticity: 'dispute_statement_authenticity',
+    boycott: 'boycott',
+    observation: 'observation',
+    rating: 'rating',
+    signPdf: "sign_pdf",
+    bounty: "bounty",
+    unsupported: "unsupported",
+};
+exports.peopleCountBuckets = {
+    "0": "0-10",
+    "10": "10-100",
+    "100": "100-1000",
+    "1000": "1000-10,000",
+    "10000": "10,000-100,000",
+    "100000": "100,000+",
+    "1000000": "1,000,000+",
+    "10000000": "10,000,000+",
+};
+exports.UTCFormat = /(Mon|Tue|Wed|Thu|Fri|Sat|Sun),\s\d{2}\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s\d{4}\s\d{2}:\d{2}:\d{2}\sGMT/;
+exports.pollKeys = /(Type: |The poll outcome is finalized when the following nodes agree: |Voting deadline: |Poll: |Option 1: |Option 2: |Option 3: |Option 4: |Option 5: |Allow free text votes: |Who can vote: |Description: |Country scope: |City scope: |Legal form scope: |Domain scope: |All entities with the following property: |As observed by: |Link to query defining who can vote: )/g;
+exports.organisationVerificationKeys = /(Type: |Description: |Name: |English name: |Country: |Legal entity: |Legal form: |Department using the domain: |Owner of the domain: |Foreign domain used for publishing statements: |Province or state: |Business register number: |City: |Longitude: |Latitude: |Population: |Logo: |Employee count: |Reliability policy: |Confidence: )/g;
+exports.personVerificationKeys = /(Type: |Description: |Name: |Date of birth: |City of birth: |Country of birth: |Job title: |Employer: |Owner of the domain: |Foreign domain used for publishing statements: |Picture: |Verification method: |Confidence: |Reliability policy: )/g;
+exports.voteKeys = /(Type: |Poll id: |Poll: |Option: )/g;
+exports.disputeAuthenticityKeys = /(Type: |Description: |Hash of referenced statement: |Confidence: |Reliability policy: )/g;
+exports.disputeContentKeys = /(Type: |Description: |Hash of referenced statement: |Confidence: |Reliability policy: )/g;
+exports.responseKeys = /(Type: |Hash of referenced statement: |Response: )/;
+exports.PDFSigningKeys = /(Type: |Description: |PDF file hash: )/;
+exports.ratingKeys = /(Type: |Subject type: |Subject name: |URL that identifies the subject: |Document file hash: |Rated quality: |Our rating: |Comment: )/;
+exports.BountyKeys = /(Type: |In order to: |We will reward any entity that: |The reward is: |In case of dispute, bounty claims are judged by: |The judge will be paid per investigated case with a maxium of: )/;
+exports.ObservationKeys = /(Type: |Approach: |Confidence: |Reliability policy: |Subject: |Subject identity reference: |Observation reference: |Observed property: |Observed value: )/;
+exports.BoycottKeys = /(Type: |Description: |Subject: |Subject identity reference: )/;

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+import type { Statement, Quotation, Poll, OrganisationVerification, PersonVerification, Vote, DisputeAuthenticity, DisputeContent, ResponseContent, PDFSigning, Rating, Bounty, Observation, Boycott } from './types';
+export * from './types';
+export * from './constants';
+export * from './utils';
+export * from './v3';
+export declare const buildStatement: ({ domain, author, time, tags, content, representative, supersededStatement }: Statement) => string;
+export declare const parseStatement: ({ statement: s, allowNoVersion }: {
+    statement: string;
+    allowNoVersion?: boolean;
+}) => Statement & {
+    type?: string;
+    formatVersion: string;
+};
+export declare const buildQuotationContent: ({ originalAuthor, authorVerification, originalTime, source, quotation, paraphrasedStatement, picture, confidence }: Quotation) => string;
+export declare const parseQuotation: (s: string) => Quotation & {
+    type: string | undefined;
+};
+export declare const buildPollContent: ({ country, city, legalEntity, domainScope, judges, deadline, poll, scopeDescription, scopeQueryLink, options, allowArbitraryVote, requiredProperty: propertyScope, requiredPropertyObserver: propertyScopeObserver }: Poll) => string;
+export declare const parsePoll: (s: string, version?: string) => Poll;
+export declare const buildOrganisationVerificationContent: ({ name, englishName, country, city, province, legalForm, department, domain, foreignDomain, serialNumber, confidence, reliabilityPolicy, employeeCount, pictureHash, latitude, longitude, population }: OrganisationVerification) => string;
+export declare const parseOrganisationVerification: (s: string) => OrganisationVerification;
+export declare const buildPersonVerificationContent: ({ name, countryOfBirth, cityOfBirth, ownDomain, foreignDomain, dateOfBirth, jobTitle, employer, verificationMethod, confidence, picture, reliabilityPolicy }: PersonVerification) => string;
+export declare const parsePersonVerification: (s: string) => PersonVerification;
+export declare const buildVoteContent: ({ pollHash, poll, vote }: Vote) => string;
+export declare const parseVote: (s: string) => Vote;
+export declare const buildDisputeAuthenticityContent: ({ hash, confidence, reliabilityPolicy }: DisputeAuthenticity) => string;
+export declare const parseDisputeAuthenticity: (s: string) => DisputeAuthenticity;
+export declare const buildDisputeContentContent: ({ hash, confidence, reliabilityPolicy }: DisputeContent) => string;
+export declare const parseDisputeContent: (s: string) => DisputeContent;
+export declare const buildResponseContent: ({ hash, response }: ResponseContent) => string;
+export declare const parseResponseContent: (s: string) => ResponseContent;
+export declare const buildPDFSigningContent: ({ hash }: PDFSigning) => string;
+export declare const parsePDFSigning: (s: string) => PDFSigning;
+export declare const buildRating: ({ subjectName, subjectType, subjectReference, documentFileHash, rating, quality, comment }: Rating) => string;
+export declare const parseRating: (s: string) => Rating;
+export declare const buildBounty: ({ motivation, bounty, reward, judge, judgePay }: Bounty) => string;
+export declare const parseBounty: (s: string) => Bounty;
+export declare const buildObservation: ({ approach, confidence, reliabilityPolicy, subject, subjectReference, observationReference, property, value }: Observation) => string;
+export declare const parseObservation: (s: string) => Observation;
+export declare const buildBoycott: ({ description, subject, subjectReference }: Boycott) => string;
+export declare const parseBoycott: (s: string) => Boycott;

package/dist/index.js

@@ -0,0 +1,683 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 */
+const constants_1 = require("./constants");
+const v3_1 = require("./v3");
+const utils_1 = require("./utils");
+const fallBackVersion = 3;
+const version = 4;
+__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 }) => {
+    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;
+};
+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
+    };
+    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']);
+    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(' ', '_'),
+    };
+};
+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 }) => {
+    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;
+};
+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;
+    if (deadlineStr && !deadlineStr.match(constants_1.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,
+    };
+};
+exports.parsePoll = parsePoll;
+const buildOrganisationVerificationContent = ({ name, englishName, country, city, province, legalForm, department, domain, foreignDomain, serialNumber, confidence, reliabilityPolicy, employeeCount, pictureHash, latitude, longitude, population }) => {
+    if (!name || !country || !legalForm || (!domain && !foreignDomain))
+        throw new Error("Missing required fields");
+    if (!Object.values(constants_1.legalForms).includes(legalForm))
+        throw new Error("Invalid legal form " + legalForm);
+    if (employeeCount && !Object.values(constants_1.peopleCountBuckets).includes(employeeCount))
+        throw new Error("Invalid employee count " + employeeCount);
+    if (population && !Object.values(constants_1.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" : "") +
+        "";
+};
+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);
+    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,
+    };
+};
+exports.parseOrganisationVerification = parseOrganisationVerification;
+const buildPersonVerificationContent = ({ name, countryOfBirth, cityOfBirth, ownDomain, foreignDomain, dateOfBirth, jobTitle, employer, verificationMethod, confidence, picture, reliabilityPolicy }) => {
+    if (!name || !countryOfBirth || !cityOfBirth || !dateOfBirth || (!ownDomain && !foreignDomain)) {
+        console.log("Missing required fields: ", { name, countryOfBirth, cityOfBirth, dateOfBirth, ownDomain, foreignDomain });
+        return "";
+    }
+    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;
+};
+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 || {};
+    if (!d || !month || !y)
+        throw new Error("Invalid birth date format: " + m[2]);
+    return {
+        name: m[1],
+        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]
+    };
+};
+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" +
+        "";
+    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]
+    };
+};
+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" : "") +
+        "";
+    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);
+    return {
+        hash: m[1],
+        confidence: m[2] ? parseFloat(m[2]) : undefined,
+        reliabilityPolicy: m[3]
+    };
+};
+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" : "") +
+        "";
+    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);
+    return {
+        hash: m[1],
+        confidence: m[2] ? parseFloat(m[2]) : undefined,
+        reliabilityPolicy: m[3]
+    };
+};
+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" +
+        "";
+    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]
+    };
+};
+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" +
+        "";
+    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]
+    };
+};
+exports.parsePDFSigning = parsePDFSigning;
+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" : "") +
+        "";
+    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]);
+    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],
+        subjectName: m[2],
+        subjectReference: m[3],
+        documentFileHash: m[4],
+        quality: m[5],
+        rating,
+        comment: m[7]
+    };
+};
+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;

package/dist/types.d.ts

@@ -0,0 +1,148 @@
+export type StatementTypeValue = 'statement' | 'quotation' | 'organisation_verification' | 'person_verification' | 'poll' | 'vote' | 'response' | 'dispute_statement_content' | 'dispute_statement_authenticity' | 'boycott' | 'observation' | 'rating' | 'sign_pdf' | 'bounty';
+export type Statement = {
+    domain: string;
+    author: string;
+    time: Date;
+    tags?: string[];
+    content: string;
+    representative?: string;
+    supersededStatement?: string;
+    formatVersion?: string;
+};
+export type Quotation = {
+    originalAuthor: string;
+    authorVerification: string;
+    originalTime?: string;
+    source?: string;
+    quotation?: string;
+    paraphrasedStatement?: string;
+    picture?: string;
+    confidence?: string;
+};
+export type Poll = {
+    country: string | undefined;
+    city: string | undefined;
+    legalEntity: string | undefined;
+    domainScope: string[] | undefined;
+    judges?: string;
+    deadline: Date | undefined;
+    poll: string;
+    scopeDescription?: string;
+    scopeQueryLink?: string;
+    options: string[];
+    allowArbitraryVote?: boolean;
+    requiredProperty?: string;
+    requiredPropertyValue?: string;
+    requiredPropertyObserver?: string;
+    requiredMinConfidence?: number;
+};
+export type OrganisationVerification = {
+    name: string;
+    englishName?: string;
+    country: string;
+    city: string;
+    province: string;
+    legalForm: string;
+    department?: string;
+    domain: string;
+    foreignDomain: string;
+    serialNumber: string;
+    confidence?: number;
+    reliabilityPolicy?: string;
+    employeeCount?: string;
+    pictureHash?: string;
+    latitude?: number;
+    longitude?: number;
+    population?: string;
+};
+export type withOwnDomain = {
+    ownDomain: string;
+    foreignDomain?: string;
+};
+export type withForeignDomain = {
+    foreignDomain: string;
+    ownDomain?: string;
+};
+export type PersonVerification = {
+    name: string;
+    countryOfBirth: string;
+    cityOfBirth: string;
+    dateOfBirth: Date;
+    jobTitle?: string;
+    employer?: string;
+    verificationMethod?: string;
+    confidence?: number;
+    picture?: string;
+    reliabilityPolicy?: string;
+} & (withOwnDomain | withForeignDomain);
+export type Vote = {
+    pollHash: string;
+    poll: string;
+    vote: string;
+};
+export type DisputeAuthenticity = {
+    hash: string;
+    confidence?: number;
+    reliabilityPolicy?: string;
+};
+export type DisputeContent = {
+    hash: string;
+    confidence?: number;
+    reliabilityPolicy?: string;
+};
+export type ResponseContent = {
+    hash: string;
+    response: string;
+};
+export type PDFSigning = {
+    hash: string;
+};
+export type RatingSubjectTypeValue = 'Organisation' | 'Policy proposal' | 'Treaty draft' | 'Research publication' | 'Regulation' | 'Product';
+export type Rating = {
+    subjectType?: RatingSubjectTypeValue;
+    subjectName: string;
+    subjectReference?: string;
+    documentFileHash?: string;
+    rating: number;
+    quality?: string;
+    comment?: string;
+};
+export type Bounty = {
+    motivation?: string;
+    bounty: string;
+    reward: string;
+    judge: string;
+    judgePay?: string;
+};
+export type Observation = {
+    description?: string;
+    approach?: string;
+    confidence?: number;
+    reliabilityPolicy?: string;
+    subject: string;
+    subjectReference?: string;
+    observationReference?: string;
+    property: string;
+    value?: string;
+};
+export type PollV3 = {
+    country: string | undefined;
+    city: string | undefined;
+    legalEntity: string | undefined;
+    domainScope: string[] | undefined;
+    judges?: string;
+    deadline: Date;
+    poll: string;
+    scopeDescription?: string;
+    scopeQueryLink?: string;
+    scopeProperty?: string;
+    propertyScopeObserver?: string;
+    pollType?: string;
+    options: string[];
+};
+export type Boycott = {
+    description?: string;
+    reliabilityPolicy?: string;
+    subject: string;
+    subjectReference?: string;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const minPeopleCountToRange: (n: number) => string | undefined;
+export declare const monthIndex: (month: string) => number;
+export declare const birthDateFormat: RegExp;

package/dist/utils.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.birthDateFormat = exports.monthIndex = exports.minPeopleCountToRange = void 0;
+const constants_1 = require("./constants");
+const minPeopleCountToRange = (n) => {
+    if (n >= 10000000)
+        return constants_1.peopleCountBuckets["10000000"];
+    if (n >= 1000000)
+        return constants_1.peopleCountBuckets["1000000"];
+    if (n >= 100000)
+        return constants_1.peopleCountBuckets["100000"];
+    if (n >= 10000)
+        return constants_1.peopleCountBuckets["10000"];
+    if (n >= 1000)
+        return constants_1.peopleCountBuckets["1000"];
+    if (n >= 100)
+        return constants_1.peopleCountBuckets["100"];
+    if (n >= 10)
+        return constants_1.peopleCountBuckets["10"];
+    if (n >= 0)
+        return constants_1.peopleCountBuckets["0"];
+};
+exports.minPeopleCountToRange = minPeopleCountToRange;
+const monthIndex = (month) => ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"]
+    .indexOf(month.toLowerCase().substr(0, 3));
+exports.monthIndex = monthIndex;
+exports.birthDateFormat = /(?<d>\d{1,2})\s(?<month>Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(?<y>\d{4})/;

package/dist/v3.d.ts

@@ -0,0 +1,4 @@
+import { Poll } from './types';
+export declare const parsePollV3: (s: string, version?: string) => Poll & {
+    pollType: string;
+};

package/dist/v3.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePollV3 = void 0;
+const constants_1 = require("./constants");
+const parsePollV3 = (s, version) => {
+    const pollRegex = new RegExp(''
+        + /^\n\tType: Poll\n/.source
+        + /(?:\tPoll type: (?<pollType>[^\n]+?)\n)?/.source
+        + /(?:\tWho can vote: (?<scopeDescription>[^\n]+?)\n)?/.source
+        + /(?:\tLink to query defining who can vote: (?<scopeQueryLink>[^\n]+?)\n)?/.source
+        + /(?:\tCountry scope: (?<country>[^\n]+?)\n)?/.source
+        + /(?:\tCity scope: (?<city>[^\n]+?)\n)?/.source
+        + /(?:\tLegal form scope: (?<legalEntity>[^\n]+?)\n)?/.source
+        + /(?:\tDomain scope: (?<domainScope>[^\n]+?)\n)?/.source
+        + /(?:\tThe decision 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
+        + /$/.source);
+    const match = s.match(pollRegex);
+    if (!match)
+        throw new Error("Invalid poll format: " + s);
+    const m = {
+        pollType: match[1],
+        scopeDescription: match[2],
+        scopeQueryLink: match[3],
+        country: match[4],
+        city: match[5],
+        legalEntity: match[6],
+        domainScope: match[7],
+        judges: match[8],
+        deadline: match[9],
+        poll: match[10],
+        option1: match[11],
+        option2: match[12],
+        option3: match[13],
+        option4: match[14],
+        option5: match[15]
+    };
+    const options = [m.option1, m.option2, m.option3, m.option4, m.option5].filter(o => o);
+    const domainScope = m.domainScope?.split(', ');
+    const deadlineStr = m.deadline;
+    if (!deadlineStr.match(constants_1.UTCFormat))
+        throw new Error("Invalid poll, deadline must be in UTC: " + deadlineStr);
+    return {
+        pollType: m['pollType'],
+        country: m['country'],
+        scopeDescription: m['scopeDescription'],
+        scopeQueryLink: m['scopeQueryLink'],
+        city: m['city'],
+        legalEntity: m['legalEntity'],
+        domainScope: (domainScope && domainScope.length > 0) ? domainScope : undefined,
+        judges: m['judges'],
+        deadline: new Date(deadlineStr),
+        poll: m['poll'],
+        options
+    };
+};
+exports.parsePollV3 = parsePollV3;

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "stated-protocol-parser",
+  "version": "1.0.0",
+  "description": "Parser and formatter for the Stated protocol - a decentralized statement verification system",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "stated",
+    "protocol",
+    "parser",
+    "formatter",
+    "verification",
+    "decentralized",
+    "statements"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/c-riq/stated"
+  }
+}