├── .flowconfig
├── .gitignore
├── LICENSE
├── index.html
├── package.json
├── src
├── hlc.js
├── index.js
└── merkle.js
└── yarn.lock
/.flowconfig:
--------------------------------------------------------------------------------
1 | [ignore]
2 |
3 | [include]
4 |
5 | [libs]
6 |
7 | [lints]
8 |
9 | [options]
10 |
11 | [strict]
12 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .cache
2 | dist
3 | node_modules
4 | .vscode
5 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | Creative Commons Legal Code
2 |
3 | CC0 1.0 Universal
4 |
5 | CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
6 | LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
7 | ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
8 | INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
9 | REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
10 | PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
11 | THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
12 | HEREUNDER.
13 |
14 | Statement of Purpose
15 |
16 | The laws of most jurisdictions throughout the world automatically confer
17 | exclusive Copyright and Related Rights (defined below) upon the creator
18 | and subsequent owner(s) (each and all, an "owner") of an original work of
19 | authorship and/or a database (each, a "Work").
20 |
21 | Certain owners wish to permanently relinquish those rights to a Work for
22 | the purpose of contributing to a commons of creative, cultural and
23 | scientific works ("Commons") that the public can reliably and without fear
24 | of later claims of infringement build upon, modify, incorporate in other
25 | works, reuse and redistribute as freely as possible in any form whatsoever
26 | and for any purposes, including without limitation commercial purposes.
27 | These owners may contribute to the Commons to promote the ideal of a free
28 | culture and the further production of creative, cultural and scientific
29 | works, or to gain reputation or greater distribution for their Work in
30 | part through the use and efforts of others.
31 |
32 | For these and/or other purposes and motivations, and without any
33 | expectation of additional consideration or compensation, the person
34 | associating CC0 with a Work (the "Affirmer"), to the extent that he or she
35 | is an owner of Copyright and Related Rights in the Work, voluntarily
36 | elects to apply CC0 to the Work and publicly distribute the Work under its
37 | terms, with knowledge of his or her Copyright and Related Rights in the
38 | Work and the meaning and intended legal effect of CC0 on those rights.
39 |
40 | 1. Copyright and Related Rights. A Work made available under CC0 may be
41 | protected by copyright and related or neighboring rights ("Copyright and
42 | Related Rights"). Copyright and Related Rights include, but are not
43 | limited to, the following:
44 |
45 | i. the right to reproduce, adapt, distribute, perform, display,
46 | communicate, and translate a Work;
47 | ii. moral rights retained by the original author(s) and/or performer(s);
48 | iii. publicity and privacy rights pertaining to a person's image or
49 | likeness depicted in a Work;
50 | iv. rights protecting against unfair competition in regards to a Work,
51 | subject to the limitations in paragraph 4(a), below;
52 | v. rights protecting the extraction, dissemination, use and reuse of data
53 | in a Work;
54 | vi. database rights (such as those arising under Directive 96/9/EC of the
55 | European Parliament and of the Council of 11 March 1996 on the legal
56 | protection of databases, and under any national implementation
57 | thereof, including any amended or successor version of such
58 | directive); and
59 | vii. other similar, equivalent or corresponding rights throughout the
60 | world based on applicable law or treaty, and any national
61 | implementations thereof.
62 |
63 | 2. Waiver. To the greatest extent permitted by, but not in contravention
64 | of, applicable law, Affirmer hereby overtly, fully, permanently,
65 | irrevocably and unconditionally waives, abandons, and surrenders all of
66 | Affirmer's Copyright and Related Rights and associated claims and causes
67 | of action, whether now known or unknown (including existing as well as
68 | future claims and causes of action), in the Work (i) in all territories
69 | worldwide, (ii) for the maximum duration provided by applicable law or
70 | treaty (including future time extensions), (iii) in any current or future
71 | medium and for any number of copies, and (iv) for any purpose whatsoever,
72 | including without limitation commercial, advertising or promotional
73 | purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
74 | member of the public at large and to the detriment of Affirmer's heirs and
75 | successors, fully intending that such Waiver shall not be subject to
76 | revocation, rescission, cancellation, termination, or any other legal or
77 | equitable action to disrupt the quiet enjoyment of the Work by the public
78 | as contemplated by Affirmer's express Statement of Purpose.
79 |
80 | 3. Public License Fallback. Should any part of the Waiver for any reason
81 | be judged legally invalid or ineffective under applicable law, then the
82 | Waiver shall be preserved to the maximum extent permitted taking into
83 | account Affirmer's express Statement of Purpose. In addition, to the
84 | extent the Waiver is so judged Affirmer hereby grants to each affected
85 | person a royalty-free, non transferable, non sublicensable, non exclusive,
86 | irrevocable and unconditional license to exercise Affirmer's Copyright and
87 | Related Rights in the Work (i) in all territories worldwide, (ii) for the
88 | maximum duration provided by applicable law or treaty (including future
89 | time extensions), (iii) in any current or future medium and for any number
90 | of copies, and (iv) for any purpose whatsoever, including without
91 | limitation commercial, advertising or promotional purposes (the
92 | "License"). The License shall be deemed effective as of the date CC0 was
93 | applied by Affirmer to the Work. Should any part of the License for any
94 | reason be judged legally invalid or ineffective under applicable law, such
95 | partial invalidity or ineffectiveness shall not invalidate the remainder
96 | of the License, and in such case Affirmer hereby affirms that he or she
97 | will not (i) exercise any of his or her remaining Copyright and Related
98 | Rights in the Work or (ii) assert any associated claims and causes of
99 | action with respect to the Work, in either case contrary to Affirmer's
100 | express Statement of Purpose.
101 |
102 | 4. Limitations and Disclaimers.
103 |
104 | a. No trademark or patent rights held by Affirmer are waived, abandoned,
105 | surrendered, licensed or otherwise affected by this document.
106 | b. Affirmer offers the Work as-is and makes no representations or
107 | warranties of any kind concerning the Work, express, implied,
108 | statutory or otherwise, including without limitation warranties of
109 | title, merchantability, fitness for a particular purpose, non
110 | infringement, or the absence of latent or other defects, accuracy, or
111 | the present or absence of errors, whether or not discoverable, all to
112 | the greatest extent permissible under applicable law.
113 | c. Affirmer disclaims responsibility for clearing rights of other persons
114 | that may apply to the Work or any use thereof, including without
115 | limitation any person's Copyright and Related Rights in the Work.
116 | Further, Affirmer disclaims responsibility for obtaining any necessary
117 | consents, permissions or other rights required for any use of the
118 | Work.
119 | d. Affirmer understands and acknowledges that Creative Commons is not a
120 | party to this document and has no duty or obligation with respect to
121 | this CC0 or use of the Work.
122 |
--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "dependencies": {
3 | "flow-bin": "^0.115.0",
4 | "parcel": "^1.12.4",
5 | "react": "^16.0.0",
6 | "react-dom": "^16.12.0"
7 | },
8 | "scripts": {
9 | "start": "parcel index.html"
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/src/hlc.js:
--------------------------------------------------------------------------------
1 | // @flow
2 |
3 | /**
4 | * This implementation of the [Hybric Logical Clocks][1] paper was very much based
5 | * on [this go implementation][2] and [james long's demo][3]
6 | *
7 | * [1]: https://muratbuffalo.blogspot.com/2014/07/hybrid-logical-clocks.html
8 | * [2]: https://github.com/lafikl/hlc/blob/master/hlc.go
9 | * [3]: https://github.com/jlongster/crdt-example-app/blob/master/shared/timestamp.js
10 | */
11 |
12 | export type HLC = {
13 | ts: number,
14 | count: number,
15 | node: string,
16 | };
17 |
18 | export const pack = ({ ts, count, node }: HLC) => {
19 | // 13 digits is enough for the next 100 years, so this is probably fine
20 | return (
21 | ts.toString().padStart(15, '0') +
22 | ':' +
23 | count.toString(36).padStart(5, '0') +
24 | ':' +
25 | node
26 | );
27 | };
28 |
29 | export const unpack = (serialized: string) => {
30 | const [ts, count, ...node] = serialized.split(':');
31 | return {
32 | ts: parseInt(ts),
33 | count: parseInt(count, 36),
34 | node: node.join(':'),
35 | };
36 | };
37 |
38 | export const init = (node: string, now: number): HLC => ({
39 | ts: now,
40 | count: 0,
41 | node,
42 | });
43 |
44 | export const cmp = (one: HLC, two: HLC) => {
45 | if (one.ts == two.ts) {
46 | if (one.count === two.count) {
47 | if (one.node === two.node) {
48 | return 0;
49 | }
50 | return one.node < two.node ? -1 : 1;
51 | }
52 | return one.count - two.count;
53 | }
54 | return one.ts - two.ts;
55 | };
56 |
57 | export const inc = (local: HLC, now: number): HLC => {
58 | if (now > local.ts) {
59 | return { ts: now, count: 0, node: local.node };
60 | }
61 |
62 | return { ...local, count: local.count + 1 };
63 | };
64 |
65 | export const recv = (local: HLC, remote: HLC, now: number): HLC => {
66 | if (now > local.ts && now > remote.ts) {
67 | return { ...local, ts: now, count: 0 };
68 | }
69 |
70 | if (local.ts === remote.ts) {
71 | return { ...local, count: Math.max(local.count, remote.count) + 1 };
72 | } else if (local.ts > remote.ts) {
73 | return { ...local, count: local.count + 1 };
74 | } else {
75 | return { ...local, ts: remote.ts, count: remote.count + 1 };
76 | }
77 | };
78 |
79 | // This impl is closer to the article's algorithm, but I find it a little trickier to explain.
80 | // export const recv = (time: HLC, remote: HLC, now: number): HLC => {
81 | // const node = time.node;
82 | // const ts = Math.max(time.ts, remote.ts, now);
83 | // if (ts == time.ts && ts == remote.ts) {
84 | // return { node, ts, count: Math.max(time.count, remote.count) + 1 };
85 | // }
86 | // if (ts == time.ts) {
87 | // return { node, ts, count: time.count + 1 };
88 | // }
89 | // if (ts == remote.ts) {
90 | // return { node, ts, count: remote.count + 1 };
91 | // }
92 | // return { node, ts, count: 0 };
93 | // };
94 |
95 | const validate = (time: HLC, now: number, maxDrift: number = 60 * 1000) => {
96 | if (time.count > Math.pow(36,5)) {
97 | return 'counter-overflow';
98 | }
99 | // if a timestamp is more than 1 minute off from our local wall clock, something has gone horribly wrong.
100 | if (Math.abs(time.ts - now) > maxDrift) {
101 | return 'clock-off';
102 | }
103 | return null;
104 | };
105 |
--------------------------------------------------------------------------------
/src/index.js:
--------------------------------------------------------------------------------
1 | // @flow
2 | import React from 'react';
3 | import { render } from 'react-dom';
4 |
5 | import * as hlc from './hlc';
6 | import type { HLC } from './hlc';
7 |
8 | type State = {|
9 | nodes: { [key: string]: NodeT },
10 | trueIdx: number,
11 | |};
12 |
13 | type NodeT = {|
14 | id: string,
15 | clock: HLC,
16 | events: Array,
17 | now: number,
18 | counter: number,
19 | |};
20 | type Event = {|
21 | id: string,
22 | clock: HLC,
23 | trueIdx: number,
24 | |};
25 |
26 | const createNode = nodeId => {
27 | return {
28 | id: nodeId,
29 | clock: hlc.init(nodeId, 499),
30 | events: [],
31 | now: 500,
32 | counter: 1,
33 | };
34 | };
35 |
36 | const hoursMinutes = ts => `${Math.floor(ts / 60)}:${ts % 60}`;
37 |
38 | const toString = ({ ts, count, node }: HLC) =>
39 | `${hoursMinutes(ts)} - ${count} - ${node}`;
40 |
41 | const initial = {
42 | nodes: { a: createNode('a'), b: createNode('b'), c: createNode('c') },
43 | trueIdx: 0,
44 | };
45 |
46 | const compareEvents = (one: Event, two: Event) => hlc.cmp(one.clock, two.clock);
47 |
48 | const addEvent = (node: NodeT, trueIdx: number): NodeT => {
49 | const clock = hlc.inc(node.clock, node.now);
50 | const event = { id: node.id + node.counter, clock, trueIdx };
51 | const events = node.events.concat([event]);
52 | return { ...node, counter: node.counter + 1, clock, events };
53 | };
54 |
55 | type Action =
56 | | { type: 'set-clock', node: string, now: number }
57 | | { type: 'send', clock: HLC, src: string, dest: string }
58 | | { type: 'event', nodes: Array };
59 |
60 | const reducer = (state: State, action: Action) => {
61 | switch (action.type) {
62 | case 'set-clock':
63 | return {
64 | ...state,
65 | nodes: {
66 | ...state.nodes,
67 | [action.node]: {
68 | ...state.nodes[action.node],
69 | now: action.now,
70 | },
71 | },
72 | };
73 | case 'event':
74 | const trueIdx = state.trueIdx;
75 | const res = {
76 | ...state,
77 | nodes: { ...state.nodes },
78 | trueIdx: trueIdx + 1,
79 | };
80 | action.nodes.forEach(nid => {
81 | res.nodes[nid] = addEvent(res.nodes[nid], trueIdx);
82 | });
83 | Object.keys(res.nodes).forEach(nid => {
84 | res.nodes[nid] = {
85 | ...res.nodes[nid],
86 | now: res.nodes[nid].now + 1,
87 | };
88 | });
89 | return res;
90 | case 'send':
91 | const res2 = { ...state, nodes: { ...state.nodes } };
92 | res2.nodes[action.dest] = {
93 | ...res2.nodes[action.dest],
94 | clock: hlc.recv(
95 | res2.nodes[action.dest].clock,
96 | action.clock,
97 | res2.nodes[action.dest].now,
98 | ),
99 | };
100 | return res2;
101 | }
102 | return state;
103 | };
104 |
105 | const Node = ({ node, setClock, addEvent, ids, send }) => {
106 | return (
107 |