+ }
+
+ /**
+ * @dev Returns the number of decimals used to get its user representation.
+ * For example, if `decimals` equals `2`, a balance of `505` tokens should
+ * be displayed to a user as `5.05` (`505 / 10 ** 2`).
+ *
+ * Tokens usually opt for a value of 18, imitating the relationship between
+ * Ether and Wei. This is the default value returned by this function, unless
+ * it's overridden.
+ *
+ * NOTE: This information is only used for _display_ purposes: it in
+ * no way affects any of the arithmetic of the contract, including
+ * {IERC20-balanceOf} and {IERC20-transfer}.
+ */
+ static decimals() {
+ return 18;
+ }
+
+ /**
+ * @dev See {IERC20-balanceOf}.
+ */
+ balanceOf(account) {
+ return this.balances.get(account);
+ }
+
+ /**
+ * @dev See {IERC20-transfer}.
+ *
+ * Emits an {Approval} event indicating the updated allowance. This is not
+ * required by the EIP. See the note at the beginning of {ERC20}.
+ *
+ * NOTE: Does not update the allowance if the current allowance
+ * is the maximum `uint256`.
+ *
+ * Requirements:
+ *
+ * - `from` and `to` cannot be the zero address.
+ * - `from` must have a balance of at least `amount`.
+ * - the caller must have allowance for ``from``'s tokens of at least
+ * `amount`.
+ */
+ transfer(from, to, amount) {
+ if (!from) throw new Error('ERC20: transfer from the zero address');
+ if (!to) throw new Error('ERC20: transfer to the zero address');
+
+ // _beforeTokenTransfer(from, to, amount);
+
+ const fromBalance = this.balances.get(from);
+ if (fromBalance < amount) throw new Error('ERC20: transfer amount exceeds balance');
+ this.balances.set(from, fromBalance - amount);
+ // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
+ // decrementing then incrementing.
+ this.balances.set(to, this.balances.get(to) + amount);
+
+ // emit Transfer(from, to, amount);
+
+ // _afterTokenTransfer(from, to, amount);
+ }
+
+ /** @dev Creates `amount` tokens and assigns them to `account`, increasing
+ * the total supply.
+ *
+ * Emits a {Transfer} event with `from` set to the zero address.
+ *
+ * Requirements:
+ *
+ * - `account` cannot be the zero address.
+ */
+ mint(account, amount) {
+ if (!account) throw new Error('ERC20: mint to the zero address');
+
+ // _beforeTokenTransfer(address(0), account, amount);
+
+ this.totalSupply += amount;
+ // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
+ this.balances.set(account, this.balances.get(account) + amount);
+ // emit Transfer(address(0), account, amount);
+
+ // _afterTokenTransfer(address(0), account, amount);
+ }
+
+ /**
+ * @dev Destroys `amount` tokens from `account`, reducing the
+ * total supply.
+ *
+ * Emits a {Transfer} event with `to` set to the zero address.
+ *
+ * Requirements:
+ *
+ * - `account` cannot be the zero address.
+ * - `account` must have at least `amount` tokens.
+ */
+ burn(account, amount) {
+ if (!account) throw new Error('ERC20: burn from the zero address');
+
+ // _beforeTokenTransfer(account, address(0), amount);
+
+ const accountBalance = this.balances.get(account);
+ if (accountBalance < amount) throw new Error('ERC20: burn amount exceeds balance');
+ this.balances.set(account, accountBalance - amount);
+ // Overflow not possible: amount <= accountBalance <= totalSupply.
+ this.totalSupply -= amount;
+ // emit Transfer(address(0), account, amount);
+
+ // _afterTokenTransfer(address(0), account, amount);
+ }
+}
diff --git a/src/classes/supporting/erc721.js b/src/classes/supporting/erc721.js
new file mode 100644
index 0000000..9a68166
--- /dev/null
+++ b/src/classes/supporting/erc721.js
@@ -0,0 +1,93 @@
+/**
+ * ERC-721 Non-Fungible Token Standard
+ * See https://eips.ethereum.org/EIPS/eip-721
+ * and https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/ERC721.sol
+ *
+ * This implementation is currently incomplete. It lacks the following:
+ * - Token approvals
+ * - Operator approvals
+ * - Emitting events
+ */
+
+export class ERC721 {
+ constructor(name, symbol) {
+ this.name = name;
+ this.symbol = symbol;
+ this.balances = new Map(); // owner address --> token count
+ this.owners = new Map(); // token id --> owner address
+ // this.tokenApprovals = new Map(); // token id --> approved addresses
+ // this.operatorApprovals = new Map(); // owner --> operator approvals
+
+ this.events = {
+ // Transfer: (_from, _to, _tokenId) => {},
+ // Approval: (_owner, _approved, _tokenId) => {},
+ // ApprovalForAll: (_owner, _operator, _approved) => {},
+ };
+ }
+
+ incrementBalance(owner, increment) {
+ const balance = this.balances.get(owner) ?? 0;
+ this.balances.set(owner, balance + increment);
+ }
+
+ mint(to, tokenId) {
+ console.log('ERC721.mint', { to, tokenId });
+ if (this.owners.get(tokenId)) {
+ throw new Error('ERC721: token already minted');
+ }
+ this.incrementBalance(to, 1);
+ this.owners.set(tokenId, to);
+ }
+
+ burn(tokenId) {
+ const owner = this.owners.get(tokenId);
+ this.incrementBalance(owner, -1);
+ this.owners.delete(tokenId);
+ }
+
+ balanceOf(owner) {
+ if (!owner) {
+ throw new Error('ERC721: address zero is not a valid owner');
+ }
+ return this.balances.get(owner) ?? 0;
+ }
+
+ ownerOf(tokenId) {
+ const owner = this.owners.get(tokenId);
+ if (!owner) {
+ throw new Error(`ERC721: invalid token ID: ${tokenId}`);
+ }
+ return owner;
+ }
+
+ transfer(from, to, tokenId) {
+ console.log('ERC721.transfer', { from, to, tokenId });
+ const owner = this.owners.get(tokenId);
+ if (owner !== from) {
+ throw new Error(`ERC721: transfer from incorrect owner ${from}; should be ${owner}`);
+ }
+ this.incrementBalance(from, -1);
+ this.incrementBalance(to, 1);
+ this.owners.set(tokenId, to);
+ }
+
+ /// @notice Enable or disable approval for a third party ("operator") to manage
+ /// all of `msg.sender`'s assets
+ /// @dev Emits the ApprovalForAll event. The contract MUST allow
+ /// multiple operators per owner.
+ /// @param _operator Address to add to the set of authorized operators
+ /// @param _approved True if the operator is approved, false to revoke approval
+ // setApprovalForAll(_operator, _approved) {}
+
+ /// @notice Get the approved address for a single NFT
+ /// @dev Throws if `_tokenId` is not a valid NFT.
+ /// @param _tokenId The NFT to find the approved address for
+ /// @return The approved address for this NFT, or the zero address if there is none
+ // getApproved(_tokenId) {}
+
+ /// @notice Query if an address is an authorized operator for another address
+ /// @param _owner The address that owns the NFTs
+ /// @param _operator The address that acts on behalf of the owner
+ /// @return True if `_operator` is an approved operator for `_owner`, false otherwise
+ // isApprovedForAll(_owner, _operator) {}
+}
diff --git a/src/classes/supporting/post-content.js b/src/classes/supporting/post-content.js
new file mode 100644
index 0000000..5308d36
--- /dev/null
+++ b/src/classes/supporting/post-content.js
@@ -0,0 +1,81 @@
+class Author {
+ constructor(publicKey, weight) {
+ this.publicKey = publicKey;
+ this.weight = weight;
+ }
+
+ toJSON() {
+ return {
+ publicKey: this.publicKey,
+ weight: this.weight,
+ };
+ }
+
+ static fromJSON({ publicKey, weight }) {
+ return new Author(publicKey, weight);
+ }
+}
+
+class Citation {
+ constructor(postId, weight) {
+ this.postId = postId;
+ this.weight = weight;
+ }
+
+ toJSON() {
+ return {
+ postId: this.postId,
+ weight: this.weight,
+ };
+ }
+
+ static fromJSON({ postId, weight }) {
+ return new Citation(postId, weight);
+ }
+}
+
+export class PostContent {
+ constructor(content = {}) {
+ this.content = content;
+ this.authors = [];
+ this.citations = [];
+ }
+
+ addAuthor(authorPublicKey, weight) {
+ const author = new Author(authorPublicKey, weight);
+ this.authors.push(author);
+ return this;
+ }
+
+ addCitation(postId, weight) {
+ const citation = new Citation(postId, weight);
+ this.citations.push(citation);
+ return this;
+ }
+
+ setTitle(title) {
+ this.title = title;
+ return this;
+ }
+
+ toJSON() {
+ return {
+ content: this.content,
+ authors: this.authors.map((author) => author.toJSON()),
+ citations: this.citations.map((citation) => citation.toJSON()),
+ ...(this.id ? { id: this.id } : {}),
+ title: this.title,
+ };
+ }
+
+ static fromJSON({
+ id, content, authors, citations, title,
+ }) {
+ const post = new PostContent(content);
+ post.authors = authors.map((author) => Author.fromJSON(author));
+ post.citations = citations.map((citation) => Citation.fromJSON(citation));
+ post.id = id;
+ post.title = title;
+ return post;
+ }
+}
diff --git a/src/classes/supporting/stake.js b/src/classes/supporting/stake.js
new file mode 100644
index 0000000..8b6ac7e
--- /dev/null
+++ b/src/classes/supporting/stake.js
@@ -0,0 +1,14 @@
+export class Stake {
+ constructor({
+ tokenId, position, amount, lockingTime,
+ }) {
+ this.tokenId = tokenId;
+ this.position = position;
+ this.amount = amount;
+ this.lockingTime = lockingTime;
+ }
+
+ getStakeValue({ lockingTimeExponent } = {}) {
+ return this.amount * this.lockingTime ** lockingTimeExponent;
+ }
+}
diff --git a/src/classes/supporting/vertex.js b/src/classes/supporting/vertex.js
new file mode 100644
index 0000000..fb27be6
--- /dev/null
+++ b/src/classes/supporting/vertex.js
@@ -0,0 +1,159 @@
+import { displayNumber } from '../../util/helpers.js';
+
+import { Edge } from './edge.js';
+
+export class Vertex {
+ constructor(graph, type, id, data, options = {}) {
+ this.graph = graph;
+ this.type = type;
+ this.id = id;
+ this.data = data;
+ this.label = options.label ?? this.id;
+ this.options = options;
+ this.edges = {
+ from: [],
+ to: [],
+ };
+ this.installedClickCallback = false;
+ this.properties = new Map();
+ }
+
+ reset() {
+ this.installedClickCallback = false;
+ }
+
+ getEdges(type, away) {
+ return this.edges[away ? 'from' : 'to'].filter(
+ (edge) => edge.type === type,
+ );
+ }
+
+ setProperty(key, value) {
+ this.properties.set(key, value);
+ return this;
+ }
+
+ displayVertex() {
+ if (this.options.hide) {
+ return;
+ }
+
+ let html = '';
+ html += `${this.label}`;
+ html += '';
+ for (const [key, value] of this.properties.entries()) {
+ const displayValue = typeof value === 'number' ? displayNumber(value) : value;
+ html += `| ${key} | ${displayValue} |
`;
+ }
+ html += '
';
+ if (this.id !== this.label) {
+ html += `${this.id}
`;
+ }
+ html = html.replaceAll(/\n\s*/g, '');
+ this.graph.flowchart?.log(`${this.id}["${html}"]`);
+
+ if (this.graph.editable && !this.installedClickCallback) {
+ this.graph.flowchart?.log(`click ${this.id} WDGHandler${this.graph.index} "Edit Vertex ${this.id}"`);
+ this.installedClickCallback = true;
+ }
+ }
+
+ static prepareEditorDocument(graph, doc, vertexId) {
+ doc.clear();
+ const vertex = vertexId ? graph.getVertex(vertexId) : undefined;
+ const form = doc.form().lastElement;
+ doc.remark(`${vertex ? 'Edit' : 'Add'} Vertex
`, { parentEl: form.el });
+ form
+ .textField({
+ id: 'id', name: 'id', defaultValue: vertex?.id,
+ })
+ .textField({ id: 'type', name: 'type', defaultValue: vertex?.type })
+ .textField({ id: 'label', name: 'label', defaultValue: vertex?.label });
+
+ doc.remark('Properties
', { parentEl: form.el });
+ const subFormArray = form.subFormArray({ id: 'properties', name: 'properties' }).lastItem;
+ const addPropertyForm = (key, value) => {
+ const { subForm } = form.subForm({ name: 'subform', subFormArray }).lastItem;
+ subForm.textField({ id: 'key', name: 'key', defaultValue: key })
+ .textField({ id: 'value', name: 'value', defaultValue: value })
+ .button({
+ id: 'remove',
+ name: 'Remove Property',
+ cb: () => subFormArray.remove(subForm),
+ });
+ doc.remark('
', { parentEl: subForm.el });
+ };
+
+ if (vertex) {
+ for (const [key, value] of vertex.properties.entries()) {
+ addPropertyForm(key, value);
+ }
+ }
+
+ form.button({
+ id: 'add',
+ name: 'Add Property',
+ cb: () => addPropertyForm('', ''),
+ });
+
+ form.button({
+ id: 'save',
+ name: 'Save',
+ type: 'submit',
+ cb: ({ form: { value: formValue } }) => {
+ let fullRedraw = false;
+ if (vertex && formValue.id !== vertex.id) {
+ fullRedraw = true;
+ }
+ // TODO: preserve data types of properties
+ formValue.properties = new Map(formValue.properties.map(({ key, value }) => [key, value]));
+ if (vertex) {
+ Object.assign(vertex, formValue);
+ vertex.displayVertex();
+ } else {
+ const newVertex = graph.addVertex(formValue.type, formValue.id, null, formValue.label);
+ Object.assign(newVertex, formValue);
+ doc.clear();
+ Vertex.prepareEditorDocument(graph, doc, newVertex.id);
+ }
+ if (fullRedraw) {
+ graph.redraw();
+ }
+ },
+ });
+
+ if (vertex) {
+ form.button({
+ id: 'delete',
+ name: 'Delete Vertex',
+ cb: () => {
+ graph.deleteVertex(vertex.id);
+ graph.redraw();
+ graph.resetEditorDocument();
+ },
+ });
+
+ doc.remark('New Edge
', { parentEl: form.el });
+ const { subForm } = form.subForm({ name: 'newEdge' }).lastItem;
+ subForm.textField({ name: 'to' });
+ subForm.textField({ name: 'type' });
+ subForm.textField({ name: 'weight' });
+ subForm.button({
+ name: 'Save',
+ cb: ({ form: { value: { to, type, weight } } }) => {
+ graph.addEdge(type, vertex, to, weight, null);
+ doc.clear();
+ Edge.prepareEditorDocument(graph, doc, vertex.id, to);
+ },
+ });
+ }
+
+ form.button({
+ id: 'cancel',
+ name: 'Cancel',
+ cb: () => graph.resetEditorDocument(),
+ });
+
+ return doc;
+ }
+}
diff --git a/src/classes/supporting/vm.js b/src/classes/supporting/vm.js
new file mode 100644
index 0000000..03e5dbf
--- /dev/null
+++ b/src/classes/supporting/vm.js
@@ -0,0 +1,69 @@
+import { Action } from '../display/action.js';
+
+class ContractRecord {
+ constructor(id, instance) {
+ this.id = id;
+ this.instance = instance;
+ }
+}
+
+export class VMHandle {
+ constructor(vm, sender) {
+ this.vm = vm;
+ this.sender = sender;
+ this.actions = {
+ call: new Action('call', vm.scene),
+ return: new Action('return', vm.scene),
+ };
+ }
+
+ /**
+ * @param {string} id Contract ID
+ * @param {string} method
+ */
+ async callContract(id, method, ...args) {
+ const instance = this.vm.getContractInstance(id);
+ const fn = instance[method];
+ if (!fn) throw new Error(`Contract ${id} method ${method} not found!`);
+ await this.actions.call.log(this.sender, instance, method);
+ const result = await fn.call(instance, this.sender, ...args);
+ await this.actions.return.log(instance, this.sender, undefined, undefined, '-->>');
+ return result;
+ }
+}
+
+export class VM {
+ constructor(scene) {
+ this.scene = scene;
+ this.contracts = new Map();
+ }
+
+ /**
+ * @param {string} id
+ * @param {class} ContractClass
+ * @param {any[]} ...args Passed to contractClass constructor after `vm`
+ */
+ addContract(id, ContractClass, ...args) {
+ const instance = new ContractClass(this, ...args);
+ const contract = new ContractRecord(id, instance);
+ this.contracts.set(id, contract);
+ }
+
+ getHandle(sender) {
+ return new VMHandle(this, sender);
+ }
+
+ /**
+ * @param {string} id
+ */
+ getContract(id) {
+ return this.contracts.get(id);
+ }
+
+ /**
+ * @param {string} id
+ */
+ getContractInstance(id) {
+ return this.getContract(id)?.instance;
+ }
+}
diff --git a/src/classes/supporting/voter.js b/src/classes/supporting/voter.js
new file mode 100644
index 0000000..ea5fed8
--- /dev/null
+++ b/src/classes/supporting/voter.js
@@ -0,0 +1,14 @@
+export class Voter {
+ constructor(reputationPublicKey) {
+ this.reputationPublicKey = reputationPublicKey;
+ this.voteHistory = [];
+ this.dateLastVote = null;
+ }
+
+ addVoteRecord(stake) {
+ this.voteHistory.push(stake);
+ if (!this.dateLastVote || stake.dateStart > this.dateLastVote) {
+ this.dateLastVote = stake.dateStart;
+ }
+ }
+}
diff --git a/src/classes/supporting/wdg.js b/src/classes/supporting/wdg.js
new file mode 100644
index 0000000..ab083e7
--- /dev/null
+++ b/src/classes/supporting/wdg.js
@@ -0,0 +1,231 @@
+import { Vertex } from './vertex.js';
+import { Edge } from './edge.js';
+import { Document } from '../display/document.js';
+
+const allGraphs = [];
+
+const makeWDGHandler = (graphIndex) => (vertexId) => {
+ const graph = allGraphs[graphIndex];
+ // We want a document for editing this node, which may be a vertex or an edge
+ const { editorDoc } = graph;
+ editorDoc.clear();
+ if (vertexId.startsWith('edge:')) {
+ const [, from, to] = vertexId.split(':');
+ Edge.prepareEditorDocument(graph, editorDoc, from, to);
+ } else {
+ Vertex.prepareEditorDocument(graph, editorDoc, vertexId);
+ }
+};
+
+export class WeightedDirectedGraph {
+ constructor(scene, options = {}) {
+ this.scene = scene;
+ this.vertices = new Map();
+ this.edgeTypes = new Map();
+ this.nextVertexId = 0;
+ this.flowchart = scene?.flowchart;
+ this.editable = options.editable;
+
+ // Mermaid supports a click callback, but we can't customize arguments; we just get the vertex ID.
+ // In order to provide the appropriate graph context for each callback, we create a separate callback
+ // function for each graph.
+ this.index = allGraphs.length;
+ allGraphs.push(this);
+ window[`WDGHandler${this.index}`] = makeWDGHandler(this.index);
+
+ // TODO: Populate history
+ this.history = {};
+ }
+
+ getHistory() {
+ // record operations that modify the graph
+ return this.history;
+ }
+
+ toJSON() {
+ return {
+ vertices: Array.from(this.vertices.values()),
+ edgeTypes: Array.from(this.edgeTypes.keys()),
+ edges: Array.from(this.edgeTypes.values()).flatMap((edges) => Array.from(edges.values())),
+ history: this.getHistory(),
+ };
+ }
+
+ redraw() {
+ // Call .reset() on all vertices and edges
+ for (const vertex of this.vertices.values()) {
+ vertex.reset();
+ }
+ for (const edges of this.edgeTypes.values()) {
+ for (const edge of edges.values()) {
+ edge.reset();
+ }
+ }
+
+ // Clear the target div
+ this.flowchart?.reset();
+ this.flowchart?.init();
+
+ // Draw all vertices and edges
+ for (const vertex of this.vertices.values()) {
+ vertex.displayVertex();
+ }
+ // Let's flatmap and dedupe by [from, to] since each edge
+ // renders all comorphic edges as well.
+ const edgesFrom = new Map(); // edgeMap[from][to] = edge
+ for (const edges of this.edgeTypes.values()) {
+ for (const edge of edges.values()) {
+ const edgesTo = edgesFrom.get(edge.from) || new Map();
+ edgesTo.set(edge.to, edge);
+ edgesFrom.set(edge.from, edgesTo);
+ }
+ }
+
+ for (const edgesTo of edgesFrom.values()) {
+ for (const edge of edgesTo.values()) {
+ edge.displayEdge();
+ }
+ }
+
+ // Ensure rerender
+ this.flowchart?.render();
+ }
+
+ withFlowchart() {
+ this.scene?.withSectionFlowchart();
+ this.flowchart = this.scene?.lastFlowchart;
+ if (this.editable) {
+ this.editorDoc = new Document('WDGControls', this.flowchart.box.el);
+ this.resetEditorDocument();
+ }
+ this.errorDoc = new Document('WDGErrors', this.flowchart.box.el);
+ return this;
+ }
+
+ resetEditorDocument() {
+ this.editorDoc.clear();
+ Vertex.prepareEditorDocument(this, this.editorDoc);
+ }
+
+ addVertex(type, id, data, label, options) {
+ // Supports simple case of auto-incremented numeric ids
+ if (typeof id === 'object') {
+ data = id;
+ id = this.nextVertexId++;
+ }
+ id = (typeof id === 'number') ? id.toString(10) : id;
+ if (this.vertices.has(id)) {
+ throw new Error(`Vertex already exists with id: ${id}`);
+ }
+ const vertex = new Vertex(this, type, id, data, { ...options, label });
+ this.vertices.set(id, vertex);
+ vertex.displayVertex();
+ return vertex;
+ }
+
+ getVertex(id) {
+ id = (typeof id === 'number') ? id.toString(10) : id;
+ return this.vertices.get(id);
+ }
+
+ getVertexData(id) {
+ return this.getVertex(id)?.data;
+ }
+
+ getVerticesData() {
+ return Array.from(this.vertices.values()).map(({ data }) => data);
+ }
+
+ getEdge(type, from, to) {
+ from = from instanceof Vertex ? from : this.getVertex(from);
+ to = to instanceof Vertex ? to : this.getVertex(to);
+ if (!from || !to) {
+ return undefined;
+ }
+ const edges = this.edgeTypes.get(type);
+ const edgeKey = Edge.getKey({ from, to, type });
+ return edges?.get(edgeKey);
+ }
+
+ getEdgeWeight(type, from, to) {
+ return this.getEdge(type, from, to)?.weight;
+ }
+
+ setEdgeWeight(type, from, to, weight, data, options) {
+ from = from instanceof Vertex ? from : this.getVertex(from);
+ to = to instanceof Vertex ? to : this.getVertex(to);
+ const edge = new Edge(this, type, from, to, weight, data, options);
+ let edges = this.edgeTypes.get(type);
+ if (!edges) {
+ edges = new Map();
+ this.edgeTypes.set(type, edges);
+ }
+ const edgeKey = Edge.getKey(edge);
+ edges.set(edgeKey, edge);
+ edge.displayEdgeNode();
+ return edge;
+ }
+
+ addEdge(type, from, to, weight, data, options) {
+ from = from instanceof Vertex ? from : this.getVertex(from);
+ to = to instanceof Vertex ? to : this.getVertex(to);
+ const existingEdges = this.getEdges(type, from, to);
+ if (this.getEdge(type, from, to)) {
+ throw new Error(`Edge ${type} from ${from.id} to ${to.id} already exists`);
+ }
+ const edge = this.setEdgeWeight(type, from, to, weight, data, options);
+ from.edges.from.push(edge);
+ to.edges.to.push(edge);
+ if (existingEdges.length) {
+ edge.displayEdgeNode();
+ } else {
+ edge.displayEdge();
+ }
+ return edge;
+ }
+
+ getEdges(type, from, to) {
+ from = from instanceof Vertex ? from : this.getVertex(from);
+ to = to instanceof Vertex ? to : this.getVertex(to);
+ const edgeTypes = type ? [type] : Array.from(this.edgeTypes.keys());
+ return edgeTypes.flatMap((edgeType) => {
+ const edges = this.edgeTypes.get(edgeType);
+ return Array.from(edges?.values() || []).filter((edge) => {
+ const matchFrom = from === null || from === undefined || from === edge.from;
+ const matchTo = to === null || to === undefined || to === edge.to;
+ return matchFrom && matchTo;
+ });
+ });
+ }
+
+ countVertices(type) {
+ if (!type) {
+ return this.vertices.size;
+ }
+ return Array.from(this.vertices.values()).filter((vertex) => vertex.type === type).length;
+ }
+
+ deleteEdge(type, from, to) {
+ from = from instanceof Vertex ? from : this.getVertex(from);
+ to = to instanceof Vertex ? to : this.getVertex(to);
+ const edges = this.edgeTypes.get(type);
+ const edgeKey = Edge.getKey({ type, from, to });
+ if (!edges) return;
+ const edge = edges.get(edgeKey);
+ if (!edge) return;
+ to.edges.from.forEach((x, i) => (x === edge) && to.edges.from.splice(i, 1));
+ from.edges.to.forEach((x, i) => (x === edge) && from.edges.to.splice(i, 1));
+ edges.delete(edgeKey);
+ if (edges.size === 0) {
+ this.edgeTypes.delete(type);
+ }
+ }
+
+ deleteVertex(id) {
+ const vertex = this.getVertex(id);
+ for (const { type, from, to } of [...vertex.edges.to, ...vertex.edges.from]) {
+ this.deleteEdge(type, from, to);
+ }
+ this.vertices.delete(id);
+ }
+}
diff --git a/src/favicon.ico b/src/favicon.ico
new file mode 100644
index 0000000..28aeaa7
Binary files /dev/null and b/src/favicon.ico differ
diff --git a/src/index.css b/src/index.css
new file mode 100644
index 0000000..a42bab2
--- /dev/null
+++ b/src/index.css
@@ -0,0 +1,94 @@
+body {
+ background-color: #09343f;
+ color: #b6b6b6;
+ font-family: monospace;
+ font-size: 12pt;
+ margin: 1em;
+}
+a {
+ color: #c6f4ff;
+}
+a:visited {
+ color: #85b7c3;
+}
+.box {
+ width: fit-content;
+}
+.box .name {
+ width: 15em;
+ font-weight: bold;
+ text-align: right;
+ margin-right: 6pt;
+}
+.box .value {
+ width: fit-content;
+}
+.flex {
+ display: flex;
+}
+.monospace {
+ font-family: monospace;
+}
+.dim {
+ opacity: 0.25;
+}
+.padded {
+ padding: 20px;
+}
+.top-rail {
+ position: sticky;
+ top: 0;
+ left: 0;
+ width: 100%;
+ height: 0;
+}
+.scene-controls {
+ position: relative;
+ left: 150px;
+}
+svg {
+ width: 800px;
+}
+th {
+ text-align: left;
+ padding: 10px;
+}
+td {
+ background-color: #0c2025;
+}
+.edge > rect {
+ fill: #216262 !important;
+}
+button {
+ margin: 5px;
+ margin-top: 1em;
+ background-color: #c6f4ff;
+ border-color: #b6b6b6;
+ border-radius: 5px;
+}
+button:disabled {
+ background-color: #2a535e;
+ color: #919191;
+}
+label > input {
+ margin-left: 1em;
+}
+label {
+ font-family: monospace;
+ font-weight: bold;
+ font-size: smaller;
+ color: #999999;
+}
+label > div {
+ display: inline-block;
+ min-width: 50px;
+}
+table {
+ width: 100%;
+}
+form {
+ min-width: 20em;
+}
+span.small {
+ font-size: smaller;
+}
\ No newline at end of file
diff --git a/src/index.html b/src/index.html
new file mode 100644
index 0000000..8b95bbf
--- /dev/null
+++ b/src/index.html
@@ -0,0 +1,68 @@
+
+
+
+ DGF Tests
+
+
+
+
+ Decentralized Governance Framework
+
+ We are building a system to enable experts to collaborate and self-govern in accordance with their values.
+
+
+ For more information please see the DGF
+ Wiki.
+
+ Javascript Prototype: Example Scenarios
+
+ Below are example scenarios with various assertions covering features of our reputation system.
+
+
+ The code for this site is available in GitLab.
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/all.test.html b/src/tests/all.test.html
new file mode 100644
index 0000000..b28655c
--- /dev/null
+++ b/src/tests/all.test.html
@@ -0,0 +1,47 @@
+
+
+
+ All Tests
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/availability.test.html b/src/tests/availability.test.html
new file mode 100644
index 0000000..3efa0df
--- /dev/null
+++ b/src/tests/availability.test.html
@@ -0,0 +1,31 @@
+
+
+
+ Availability test
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/basic.test.html b/src/tests/basic.test.html
new file mode 100644
index 0000000..a103f5e
--- /dev/null
+++ b/src/tests/basic.test.html
@@ -0,0 +1,13 @@
+
+
+
+ Forum Network
+
+
+
+
+
+
+
+
diff --git a/src/tests/basic2.test.html b/src/tests/basic2.test.html
new file mode 100644
index 0000000..9b98448
--- /dev/null
+++ b/src/tests/basic2.test.html
@@ -0,0 +1,13 @@
+
+
+
+ Forum Network
+
+
+
+
+
+
+
+
diff --git a/src/tests/business.test.html b/src/tests/business.test.html
new file mode 100644
index 0000000..fe8bb01
--- /dev/null
+++ b/src/tests/business.test.html
@@ -0,0 +1,30 @@
+
+
+
+ Business
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/client1.test.html b/src/tests/client1.test.html
new file mode 100644
index 0000000..51510c7
--- /dev/null
+++ b/src/tests/client1.test.html
@@ -0,0 +1,26 @@
+
+
+
+ Client test 1
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/debounce.test.html b/src/tests/debounce.test.html
new file mode 100644
index 0000000..b45f7eb
--- /dev/null
+++ b/src/tests/debounce.test.html
@@ -0,0 +1,30 @@
+
+
+
+ Debounce test
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/document.test.html b/src/tests/document.test.html
new file mode 100644
index 0000000..3978d2f
--- /dev/null
+++ b/src/tests/document.test.html
@@ -0,0 +1,26 @@
+
+
+
+ Document
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/flowchart.test.html b/src/tests/flowchart.test.html
new file mode 100644
index 0000000..ff07fe1
--- /dev/null
+++ b/src/tests/flowchart.test.html
@@ -0,0 +1,41 @@
+
+
+
+ Flowchart test
+
+
+
+
+
+
+
+
diff --git a/src/tests/forum1.test.html b/src/tests/forum1.test.html
new file mode 100644
index 0000000..4e338af
--- /dev/null
+++ b/src/tests/forum1.test.html
@@ -0,0 +1,26 @@
+
+
+
+ Forum test 1
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/forum10.test.html b/src/tests/forum10.test.html
new file mode 100644
index 0000000..ad297ed
--- /dev/null
+++ b/src/tests/forum10.test.html
@@ -0,0 +1,26 @@
+
+
+
+ Forum test 10
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/forum11.test.html b/src/tests/forum11.test.html
new file mode 100644
index 0000000..74a3926
--- /dev/null
+++ b/src/tests/forum11.test.html
@@ -0,0 +1,26 @@
+
+
+
+ Forum test 11
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/forum2.test.html b/src/tests/forum2.test.html
new file mode 100644
index 0000000..29af18a
--- /dev/null
+++ b/src/tests/forum2.test.html
@@ -0,0 +1,26 @@
+
+
+
+ Forum test 2
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/forum3.test.html b/src/tests/forum3.test.html
new file mode 100644
index 0000000..d9e41ed
--- /dev/null
+++ b/src/tests/forum3.test.html
@@ -0,0 +1,26 @@
+
+
+
+ Forum test 3
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/forum4.test.html b/src/tests/forum4.test.html
new file mode 100644
index 0000000..262977e
--- /dev/null
+++ b/src/tests/forum4.test.html
@@ -0,0 +1,26 @@
+
+
+
+ Forum test 4
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/forum5.test.html b/src/tests/forum5.test.html
new file mode 100644
index 0000000..f99f35e
--- /dev/null
+++ b/src/tests/forum5.test.html
@@ -0,0 +1,26 @@
+
+
+
+ Forum test 5
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/forum6.test.html b/src/tests/forum6.test.html
new file mode 100644
index 0000000..25f3d53
--- /dev/null
+++ b/src/tests/forum6.test.html
@@ -0,0 +1,26 @@
+
+
+
+ Forum test 6
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/forum7.test.html b/src/tests/forum7.test.html
new file mode 100644
index 0000000..bf10bd1
--- /dev/null
+++ b/src/tests/forum7.test.html
@@ -0,0 +1,26 @@
+
+
+
+ Forum test 7
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/forum8.test.html b/src/tests/forum8.test.html
new file mode 100644
index 0000000..7c18c59
--- /dev/null
+++ b/src/tests/forum8.test.html
@@ -0,0 +1,26 @@
+
+
+
+ Forum test 8
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/forum9.test.html b/src/tests/forum9.test.html
new file mode 100644
index 0000000..f5c5240
--- /dev/null
+++ b/src/tests/forum9.test.html
@@ -0,0 +1,26 @@
+
+
+
+ Forum test 9
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/input.test.html b/src/tests/input.test.html
new file mode 100644
index 0000000..b2b35e1
--- /dev/null
+++ b/src/tests/input.test.html
@@ -0,0 +1,26 @@
+
+
+
+ Input
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/mocha.test.html b/src/tests/mocha.test.html
new file mode 100644
index 0000000..174b492
--- /dev/null
+++ b/src/tests/mocha.test.html
@@ -0,0 +1,31 @@
+
+
+
+
+
+ Mocha Tests
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/reputation.test.html b/src/tests/reputation.test.html
new file mode 100644
index 0000000..d91e105
--- /dev/null
+++ b/src/tests/reputation.test.html
@@ -0,0 +1,35 @@
+
+
+
+ Reputation test
+
+
+
+
+
+
+
+
diff --git a/src/tests/scripts/availability.test.js b/src/tests/scripts/availability.test.js
new file mode 100644
index 0000000..5ac1619
--- /dev/null
+++ b/src/tests/scripts/availability.test.js
@@ -0,0 +1,174 @@
+import { Box } from '../../classes/display/box.js';
+import { Scene } from '../../classes/display/scene.js';
+import { Expert } from '../../classes/actors/expert.js';
+import { DAO } from '../../classes/dao/dao.js';
+import { Public } from '../../classes/actors/public.js';
+import { PostContent } from '../../classes/supporting/post-content.js';
+import { delayOrWait } from '../../classes/display/scene-controls.js';
+import { mochaRun } from '../../util/helpers.js';
+
+const DELAY_INTERVAL = 100;
+const POOL_DURATION = 200;
+let dao;
+let experts;
+let requestor;
+let scene;
+
+const newExpert = async () => {
+ const index = experts.length;
+ const name = `Expert${index + 1}`;
+ const expert = await new Expert(dao, name, scene).initialize();
+ experts.push(expert);
+ return expert;
+};
+
+const setup = async () => {
+ const rootElement = document.getElementById('scene');
+ const rootBox = new Box('rootBox', rootElement).flex();
+
+ scene = new Scene('Availability test', rootBox);
+ scene.withSequenceDiagram();
+ scene.withFlowchart();
+ scene.withTable();
+
+ dao = new DAO('DGF', scene);
+ await dao.setDisplayValue('total rep', () => dao.reputation.getTotal());
+
+ experts = [];
+
+ await newExpert();
+ await newExpert();
+ requestor = new Public('Public', scene);
+
+ await delayOrWait(DELAY_INTERVAL);
+
+ // Experts gain initial reputation by submitting a post with fee
+ const { postId: postId1, pool: pool1 } = await experts[0].submitPostWithFee(
+ new PostContent({ hello: 'there' }).setTitle('Post 1'),
+ {
+ fee: 10,
+ },
+ {
+ duration: POOL_DURATION,
+ tokenLossRatio: 1,
+ },
+ );
+ await delayOrWait(POOL_DURATION);
+
+ await pool1.evaluateWinningConditions();
+ await delayOrWait(DELAY_INTERVAL);
+
+ dao.reputation.valueOwnedBy(experts[0].reputationPublicKey).should.equal(10);
+
+ const { pool: pool2 } = await experts[1].submitPostWithFee(
+ new PostContent({ hello: 'to you as well' })
+ .setTitle('Post 2')
+ .addCitation(postId1, 0.5),
+ {
+ fee: 10,
+ },
+ {
+ duration: POOL_DURATION,
+ tokenLossRatio: 1,
+ },
+ );
+ await delayOrWait(POOL_DURATION);
+
+ await pool2.evaluateWinningConditions();
+ await delayOrWait(DELAY_INTERVAL);
+
+ dao.reputation.valueOwnedBy(experts[0].reputationPublicKey).should.equal(15);
+ dao.reputation.valueOwnedBy(experts[1].reputationPublicKey).should.equal(5);
+};
+
+const getActiveWorker = async () => {
+ let worker;
+ let request;
+ for (const expert of experts) {
+ request = await expert.getAssignedWork();
+ if (request) {
+ worker = expert;
+ await worker.actions.getAssignedWork.log(worker, dao.availability);
+ worker.activate();
+ break;
+ }
+ }
+ return { worker, request };
+};
+
+const voteForWorkEvidence = async (worker, pool) => {
+ for (const expert of experts) {
+ if (expert !== worker) {
+ await expert.stake(pool, {
+ position: true,
+ amount: 1,
+ });
+ }
+ }
+};
+
+describe('Availability + Business', function tests() {
+ this.timeout(0);
+
+ before(async () => {
+ await setup();
+ });
+
+ beforeEach(async () => {
+ // await scene.sequence.startSection();
+ });
+
+ afterEach(async () => {
+ // await scene.sequence.endSection();
+ });
+
+ it('Experts can register their availability for some duration', async () => {
+ await experts[0].registerAvailability(1, 10000);
+ await experts[1].registerAvailability(1, 10000);
+ await delayOrWait(DELAY_INTERVAL);
+ });
+
+ it('Public can submit a work request', async () => {
+ await requestor.submitRequest(
+ dao.business,
+ { fee: 100 },
+ { please: 'do some work' },
+ );
+ await delayOrWait(DELAY_INTERVAL);
+ });
+
+ it('Expert can submit work evidence', async () => {
+ // Receive work request
+ const { worker, request } = await getActiveWorker();
+ const pool3 = await worker.submitWork(
+ request.id,
+ {
+ here: 'is some evidence of work product',
+ },
+ {
+ tokenLossRatio: 1,
+ duration: POOL_DURATION,
+ },
+ );
+ await worker.deactivate();
+
+ // Stake on work evidence
+ await voteForWorkEvidence(worker, pool3);
+
+ // Wait for validation pool duration to elapse
+ await delayOrWait(POOL_DURATION);
+
+ // Distribute reputation awards and fees
+ await pool3.evaluateWinningConditions();
+ await delayOrWait(DELAY_INTERVAL);
+
+ // This should throw an exception since the pool is already resolved
+ try {
+ await pool3.evaluateWinningConditions();
+ } catch (e) {
+ e.should.match(/Validation pool has already been resolved/);
+ }
+ }).timeout(10000);
+});
+
+mochaRun();
diff --git a/src/tests/scripts/basic.test.js b/src/tests/scripts/basic.test.js
new file mode 100644
index 0000000..42b9aac
--- /dev/null
+++ b/src/tests/scripts/basic.test.js
@@ -0,0 +1,67 @@
+import { Box } from '../../classes/display/box.js';
+import { Scene } from '../../classes/display/scene.js';
+import { Actor } from '../../classes/display/actor.js';
+import { Action } from '../../classes/display/action.js';
+
+const rootElement = document.getElementById('basic');
+const rootBox = new Box('rootBox', rootElement).flex();
+
+function randomDelay(min, max) {
+ const delayMs = min + Math.random() * max;
+ return delayMs;
+}
+
+(function run() {
+ const scene = new Scene('Scene 1', rootBox).withSequenceDiagram();
+ const webClientStatus = scene.addDisplayValue('WebClient Status');
+ const node1Status = scene.addDisplayValue('Node 1 Status');
+ const blockchainStatus = scene.addDisplayValue('Blockchain Status');
+
+ const webClient = new Actor('web client', scene);
+ const node1 = new Actor('node 1', scene);
+ const blockchain = new Actor('blockchain', scene);
+ const requestForumPage = new Action('requestForumPage', scene);
+ const readBlockchainData = new Action('readBlockchainData', scene);
+ const blockchainData = new Action('blockchainData', scene);
+ const forumPage = new Action('forumPage', scene);
+
+ webClientStatus.set('Initialized');
+ node1Status.set('Idle');
+ blockchainStatus.set('Idle');
+
+ node1.on(requestForumPage, (src, detail) => {
+ node1Status.set('Processing request');
+ node1.on(blockchainData, (_src, data) => {
+ node1Status.set('Processing response');
+ setTimeout(() => {
+ node1.send(src, forumPage, data);
+ node1Status.set('Idle');
+ }, randomDelay(500, 1000));
+ });
+ setTimeout(() => {
+ node1.send(blockchain, readBlockchainData, detail);
+ }, randomDelay(500, 1500));
+ });
+
+ blockchain.on(readBlockchainData, (src, _detail) => {
+ blockchainStatus.set('Processing request');
+ setTimeout(() => {
+ blockchain.send(src, blockchainData, {});
+ blockchainStatus.set('Idle');
+ }, randomDelay(500, 1500));
+ });
+
+ webClient.on(forumPage, (_src, _detail) => {
+ webClientStatus.set('Received forum page');
+ });
+
+ setTimeout(() => {
+ webClient.send(node1, requestForumPage);
+ webClientStatus.set('Requested forum page');
+ }, randomDelay(500, 1500));
+
+ setInterval(() => {
+ webClient.send(node1, requestForumPage);
+ webClientStatus.set('Requested forum page');
+ }, randomDelay(6000, 12000));
+}());
diff --git a/src/tests/scripts/basic2.test.js b/src/tests/scripts/basic2.test.js
new file mode 100644
index 0000000..ae24b55
--- /dev/null
+++ b/src/tests/scripts/basic2.test.js
@@ -0,0 +1,139 @@
+import { Box } from '../../classes/display/box.js';
+import { Scene } from '../../classes/display/scene.js';
+import { Actor } from '../../classes/display/actor.js';
+
+const rootElement = document.getElementById('basic');
+const rootBox = new Box('rootBox', rootElement).flex();
+
+function delay(min, max = min) {
+ const delayMs = min + Math.random() * (max - min);
+ return new Promise((resolve) => {
+ setTimeout(resolve, delayMs);
+ });
+}
+
+(async function run() {
+ const scene = new Scene('Scene 2', rootBox).withSequenceDiagram();
+
+ const webClient = new Actor('webClient', scene);
+
+ const nodes = [];
+ const memories = [];
+ const storages = [];
+
+ async function addNode() {
+ const idx = nodes.length;
+ const node = new Actor(`node${idx}`, scene);
+ const memory = new Actor(`memory${idx}`, scene);
+ const storage = new Actor(`storage${idx}`, scene);
+ node.memory = memory;
+ node.storage = storage;
+ nodes.push(node);
+ memories.push(memory);
+ storages.push(storage);
+ return node;
+ }
+
+ function getPeer(node) {
+ const peers = nodes.filter((peer) => peer !== node);
+ const idx = Math.floor(Math.random() * peers.length);
+ return peers[idx];
+ }
+
+ await addNode();
+ await addNode();
+
+ const [
+ seekTruth,
+ considerInfo,
+ evaluateConfidence,
+ chooseResponse,
+ qualifiedOpinions,
+ requestMemoryData,
+ memoryData,
+ requestStorageData,
+ storageData,
+ ] = [
+ 'seek truth',
+ 'consider available information',
+ 'evaluate confidence',
+ 'choose response',
+ 'qualified opinions',
+ 'request in-memory data',
+ 'in-memory data',
+ 'request storage data',
+ 'storage data',
+ ].map((name) => scene.addAction(name));
+
+ memories.forEach((memory) => {
+ memory.setStatus('Idle');
+ memory.on(requestMemoryData, async (src, _detail) => {
+ memory.setStatus('Retrieving data');
+ await delay(1000);
+ memory.send(src, memoryData, {});
+ memory.setStatus('Idle');
+ });
+ });
+
+ storages.forEach((storage) => {
+ storage.setStatus('Idle');
+ storage.on(requestStorageData, async (src, _detail) => {
+ storage.setStatus('Retrieving data');
+ await delay(1000);
+ storage.send(src, storageData, {});
+ storage.setStatus('Idle');
+ });
+ });
+
+ nodes.forEach((node) => {
+ node.setStatus('Idle');
+ node.on(seekTruth, async (seeker, detail) => {
+ node.setStatus('Processing request');
+
+ node.on(chooseResponse, async (_src, _info) => {
+ node.setStatus('Choosing response');
+ await delay(1000);
+ node.send(seeker, qualifiedOpinions, {});
+ node.setStatus('Idle');
+ });
+
+ node.on(evaluateConfidence, async (_src, _info) => {
+ node.setStatus('Evaluating confidence');
+ await delay(1000);
+ node.send(node, chooseResponse);
+ });
+
+ node.on(considerInfo, async (_src, _info) => {
+ node.setStatus('Considering info');
+ await delay(1000);
+ node.send(node, evaluateConfidence);
+ });
+
+ node.on(memoryData, (_src, _data) => {
+ node.on(storageData, (__src, __data) => {
+ if (detail?.readConcern === 'single') {
+ node.send(node, considerInfo, {});
+ } else {
+ const peer = getPeer(node);
+ node.on(qualifiedOpinions, (___src, info) => {
+ node.send(node, considerInfo, info);
+ });
+ node.send(peer, seekTruth, { readConcern: 'single' });
+ }
+ });
+ node.send(node.storage, requestStorageData);
+ });
+
+ await delay(1000);
+ node.send(node.memory, requestMemoryData);
+ });
+ });
+
+ webClient.on(qualifiedOpinions, (_src, _detail) => {
+ webClient.setStatus('Received opinions and qualifications');
+ });
+
+ await delay(1000);
+ webClient.setStatus('Seek truth');
+ webClient.send(nodes[0], seekTruth);
+}());
diff --git a/src/tests/scripts/business.test.js b/src/tests/scripts/business.test.js
new file mode 100644
index 0000000..97bb8b2
--- /dev/null
+++ b/src/tests/scripts/business.test.js
@@ -0,0 +1,20 @@
+import { Business } from '../../classes/dao/business.js';
+import { Scene } from '../../classes/display/scene.js';
+import { Box } from '../../classes/display/box.js';
+import { mochaRun } from '../../util/helpers.js';
+
+describe('Business', function tests() {
+ this.timeout(0);
+ let scene;
+ before(async () => {
+ const rootElement = document.getElementById('scene');
+ const rootBox = new Box('rootBox', rootElement).flex();
+ scene = new Scene('Business', rootBox);
+ });
+ it('Should exist', () => {
+ const business = new Business(null, 'Business', scene);
+ should.exist(business);
+ });
+});
+
+mochaRun();
diff --git a/src/tests/scripts/client/client1.test.js b/src/tests/scripts/client/client1.test.js
new file mode 100644
index 0000000..b5e7e9c
--- /dev/null
+++ b/src/tests/scripts/client/client1.test.js
@@ -0,0 +1,26 @@
+import { mochaRun } from '../../../util/helpers.js';
+import { ForumTest } from '../forum.test-util.js';
+import { Client } from '../../../classes/dao/client.js';
+
+describe('Forum', function tests() {
+ this.timeout(0);
+
+ const forumTest = new ForumTest({ displayAuthors: false });
+ let client;
+
+ before(async () => {
+ await forumTest.setup();
+ await forumTest.newExpert();
+ await forumTest.newExpert();
+
+ client = new Client(forumTest.dao, forumTest.experts[0]);
+ });
+
+ it('Expert can run a client', async () => {
+ client.should.not.be.undefined;
+ client.dao.should.equal(forumTest.dao);
+ client.expert.should.equal(forumTest.experts[0]);
+ });
+});
+
+mochaRun();
diff --git a/src/tests/scripts/debounce.test.js b/src/tests/scripts/debounce.test.js
new file mode 100644
index 0000000..2945e18
--- /dev/null
+++ b/src/tests/scripts/debounce.test.js
@@ -0,0 +1,74 @@
+import { Box } from '../../classes/display/box.js';
+import { Scene } from '../../classes/display/scene.js';
+import { Action } from '../../classes/display/action.js';
+import { Actor } from '../../classes/display/actor.js';
+import { debounce, delay, mochaRun } from '../../util/helpers.js';
+
+describe('Debounce', () => {
+ let scene;
+ let caller;
+ let debouncer;
+ let method;
+
+ let call;
+ let execute;
+
+ before(() => {
+ const rootElement = document.getElementById('scene');
+ const rootBox = new Box('rootBox', rootElement).flex();
+
+ scene = new Scene('Debounce test', rootBox).withSequenceDiagram();
+ caller = new Actor('Caller', scene);
+ debouncer = new Actor('Debouncer', scene);
+ method = new Actor('Target method', scene);
+
+ call = new Action('call', scene);
+ execute = new Action('execute', scene);
+ });
+
+ it('Suppresses extra events that occur within the specified window', async () => {
+ let eventCount = 0;
+ const event = sinon.spy(async () => {
+ eventCount++;
+ await execute.log(debouncer, method, eventCount);
+ });
+
+ await scene.sequence.startSection();
+ await call.log(caller, debouncer, '1');
+ await debounce(event, 500);
+ await call.log(caller, debouncer, '2');
+ await debounce(event, 500);
+
+ await delay(500);
+ event.should.have.been.calledOnce;
+
+ await call.log(caller, debouncer, '3');
+ await debounce(event, 500);
+ await call.log(caller, debouncer, '4');
+ await debounce(event, 500);
+
+ eventCount.should.equal(2);
+ event.should.have.been.calledTwice;
+ await scene.sequence.endSection();
+ });
+
+ it('Propagates exceptions', async () => {
+ const event = sinon.spy(async () => {
+ await execute.log(debouncer, method, undefined, undefined, '-x');
+ throw new Error('An error occurs in the callback');
+ });
+ await scene.sequence.startSection();
+
+ try {
+ await call.log(caller, debouncer);
+ await debounce(event, 500);
+ } catch (e) {
+ event.should.have.been.calledOnce;
+ e.should.exist;
+ e.should.match(/An error occurs in the callback/);
+ }
+ await scene.sequence.endSection();
+ });
+});
+
+mochaRun();
diff --git a/src/tests/scripts/document.test.js b/src/tests/scripts/document.test.js
new file mode 100644
index 0000000..c09fcfb
--- /dev/null
+++ b/src/tests/scripts/document.test.js
@@ -0,0 +1,23 @@
+import { Box } from '../../classes/display/box.js';
+// import { Document } from '../../classes/display/document.js';
+import { Scene } from '../../classes/display/scene.js';
+import { mochaRun } from '../../util/helpers.js';
+
+const rootElement = document.getElementById('scene');
+const rootBox = new Box('rootBox', rootElement).flex();
+const scene = window.scene = new Scene('Document test', rootBox);
+
+scene.withDocument();
+
+describe('Document', () => {
+ describe('remark', () => {
+ it('can exist', () => {
+ const docFunction = (doc) => doc.remark('Hello');
+ scene.withDocument('Document', docFunction);
+ });
+ it.skip('can include handlebars expressions', () => { });
+ it.skip('updates rendered output when input changes', () => { });
+ });
+});
+
+mochaRun();
diff --git a/src/tests/scripts/forum.test-util.js b/src/tests/scripts/forum.test-util.js
new file mode 100644
index 0000000..36cb47a
--- /dev/null
+++ b/src/tests/scripts/forum.test-util.js
@@ -0,0 +1,91 @@
+import { Box } from '../../classes/display/box.js';
+import { Scene } from '../../classes/display/scene.js';
+import { Expert } from '../../classes/actors/expert.js';
+import { PostContent } from '../../classes/supporting/post-content.js';
+import { DAO } from '../../classes/dao/dao.js';
+import { delayOrWait } from '../../classes/display/scene-controls.js';
+
+export class ForumTest {
+ constructor(options) {
+ this.scene = null;
+ this.dao = null;
+ this.experts = null;
+ this.posts = null;
+ this.options = {
+ defaultDelayMs: 1,
+ poolDurationMs: 50,
+ ...options,
+ };
+ }
+
+ async addPost(authors, fee, citations = []) {
+ const postIndex = this.posts.length;
+ const title = `posts[${postIndex}]`;
+ await this.scene.sequence.startSection();
+
+ const postContent = new PostContent().setTitle(title);
+
+ const submitter = Array.isArray(authors) ? authors[0].author : authors;
+
+ if (Array.isArray(authors)) {
+ for (const { author, weight } of authors) {
+ console.log('author', { author, weight });
+ postContent.addAuthor(author.reputationPublicKey, weight);
+ }
+ }
+
+ for (const { postId, weight } of citations) {
+ postContent.addCitation(postId, weight);
+ }
+
+ const { pool, postId } = await submitter.submitPostWithFee(
+ postContent,
+ {
+ fee,
+ },
+ {
+ duration: this.options.poolDurationMs,
+ tokenLossRatio: 1,
+ },
+ );
+ this.posts.push(postId);
+ await delayOrWait(this.options.poolDurationMs);
+ await pool.evaluateWinningConditions();
+ await this.scene.sequence.endSection();
+ await delayOrWait(this.options.defaultDelayMs);
+ return postId;
+ }
+
+ async newExpert() {
+ // Hide by default, for simplicity of rendering first 9 forum tests
+ const options = {
+ hide: !this.options.displayAuthors,
+ announce: this.options.displayAuthors,
+ };
+ const index = this.experts.length;
+ const name = `Expert${index + 1}`;
+ const expert = await new Expert(this.dao, name, this.scene, options).initialize();
+ this.experts.push(expert);
+ return expert;
+ }
+
+ async setup() {
+ const rootElement = document.getElementById('scene');
+ const rootBox = new Box('rootBox', rootElement).flex();
+
+ const scene = this.scene = new Scene('Forum test', rootBox);
+ scene.withSequenceDiagram();
+ scene.withFlowchart();
+ scene.withTable();
+
+ // If we're going to announce experts, announce the DAO so it appears first.
+ this.dao = new DAO('DAO', scene, { announce: this.options.displayAuthors });
+ this.forum = this.dao.forum;
+ this.experts = [];
+ this.posts = [];
+
+ await this.newExpert();
+
+ await this.dao.addComputedValue('total value', () => this.dao.reputation.getTotal());
+ }
+}
diff --git a/src/tests/scripts/forum/forum1.test.js b/src/tests/scripts/forum/forum1.test.js
new file mode 100644
index 0000000..38536e1
--- /dev/null
+++ b/src/tests/scripts/forum/forum1.test.js
@@ -0,0 +1,39 @@
+import { mochaRun } from '../../../util/helpers.js';
+import { ForumTest } from '../forum.test-util.js';
+
+describe('Forum', function tests() {
+ this.timeout(0);
+
+ const forumTest = new ForumTest({ displayAuthors: false });
+
+ before(async () => {
+ await forumTest.setup();
+ await forumTest.newExpert();
+ await forumTest.newExpert();
+ });
+
+ context('Negative citation of a negative citation', async () => {
+ it('Post1', async () => {
+ const { forum, experts, posts } = forumTest;
+ await forumTest.addPost(experts[0], 10);
+ forum.getPost(posts[0]).value.should.equal(10);
+ });
+
+ it('Post2 negatively cites Post1', async () => {
+ const { forum, experts, posts } = forumTest;
+ await forumTest.addPost(experts[1], 10, [{ postId: posts[0], weight: -1 }]);
+ forum.getPost(posts[0]).value.should.equal(0);
+ forum.getPost(posts[1]).value.should.equal(20);
+ });
+
+ it('Post3 negatively cites Post2, restoring Post1 post to its initial value', async () => {
+ const { forum, experts, posts } = forumTest;
+ await forumTest.addPost(experts[2], 10, [{ postId: posts[1], weight: -1 }]);
+ forum.getPost(posts[0]).value.should.equal(10);
+ forum.getPost(posts[1]).value.should.equal(0);
+ forum.getPost(posts[2]).value.should.equal(20);
+ });
+ });
+});
+
+mochaRun();
diff --git a/src/tests/scripts/forum/forum10.test.js b/src/tests/scripts/forum/forum10.test.js
new file mode 100644
index 0000000..21430a3
--- /dev/null
+++ b/src/tests/scripts/forum/forum10.test.js
@@ -0,0 +1,44 @@
+import { mochaRun } from '../../../util/helpers.js';
+import { ForumTest } from '../forum.test-util.js';
+
+describe('Forum', function tests() {
+ this.timeout(0);
+
+ const forumTest = new ForumTest({ displayAuthors: true });
+
+ before(async () => {
+ await forumTest.setup();
+ await forumTest.newExpert();
+ await forumTest.newExpert();
+ });
+
+ context('Post with multiple authors', async () => {
+ let forum;
+ let experts;
+ let posts;
+ let dao;
+
+ before(async () => {
+ forum = forumTest.forum;
+ experts = forumTest.experts;
+ posts = forumTest.posts;
+ dao = forumTest.dao;
+ });
+
+ it('Post1 has three authors and reputation is distributed among them', async () => {
+ const authors = [
+ { author: experts[0], weight: 0.5 },
+ { author: experts[1], weight: 0.25 },
+ { author: experts[2], weight: 0.25 },
+ ];
+ await forumTest.addPost(authors, 10);
+ forum.getPost(posts[0]).value.should.equal(10);
+
+ dao.reputation.valueOwnedBy(experts[0].reputationPublicKey).should.equal(5);
+ dao.reputation.valueOwnedBy(experts[1].reputationPublicKey).should.equal(2.5);
+ dao.reputation.valueOwnedBy(experts[2].reputationPublicKey).should.equal(2.5);
+ });
+ });
+});
+
+mochaRun();
diff --git a/src/tests/scripts/forum/forum11.test.js b/src/tests/scripts/forum/forum11.test.js
new file mode 100644
index 0000000..04dcc92
--- /dev/null
+++ b/src/tests/scripts/forum/forum11.test.js
@@ -0,0 +1,56 @@
+import { mochaRun } from '../../../util/helpers.js';
+import { ForumTest } from '../forum.test-util.js';
+
+describe('Forum', function tests() {
+ this.timeout(0);
+
+ const forumTest = new ForumTest({ displayAuthors: true });
+
+ before(async () => {
+ await forumTest.setup();
+ await forumTest.newExpert();
+ await forumTest.newExpert();
+ });
+
+ context('Multiple posts with overlapping authors', async () => {
+ let forum;
+ let experts;
+ let posts;
+ let dao;
+
+ before(async () => {
+ forum = forumTest.forum;
+ experts = forumTest.experts;
+ posts = forumTest.posts;
+ dao = forumTest.dao;
+ });
+
+ it('Post1 with two authors', async () => {
+ const authors = [
+ { author: experts[0], weight: 0.5 },
+ { author: experts[1], weight: 0.5 },
+ ];
+ await forumTest.addPost(authors, 10);
+ forum.getPost(posts[0]).value.should.equal(10);
+
+ dao.reputation.valueOwnedBy(experts[0].reputationPublicKey).should.equal(5);
+ dao.reputation.valueOwnedBy(experts[1].reputationPublicKey).should.equal(5);
+ dao.reputation.valueOwnedBy(experts[2].reputationPublicKey).should.equal(0);
+ });
+
+ it('Post2 with two authors, one shared with Post1', async () => {
+ const authors = [
+ { author: experts[1], weight: 0.5 },
+ { author: experts[2], weight: 0.5 },
+ ];
+ await forumTest.addPost(authors, 10);
+ forum.getPost(posts[0]).value.should.equal(10);
+
+ dao.reputation.valueOwnedBy(experts[0].reputationPublicKey).should.equal(5);
+ dao.reputation.valueOwnedBy(experts[1].reputationPublicKey).should.equal(10);
+ dao.reputation.valueOwnedBy(experts[2].reputationPublicKey).should.equal(5);
+ });
+ });
+});
+
+mochaRun();
diff --git a/src/tests/scripts/forum/forum2.test.js b/src/tests/scripts/forum/forum2.test.js
new file mode 100644
index 0000000..fa98a90
--- /dev/null
+++ b/src/tests/scripts/forum/forum2.test.js
@@ -0,0 +1,44 @@
+import { mochaRun } from '../../../util/helpers.js';
+import { ForumTest } from '../forum.test-util.js';
+
+describe('Forum', function tests() {
+ this.timeout(0);
+
+ const forumTest = new ForumTest();
+
+ before(async () => {
+ await forumTest.setup();
+ });
+
+ context('Negative citation of a weaker negative citation', async () => {
+ it('Post4', async () => {
+ const { forum, experts, posts } = forumTest;
+ await forumTest.addPost(experts[0], 10);
+ forum.getPost(posts[0]).value.should.equal(10);
+ });
+
+ it('Post5 negatively cites Post4', async () => {
+ const { forum, experts, posts } = forumTest;
+ await forumTest.addPost(experts[0], 10, [{ postId: posts[0], weight: -0.5 }]);
+ forum.getPost(posts[0]).value.should.equal(5);
+ forum.getPost(posts[1]).value.should.equal(15);
+ });
+
+ it('Post6 negatively cites Post5, restoring Post4 post to its initial value', async () => {
+ const { forum, experts, posts } = forumTest;
+ await forumTest.addPost(experts[0], 20, [{ postId: posts[1], weight: -1 }]);
+ forum.getPost(posts[0]).value.should.equal(10);
+ forum.getPost(posts[1]).value.should.equal(0);
+ forum.getPost(posts[2]).value.should.equal(30);
+ });
+ });
+});
+
+// await addPost(experts[0], 10);
+// await addPost(experts[0], 10, [{ postId: posts[3], weight: -1 }]);
+// await addPost(experts[0], 10, [{ postId: posts[4], weight: -1 }]);
+
+// await addPost(expert3, 'Post 4', 100, [{ postId: postId2, weight: -1 }]);
+// await addPost(expert1, 'Post 5', 100, [{ postId: postId3, weight: -1 }]);
+
+mochaRun();
diff --git a/src/tests/scripts/forum/forum3.test.js b/src/tests/scripts/forum/forum3.test.js
new file mode 100644
index 0000000..529298b
--- /dev/null
+++ b/src/tests/scripts/forum/forum3.test.js
@@ -0,0 +1,47 @@
+import { mochaRun } from '../../../util/helpers.js';
+import { ForumTest } from '../forum.test-util.js';
+
+describe('Forum', function tests() {
+ this.timeout(0);
+
+ const forumTest = new ForumTest();
+
+ before(async () => {
+ await forumTest.setup();
+ });
+
+ context('Redistribute power', async () => {
+ it('Post1', async () => {
+ const { forum, experts, posts } = forumTest;
+ await forumTest.addPost(experts[0], 10);
+ forum.getPost(posts[0]).value.should.equal(10);
+ });
+
+ it('Post2', async () => {
+ const { forum, experts, posts } = forumTest;
+ await forumTest.addPost(experts[0], 0);
+ forum.getPost(posts[0]).value.should.equal(10);
+ forum.getPost(posts[1]).value.should.equal(0);
+ });
+
+ it('Post3 cites Post2 and negatively cites Post1', async () => {
+ const { forum, experts, posts } = forumTest;
+ await forumTest.addPost(experts[0], 10, [
+ { postId: posts[0], weight: -1 },
+ { postId: posts[1], weight: 1 },
+ ]);
+ forum.getPost(posts[0]).value.should.equal(0);
+ forum.getPost(posts[1]).value.should.equal(20);
+ forum.getPost(posts[2]).value.should.equal(0);
+ });
+ });
+});
+
+// await addPost(experts[0], 10);
+// await addPost(experts[0], 10, [{ postId: posts[3], weight: -1 }]);
+// await addPost(experts[0], 10, [{ postId: posts[4], weight: -1 }]);
+
+// await addPost(expert3, 'Post 4', 100, [{ postId: postId2, weight: -1 }]);
+// await addPost(expert1, 'Post 5', 100, [{ postId: postId3, weight: -1 }]);
+
+mochaRun();
diff --git a/src/tests/scripts/forum/forum4.test.js b/src/tests/scripts/forum/forum4.test.js
new file mode 100644
index 0000000..097d7e2
--- /dev/null
+++ b/src/tests/scripts/forum/forum4.test.js
@@ -0,0 +1,75 @@
+import { mochaRun } from '../../../util/helpers.js';
+import { ForumTest } from '../forum.test-util.js';
+
+describe('Forum', function tests() {
+ this.timeout(0);
+
+ const forumTest = new ForumTest();
+
+ before(async () => {
+ await forumTest.setup();
+ });
+
+ context('Redistribute power through subsequent support', async () => {
+ let forum;
+ let experts;
+ let posts;
+
+ before(() => {
+ forum = forumTest.forum;
+ experts = forumTest.experts;
+ posts = forumTest.posts;
+ });
+
+ it('Post1', async () => {
+ await forumTest.addPost(experts[0], 10);
+ forum.getPost(posts[0]).value.should.equal(10);
+ });
+
+ it('Post2', async () => {
+ await forumTest.addPost(experts[0], 10);
+ forum.getPost(posts[0]).value.should.equal(10);
+ forum.getPost(posts[1]).value.should.equal(10);
+ });
+
+ it('Post3 cites Post2 and negatively cites Post1', async () => {
+ await forumTest.addPost(experts[0], 0, [
+ { postId: posts[0], weight: -1 },
+ { postId: posts[1], weight: 1 },
+ ]);
+ forum.getPost(posts[0]).value.should.equal(10);
+ forum.getPost(posts[1]).value.should.equal(10);
+ forum.getPost(posts[2]).value.should.equal(0);
+ });
+
+ it('Post4 cites Post3 to strengthen its effect', async () => {
+ await forumTest.addPost(experts[0], 10, [
+ { postId: posts[2], weight: 1 },
+ ]);
+ forum.getPost(posts[0]).value.should.equal(0);
+ forum.getPost(posts[1]).value.should.equal(30);
+ forum.getPost(posts[2]).value.should.equal(0);
+ forum.getPost(posts[3]).value.should.equal(0);
+ });
+
+ it('Post5 cites Post3 to strengthen its effect', async () => {
+ await forumTest.addPost(experts[0], 10, [
+ { postId: posts[2], weight: 1 },
+ ]);
+ forum.getPost(posts[0]).value.should.equal(0);
+ forum.getPost(posts[1]).value.should.equal(40);
+ forum.getPost(posts[2]).value.should.equal(0);
+ forum.getPost(posts[3]).value.should.equal(0);
+ forum.getPost(posts[4]).value.should.equal(0);
+ });
+ });
+});
+
+// await addPost(experts[0], 10);
+// await addPost(experts[0], 10, [{ postId: posts[3], weight: -1 }]);
+// await addPost(experts[0], 10, [{ postId: posts[4], weight: -1 }]);
+
+// await addPost(expert3, 'Post 4', 100, [{ postId: postId2, weight: -1 }]);
+// await addPost(expert1, 'Post 5', 100, [{ postId: postId3, weight: -1 }]);
+
+mochaRun();
diff --git a/src/tests/scripts/forum/forum5.test.js b/src/tests/scripts/forum/forum5.test.js
new file mode 100644
index 0000000..5988001
--- /dev/null
+++ b/src/tests/scripts/forum/forum5.test.js
@@ -0,0 +1,64 @@
+import { mochaRun } from '../../../util/helpers.js';
+import { ForumTest } from '../forum.test-util.js';
+
+describe('Forum', function tests() {
+ this.timeout(0);
+
+ const forumTest = new ForumTest();
+
+ before(async () => {
+ await forumTest.setup();
+ });
+
+ context('Destroy a post after it has received positive citations', async () => {
+ let forum;
+ let experts;
+ let posts;
+
+ before(() => {
+ forum = forumTest.forum;
+ experts = forumTest.experts;
+ posts = forumTest.posts;
+ });
+
+ it('Post1', async () => {
+ await forumTest.addPost(experts[0], 100);
+ forum.getPost(posts[0]).value.should.equal(100);
+ });
+
+ it('Post2 negatively cites Post1', async () => {
+ await forumTest.addPost(experts[0], 10, [
+ { postId: posts[0], weight: -0.5 },
+ ]);
+ forum.getPost(posts[0]).value.should.equal(95);
+ forum.getPost(posts[1]).value.should.equal(15);
+ });
+
+ it('Post3 positively cites Post2', async () => {
+ await forumTest.addPost(experts[0], 50, [
+ { postId: posts[1], weight: 0.5 },
+ ]);
+ forum.getPost(posts[0]).value.should.equal(95 - 12.5);
+ forum.getPost(posts[1]).value.should.equal(15 + 25 + 12.5);
+ forum.getPost(posts[2]).value.should.equal(25);
+ });
+
+ it('Post4 negatively cites Post2', async () => {
+ await forumTest.addPost(experts[0], 100, [
+ { postId: posts[1], weight: -1 },
+ ]);
+ // forum.getPost(posts[0]).value.should.equal(95 - 12.5);
+ // forum.getPost(posts[1]).value.should.equal(15 + 25 + 12.5);
+ // forum.getPost(posts[2]).value.should.equal(25);
+ });
+ });
+});
+
+// await addPost(experts[0], 10);
+// await addPost(experts[0], 10, [{ postId: posts[3], weight: -1 }]);
+// await addPost(experts[0], 10, [{ postId: posts[4], weight: -1 }]);
+
+// await addPost(expert3, 'Post 4', 100, [{ postId: postId2, weight: -1 }]);
+// await addPost(expert1, 'Post 5', 100, [{ postId: postId3, weight: -1 }]);
+
+mochaRun();
diff --git a/src/tests/scripts/forum/forum6.test.js b/src/tests/scripts/forum/forum6.test.js
new file mode 100644
index 0000000..ab32aba
--- /dev/null
+++ b/src/tests/scripts/forum/forum6.test.js
@@ -0,0 +1,70 @@
+import { mochaRun } from '../../../util/helpers.js';
+import { EPSILON } from '../../../util/constants.js';
+import { ForumTest } from '../forum.test-util.js';
+
+describe('Forum', function tests() {
+ this.timeout(0);
+
+ const forumTest = new ForumTest();
+
+ before(async () => {
+ await forumTest.setup();
+ });
+
+ context('Negatively citing a zero-valued post', async () => {
+ let forum;
+ let experts;
+ let posts;
+
+ before(() => {
+ forum = forumTest.forum;
+ experts = forumTest.experts;
+ posts = forumTest.posts;
+ });
+
+ it('Post1: Work SC prototype', async () => {
+ await forumTest.addPost(experts[0], 0);
+ forum.getPost(posts[0]).value.should.equal(0);
+ });
+
+ it('Post2: Work SC improvement', async () => {
+ await forumTest.addPost(experts[0], 0, [
+ { postId: posts[0], weight: 0.9 },
+ ]);
+ forum.getPost(posts[0]).value.should.equal(0);
+ forum.getPost(posts[1]).value.should.equal(0);
+ });
+
+ it('Post3: Work SC improvement', async () => {
+ await forumTest.addPost(experts[0], 0, [
+ { postId: posts[1], weight: 0.8 },
+ ]);
+ forum.getPost(posts[0]).value.should.equal(0);
+ forum.getPost(posts[1]).value.should.equal(0);
+ forum.getPost(posts[2]).value.should.equal(0);
+ });
+
+ it('Post4: Work evidence using latest work SC', async () => {
+ await forumTest.addPost(experts[0], 100, [
+ { postId: posts[2], weight: 0.05 },
+ ]);
+ forum.getPost(posts[0]).value.should.equal(3.6);
+ forum.getPost(posts[1]).value.should.be.within(0.40 - EPSILON, 0.40 + EPSILON);
+ forum.getPost(posts[2]).value.should.equal(1);
+ forum.getPost(posts[3]).value.should.equal(95);
+ });
+
+ it('Post5: Work evidence using latest work SC', async () => {
+ await forumTest.addPost(experts[0], 100, [
+ { postId: posts[2], weight: 0.05 },
+ ]);
+ forum.getPost(posts[0]).value.should.equal(7.2);
+ forum.getPost(posts[1]).value.should.be.within(0.80 - EPSILON, 0.80 + EPSILON);
+ forum.getPost(posts[2]).value.should.equal(2);
+ forum.getPost(posts[3]).value.should.equal(95);
+ forum.getPost(posts[4]).value.should.equal(95);
+ });
+ });
+});
+
+mochaRun();
diff --git a/src/tests/scripts/forum/forum7.test.js b/src/tests/scripts/forum/forum7.test.js
new file mode 100644
index 0000000..1a0d293
--- /dev/null
+++ b/src/tests/scripts/forum/forum7.test.js
@@ -0,0 +1,39 @@
+import { mochaRun } from '../../../util/helpers.js';
+import { ForumTest } from '../forum.test-util.js';
+
+describe('Forum', function tests() {
+ this.timeout(0);
+
+ const forumTest = new ForumTest();
+
+ before(async () => {
+ await forumTest.setup();
+ });
+
+ context('Initially zero-valued post later receives citations', async () => {
+ let forum;
+ let experts;
+ let posts;
+
+ before(() => {
+ forum = forumTest.forum;
+ experts = forumTest.experts;
+ posts = forumTest.posts;
+ });
+
+ it('Post1 has zero value', async () => {
+ await forumTest.addPost(experts[0], 0);
+ forum.getPost(posts[0]).value.should.equal(0);
+ });
+
+ it('Post2 negatively cites Post1', async () => {
+ await forumTest.addPost(experts[0], 10, [
+ { postId: posts[0], weight: -1 },
+ ]);
+ forum.getPost(posts[0]).value.should.equal(0);
+ forum.getPost(posts[1]).value.should.equal(10);
+ });
+ });
+});
+
+mochaRun();
diff --git a/src/tests/scripts/forum/forum8.test.js b/src/tests/scripts/forum/forum8.test.js
new file mode 100644
index 0000000..63da1ed
--- /dev/null
+++ b/src/tests/scripts/forum/forum8.test.js
@@ -0,0 +1,51 @@
+import { mochaRun } from '../../../util/helpers.js';
+import { INCINERATOR_ADDRESS } from '../../../util/constants.js';
+import { ForumTest } from '../forum.test-util.js';
+
+describe('Forum', function tests() {
+ this.timeout(0);
+
+ const forumTest = new ForumTest();
+
+ before(async () => {
+ await forumTest.setup();
+ });
+
+ context('Incinerate reputation', async () => {
+ let forum;
+ let experts;
+ let posts;
+
+ before(() => {
+ forum = forumTest.forum;
+ experts = forumTest.experts;
+ posts = forumTest.posts;
+ });
+
+ it('Post1', async () => {
+ await forumTest.addPost(experts[0], 10);
+ forum.getPost(posts[0]).value.should.equal(10);
+ });
+
+ it('Post2 burns reputation from Post1', async () => {
+ await forumTest.addPost(experts[0], 10, [
+ { postId: posts[0], weight: -1 },
+ { postId: INCINERATOR_ADDRESS, weight: 1 },
+ ]);
+ forum.getPost(posts[0]).value.should.equal(0);
+ forum.getPost(posts[1]).value.should.equal(0);
+ });
+
+ it('Reputation can not be sourced from the incinerator', async () => {
+ try {
+ await forumTest.addPost(experts[0], 10, [
+ { postId: INCINERATOR_ADDRESS, weight: -1 },
+ ]);
+ } catch (e) {
+ e.message.should.match(/Incinerator can only receive positive citations/);
+ }
+ });
+ });
+});
+
+mochaRun();
diff --git a/src/tests/scripts/forum/forum9.test.js b/src/tests/scripts/forum/forum9.test.js
new file mode 100644
index 0000000..76eaf41
--- /dev/null
+++ b/src/tests/scripts/forum/forum9.test.js
@@ -0,0 +1,49 @@
+import { mochaRun } from '../../../util/helpers.js';
+import { INCINERATOR_ADDRESS } from '../../../util/constants.js';
+import { ForumTest } from '../forum.test-util.js';
+
+describe('Forum', function tests() {
+ this.timeout(0);
+
+ const forumTest = new ForumTest();
+
+ before(async () => {
+ await forumTest.setup();
+ });
+
+ context('Use incineration to achieve more balanced reweighting', async () => {
+ let forum;
+ let experts;
+ let posts;
+
+ before(() => {
+ forum = forumTest.forum;
+ experts = forumTest.experts;
+ posts = forumTest.posts;
+ });
+
+ it('Post1', async () => {
+ await forumTest.addPost(experts[0], 10);
+ forum.getPost(posts[0]).value.should.equal(10);
+ });
+
+ it('Post2', async () => {
+ await forumTest.addPost(experts[0], 0);
+ forum.getPost(posts[0]).value.should.equal(10);
+ forum.getPost(posts[1]).value.should.equal(0);
+ });
+
+ it('Post3 transfers reputation from Post1 to Post2', async () => {
+ await forumTest.addPost(experts[0], 10, [
+ { postId: posts[0], weight: -1 },
+ { postId: posts[1], weight: 0.5 },
+ { postId: INCINERATOR_ADDRESS, weight: 0.5 },
+ ]);
+ forum.getPost(posts[0]).value.should.equal(0);
+ forum.getPost(posts[1]).value.should.equal(10);
+ forum.getPost(posts[2]).value.should.equal(0);
+ });
+ });
+});
+
+mochaRun();
diff --git a/src/tests/scripts/input.test.js b/src/tests/scripts/input.test.js
new file mode 100644
index 0000000..8908dc4
--- /dev/null
+++ b/src/tests/scripts/input.test.js
@@ -0,0 +1,70 @@
+import { Box } from '../../classes/display/box.js';
+// import { Document } from '../../classes/display/document.js';
+import { Scene } from '../../classes/display/scene.js';
+import { mochaRun } from '../../util/helpers.js';
+
+const rootElement = document.getElementById('scene');
+const rootBox = new Box('rootBox', rootElement).flex();
+const scene = window.scene = new Scene('Input test', rootBox);
+
+scene.withDocument();
+
+describe('Document > Form > TextField', () => {
+ before(() => {
+ scene.withDocument('Document 1', (d) => d.form());
+ });
+ it('can accept input and call value update callback', () => {
+ const doc = scene.lastDocument;
+ const form = doc.lastElement;
+ /**
+ * Handler callback for form element value updates.
+ * In this case we use a collection of DisplayValues as a straightforward way to render the form element values.
+ */
+ const dvMap = new Map();
+ const updateFieldValueDisplay = ({ id, name, value }) => {
+ const dv = dvMap.get(id) ?? scene.addDisplayValue(name);
+ dvMap.set(id, dv);
+ dv.set(value);
+ };
+
+ form.textField({
+ id: 'input1',
+ name: 'Input 1',
+ cb: updateFieldValueDisplay,
+ cbEventTypes: ['keydown', 'keyup'],
+ cbOnInit: true,
+ });
+ doc.remark('Hmm...!');
+ });
+ // it('can exist within a graph', () => {
+ // scene.withSectionFlowchart({ id: 'flowchart', name: 'Graph' });
+ // const graph = scene.lastFlowchart();
+ // });
+});
+
+describe('Document > Form > Button', () => {
+ before(() => {
+ scene.withDocument('Document 2', (d) => d.form());
+ });
+ it('calls a callback when clicked', () => {
+ const doc = scene.lastDocument;
+ const form = doc.lastElement;
+ const dvMap = new Map();
+ let clicks = 0;
+ const handleClick = ({ id, name }, { initializing }) => {
+ const dv = dvMap.get(id) ?? scene.addDisplayValue(name);
+ dvMap.set(id, dv);
+ if (!initializing) {
+ clicks++;
+ dv.set(`clicked ${clicks} time${clicks !== 1 ? 's' : ''}`);
+ }
+ };
+
+ doc.remark('
');
+ doc.remark('Button:');
+ form.button({ id: 'button1', name: 'Button 1', cb: handleClick });
+ doc.remark('Yeah?');
+ });
+});
+
+mochaRun();
diff --git a/src/tests/scripts/mocha.test.js b/src/tests/scripts/mocha.test.js
new file mode 100644
index 0000000..17fac9b
--- /dev/null
+++ b/src/tests/scripts/mocha.test.js
@@ -0,0 +1,23 @@
+describe('Array', () => {
+ before(() => {
+ // ...
+ });
+
+ describe('#indexOf()', () => {
+ context('when not present', () => {
+ it('should not throw an error', () => {
+ (function aFunc() {
+ [1, 2, 3].indexOf(4);
+ }.should.not.throw());
+ });
+ it('should return -1', () => {
+ [1, 2, 3].indexOf(4).should.equal(-1);
+ });
+ });
+ context('when present', () => {
+ it('should return the index where the element first appears in the array', () => {
+ [1, 2, 3].indexOf(3).should.equal(2);
+ });
+ });
+ });
+});
diff --git a/src/tests/scripts/test-framework.js b/src/tests/scripts/test-framework.js
new file mode 100644
index 0000000..4f59ec0
--- /dev/null
+++ b/src/tests/scripts/test-framework.js
@@ -0,0 +1,14 @@
+/**
+ * We want to be able to define tests essentially as sequences of actions by actors,
+ * with assertions about various values after each action.
+ *
+ * We also want the following features:
+ * - Advance tests automatically, for use as automated regression tests.
+ * - Advance tests manually, for use as a visual demo on a web page.
+ * - Nice to have: Manually add/remove/modify action steps.
+ * - Nice to have: Manually rewind actions to view prior states.
+ * - Nice to have: Export/import sequences of action steps.
+ */
+export class Test {
+
+}
diff --git a/src/tests/scripts/validation-pool.test.js b/src/tests/scripts/validation-pool.test.js
new file mode 100644
index 0000000..15ceef4
--- /dev/null
+++ b/src/tests/scripts/validation-pool.test.js
@@ -0,0 +1,117 @@
+import { Box } from '../../classes/display/box.js';
+import { Scene } from '../../classes/display/scene.js';
+import { Expert } from '../../classes/actors/expert.js';
+import { PostContent } from '../../classes/supporting/post-content.js';
+import { DAO } from '../../classes/dao/dao.js';
+import { delayOrWait } from '../../classes/display/scene-controls.js';
+import { mochaRun } from '../../util/helpers.js';
+
+const POOL_DURATION_MS = 100;
+const DEFAULT_DELAY_MS = 100;
+
+let scene;
+let experts;
+let dao;
+
+async function newExpert() {
+ const index = experts.length;
+ const name = `Expert${index + 1}`;
+ const expert = await new Expert(dao, name, scene).initialize();
+ experts.push(expert);
+ return expert;
+}
+
+async function setup() {
+ const rootElement = document.getElementById('scene');
+ const rootBox = new Box('rootBox', rootElement).flex();
+
+ scene = (window.scene = new Scene('Validation Pool test', rootBox));
+ scene.withSequenceDiagram();
+ scene.withTable();
+
+ dao = new DAO('DGF', scene);
+
+ experts = [];
+ await newExpert();
+ await newExpert();
+
+ await delayOrWait(DEFAULT_DELAY_MS);
+}
+
+describe('Validation Pool', function tests() {
+ this.timeout(0);
+ before(async () => {
+ await setup();
+ });
+
+ beforeEach(async () => {
+ await scene.sequence.startSection();
+ });
+
+ afterEach(async () => {
+ await scene.sequence.endSection();
+ });
+
+ it('First expert can self-approve', async () => {
+ await scene.sequence.startSection();
+ const { pool } = await experts[0].submitPostWithFee(new PostContent(), {
+ fee: 7,
+ }, {
+ duration: POOL_DURATION_MS,
+ tokenLossRatio: 1,
+ });
+ // Attempting to evaluate winning conditions before the duration has expired
+ // should result in an exception
+ try {
+ await pool.evaluateWinningConditions();
+ } catch (e) {
+ if (e.message.match(/Validation pool duration has not yet elapsed/)) {
+ console.log(
+ 'Caught expected error: Validation pool duration has not yet elapsed',
+ );
+ } else {
+ console.error('Unexpected error');
+ throw e;
+ }
+ }
+ await scene.sequence.endSection();
+ await delayOrWait(POOL_DURATION_MS);
+ await pool.evaluateWinningConditions(); // Vote passes
+ await delayOrWait(DEFAULT_DELAY_MS);
+ });
+
+ it('Failure example: second expert can not self-approve', async () => {
+ try {
+ const { pool } = await experts[1].submitPostWithFee(new PostContent(), {
+ fee: 1,
+ }, {
+ duration: POOL_DURATION_MS,
+ tokenLossRatio: 1,
+ });
+ await delayOrWait(POOL_DURATION_MS);
+ await pool.evaluateWinningConditions(); // Quorum not met!
+ await delayOrWait(DEFAULT_DELAY_MS);
+ } catch (e) {
+ e.message.should.match(/Quorum is not met/);
+ }
+ });
+
+ it('Second expert must be approved by first expert', async () => {
+ const { pool } = await experts[1].submitPostWithFee(new PostContent(), {
+ fee: 1,
+ }, {
+ duration: POOL_DURATION_MS,
+ tokenLossRatio: 1,
+ });
+ await experts[0].stake(pool, {
+ position: true,
+ amount: 4,
+ lockingTime: 0,
+ });
+ await delayOrWait(POOL_DURATION_MS);
+ await pool.evaluateWinningConditions(); // Stake passes
+ await delayOrWait(DEFAULT_DELAY_MS);
+ });
+});
+
+mochaRun();
diff --git a/src/tests/scripts/vm.test.js b/src/tests/scripts/vm.test.js
new file mode 100644
index 0000000..fd2b1df
--- /dev/null
+++ b/src/tests/scripts/vm.test.js
@@ -0,0 +1,75 @@
+import { Actor } from '../../classes/display/actor.js';
+import { Box } from '../../classes/display/box.js';
+import { Scene } from '../../classes/display/scene.js';
+import { VM } from '../../classes/supporting/vm.js';
+import { mochaRun } from '../../util/helpers.js';
+
+const contractIds = ['contract-id-1', 'contract-id-2'];
+
+class Greeter extends Actor {
+ constructor(vm, value, scene) {
+ super('Greeter', scene);
+ this.vm = vm;
+ this.value = value;
+ }
+
+ hello(sender, message) {
+ return `${sender.name} ${this.value}: ${message}`;
+ }
+}
+
+class Repeater extends Actor {
+ constructor(vm, greeter, scene) {
+ super('Repeater', scene);
+ this.vmHandle = vm.getHandle(this);
+ this.greeter = greeter;
+ }
+
+ forward(__sender, method, message) {
+ return this.vmHandle.callContract(this.greeter, method, message);
+ }
+}
+
+describe('VM', function tests() {
+ this.timeout(0);
+
+ let vm;
+ let sender;
+ let vmHandle;
+ let scene;
+
+ before(() => {
+ const rootElement = document.getElementById('scene');
+ const rootBox = new Box('rootBox', rootElement).flex();
+ scene = new Scene('VM test', rootBox).withSequenceDiagram();
+ vm = new VM(scene);
+ sender = new Actor('Sender', scene);
+ vm.addContract(contractIds[0], Greeter, 'world', scene);
+ vm.addContract(contractIds[1], Repeater, contractIds[0], scene);
+ vmHandle = vm.getHandle(sender);
+ });
+
+ beforeEach(async () => {
+ await scene.sequence.startSection();
+ });
+
+ afterEach(async () => {
+ await scene.sequence.endSection();
+ });
+
+ it('Should exist', () => {
+ should.exist(vm);
+ });
+
+ it('Call a contract method', async () => {
+ (await Promise.resolve(vmHandle.callContract(contractIds[0], 'hello', 'good morning')))
+ .should.equal('Sender world: good morning');
+ });
+
+ it('Call a contract method which calls another contract method', async () => {
+ (await Promise.resolve(vmHandle.callContract(contractIds[1], 'forward', 'hello', 'good day')))
+ .should.equal('Repeater world: good day');
+ });
+});
+
+mochaRun();
diff --git a/src/tests/scripts/wdg.test.js b/src/tests/scripts/wdg.test.js
new file mode 100644
index 0000000..44f8c6d
--- /dev/null
+++ b/src/tests/scripts/wdg.test.js
@@ -0,0 +1,68 @@
+import { Box } from '../../classes/display/box.js';
+import { Scene } from '../../classes/display/scene.js';
+import { WeightedDirectedGraph } from '../../classes/supporting/wdg.js';
+import { mochaRun } from '../../util/helpers.js';
+
+const rootElement = document.getElementById('scene');
+const rootBox = new Box('rootBox', rootElement).flex();
+window.scene = new Scene('WDG test', rootBox);
+
+describe('Weighted Directed Acyclic Graph', function tests() {
+ this.timeout(0);
+
+ let graph;
+
+ before(() => {
+ graph = (window.graph = new WeightedDirectedGraph(window.scene)).withFlowchart();
+
+ graph.addVertex('v1', {});
+ graph.addVertex('v1', {});
+ graph.addVertex('v1', {});
+ graph.addVertex('v1', {});
+ graph.addVertex('v1', {});
+
+ graph.addEdge('e1', 0, 1, 1);
+ graph.addEdge('e1', 2, 1, 0.5);
+ graph.addEdge('e1', 3, 1, 0.25);
+ graph.addEdge('e1', 1, 4, 0.125);
+ });
+
+ it('can query for all e1 edges', () => {
+ const edges = graph.getEdges('e1');
+ edges.should.have.length(4);
+ });
+
+ it('can query for all e1 edges from a particular vertex', () => {
+ const edges = graph.getEdges('e1', 2);
+ edges.map(({ from, to, weight }) => [from.id, to.id, weight]).should.have.deep.members([[
+ '2', '1', 0.5,
+ ]]);
+ });
+
+ it('can query for all e1 edges to a particular vertex', () => {
+ const edges = graph.getEdges('e1', null, 1);
+ edges.map(({ from, to, weight }) => [from.id, to.id, weight]).should.have.deep.members([
+ ['0', '1', 1],
+ ['2', '1', 0.5],
+ ['3', '1', 0.25],
+ ]);
+ });
+});
+
+describe('editable', () => {
+ let graph;
+
+ it('should be editable', () => {
+ graph = (window.graph2 = new WeightedDirectedGraph(window.scene, { editable: true })).withFlowchart();
+
+ graph.addVertex('v1', {});
+ graph.addVertex('v2', {});
+ graph.addVertex('v3', {});
+
+ graph.addEdge('e1', 2, 1, 1);
+ graph.addEdge('e2', 1, 0, 0.5);
+ graph.addEdge('e3', 2, 0, 0.25);
+ });
+});
+
+mochaRun();
diff --git a/src/tests/validation-pool.test.html b/src/tests/validation-pool.test.html
new file mode 100644
index 0000000..4dbe0f1
--- /dev/null
+++ b/src/tests/validation-pool.test.html
@@ -0,0 +1,30 @@
+
+
+
+ Validation Pool test
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/vm.test.html b/src/tests/vm.test.html
new file mode 100644
index 0000000..f78597e
--- /dev/null
+++ b/src/tests/vm.test.html
@@ -0,0 +1,26 @@
+
+
+
+ VM
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/tests/wdg.test.html b/src/tests/wdg.test.html
new file mode 100644
index 0000000..bc53e80
--- /dev/null
+++ b/src/tests/wdg.test.html
@@ -0,0 +1,27 @@
+
+
+
+ Weighted Directed Graph test
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/util/constants.js b/src/util/constants.js
new file mode 100644
index 0000000..fbfdb79
--- /dev/null
+++ b/src/util/constants.js
@@ -0,0 +1,14 @@
+export const EPSILON = 2.23e-16;
+
+export const INCINERATOR_ADDRESS = '0';
+
+export const EdgeTypes = {
+ CITATION: 'citation',
+ BALANCE: 'balance',
+ AUTHOR: 'author',
+};
+
+export const VertexTypes = {
+ POST: 'post',
+ AUTHOR: 'author',
+};
diff --git a/src/util/helpers.js b/src/util/helpers.js
new file mode 100644
index 0000000..53ad6ee
--- /dev/null
+++ b/src/util/helpers.js
@@ -0,0 +1,42 @@
+const timers = new Map();
+
+export const debounce = async (fn, delayMs) => {
+ const timer = timers.get(fn);
+ if (timer) {
+ return timer.result;
+ }
+ const result = await fn();
+ timers.set(fn, { result });
+ setTimeout(() => {
+ timers.delete(fn);
+ }, delayMs);
+ return result;
+};
+
+export const delay = async (delayMs) => {
+ await new Promise((resolve) => {
+ setTimeout(resolve, delayMs);
+ });
+};
+
+export const hexToRGB = (input) => {
+ if (input.startsWith('#')) {
+ input = input.slice(1);
+ }
+ const r = parseInt(`${input[0]}${input[1]}`, 16);
+ const g = parseInt(`${input[2]}${input[3]}`, 16);
+ const b = parseInt(`${input[4]}${input[5]}`, 16);
+ return { r, g, b };
+};
+
+export const displayNumber = (value, decimals = 2) => (value.toString().length > decimals + 4
+ ? value.toFixed(decimals)
+ : value);
+
+export const randomID = () => window.crypto.randomUUID().replaceAll('-', '').slice(0, 8);
+
+export const mochaRun = () => {
+ if (mocha._state !== 'running') {
+ mocha.run();
+ }
+};