Remove library files into crdt-meta.
This commit is contained in:
Spencer Ofwiti
@@ -1,191 +0,0 @@
|
||||
import * as pgp from 'openpgp';
|
||||
import * as crypto from 'crypto';
|
||||
|
||||
interface Signable {
|
||||
digest():string;
|
||||
}
|
||||
|
||||
type KeyGetter = () => any;
|
||||
|
||||
type Signature = {
|
||||
engine:string
|
||||
algo:string
|
||||
data:string
|
||||
digest:string
|
||||
}
|
||||
|
||||
interface Signer {
|
||||
prepare(Signable):boolean;
|
||||
onsign(Signature):void;
|
||||
onverify(boolean):void;
|
||||
sign(digest:string):void
|
||||
verify(digest:string, signature:Signature):void
|
||||
fingerprint():string
|
||||
}
|
||||
|
||||
interface Authoritative {
|
||||
}
|
||||
|
||||
interface KeyStore {
|
||||
getPrivateKey: KeyGetter
|
||||
getFingerprint: () => string
|
||||
getTrustedKeys: () => Array<any>
|
||||
getTrustedActiveKeys: () => Array<any>
|
||||
getEncryptKeys: () => Array<any>
|
||||
}
|
||||
|
||||
class PGPKeyStore implements KeyStore {
|
||||
|
||||
fingerprint: string
|
||||
pk: any
|
||||
|
||||
pubk = {
|
||||
active: [],
|
||||
trusted: [],
|
||||
encrypt: [],
|
||||
}
|
||||
loads = 0x00;
|
||||
loadsTarget = 0x0f;
|
||||
onload: (k:KeyStore) => void;
|
||||
|
||||
constructor(passphrase:string, pkArmor:string, pubkActiveArmor:string, pubkTrustedArmor:string, pubkEncryptArmor:string, onload = (ks:KeyStore) => {}) {
|
||||
this._readKey(pkArmor, undefined, 1, passphrase);
|
||||
this._readKey(pubkActiveArmor, 'active', 2);
|
||||
this._readKey(pubkTrustedArmor, 'trusted', 4);
|
||||
this._readKey(pubkEncryptArmor, 'encrypt', 8);
|
||||
this.onload = onload;
|
||||
}
|
||||
|
||||
private _readKey(a:string, x:any, n:number, pass?:string) {
|
||||
pgp.key.readArmored(a).then((k) => {
|
||||
if (pass !== undefined) {
|
||||
this.pk = k.keys[0];
|
||||
this.pk.decrypt(pass).then(() => {
|
||||
this.fingerprint = this.pk.getFingerprint();
|
||||
console.log('private key (sign)', this.fingerprint);
|
||||
this._registerLoad(n);
|
||||
});
|
||||
} else {
|
||||
this.pubk[x] = k.keys;
|
||||
k.keys.forEach((pubk) => {
|
||||
console.log('public key (' + x + ')', pubk.getFingerprint());
|
||||
});
|
||||
this._registerLoad(n);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
private _registerLoad(b:number) {
|
||||
this.loads |= b;
|
||||
if (this.loads == this.loadsTarget) {
|
||||
this.onload(this);
|
||||
}
|
||||
}
|
||||
|
||||
public getTrustedKeys(): Array<any> {
|
||||
return this.pubk['trusted'];
|
||||
}
|
||||
|
||||
public getTrustedActiveKeys(): Array<any> {
|
||||
return this.pubk['active'];
|
||||
|
||||
}
|
||||
|
||||
public getEncryptKeys(): Array<any> {
|
||||
return this.pubk['encrypt'];
|
||||
|
||||
}
|
||||
|
||||
public getPrivateKey(): any {
|
||||
return this.pk;
|
||||
}
|
||||
|
||||
public getFingerprint(): string {
|
||||
return this.fingerprint;
|
||||
}
|
||||
}
|
||||
|
||||
class PGPSigner implements Signer {
|
||||
|
||||
engine = 'pgp'
|
||||
algo = 'sha256'
|
||||
dgst: string
|
||||
signature: Signature
|
||||
keyStore: KeyStore
|
||||
onsign: (Signature) => void
|
||||
onverify: (boolean) => void
|
||||
|
||||
constructor(keyStore:KeyStore) {
|
||||
this.keyStore = keyStore
|
||||
this.onsign = (string) => {};
|
||||
this.onverify = (boolean) => {};
|
||||
}
|
||||
|
||||
public fingerprint(): string {
|
||||
return this.keyStore.getFingerprint();
|
||||
}
|
||||
|
||||
public prepare(material:Signable):boolean {
|
||||
this.dgst = material.digest();
|
||||
return true;
|
||||
}
|
||||
|
||||
public verify(digest:string, signature:Signature) {
|
||||
pgp.signature.readArmored(signature.data).then((s) => {
|
||||
const opts = {
|
||||
message: pgp.cleartext.fromText(digest),
|
||||
publicKeys: this.keyStore.getTrustedKeys(),
|
||||
signature: s,
|
||||
};
|
||||
pgp.verify(opts).then((v) => {
|
||||
let i = 0;
|
||||
for (i = 0; i < v.signatures.length; i++) {
|
||||
const s = v.signatures[i];
|
||||
if (s.valid) {
|
||||
this.onverify(s);
|
||||
return;
|
||||
}
|
||||
}
|
||||
console.error('checked ' + i + ' signature(s) but none valid');
|
||||
this.onverify(false);
|
||||
});
|
||||
}).catch((e) => {
|
||||
console.error(e);
|
||||
this.onverify(false);
|
||||
});
|
||||
}
|
||||
|
||||
public sign(digest:string) {
|
||||
const m = pgp.cleartext.fromText(digest);
|
||||
const pk = this.keyStore.getPrivateKey();
|
||||
const opts = {
|
||||
message: m,
|
||||
privateKeys: [pk],
|
||||
detached: true,
|
||||
}
|
||||
pgp.sign(opts).then((s) => {
|
||||
this.signature = {
|
||||
engine: this.engine,
|
||||
algo: this.algo,
|
||||
data: s.signature,
|
||||
// TODO: fix for browser later
|
||||
digest: digest,
|
||||
};
|
||||
this.onsign(this.signature);
|
||||
}).catch((e) => {
|
||||
console.error(e);
|
||||
this.onsign(undefined);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
export {
|
||||
Signature,
|
||||
Authoritative,
|
||||
Signer,
|
||||
KeyGetter,
|
||||
Signable,
|
||||
KeyStore,
|
||||
PGPSigner,
|
||||
PGPKeyStore,
|
||||
};
|
||||
@@ -1,71 +0,0 @@
|
||||
import * as fs from 'fs';
|
||||
import * as ini from 'ini';
|
||||
import * as path from 'path';
|
||||
|
||||
class Config {
|
||||
|
||||
filepath: string
|
||||
store: Object
|
||||
censor: Array<string>
|
||||
require: Array<string>
|
||||
env_prefix: string
|
||||
|
||||
constructor(filepath:string, env_prefix?:string) {
|
||||
this.filepath = filepath;
|
||||
this.store = {};
|
||||
this.censor = [];
|
||||
this.require = [];
|
||||
this.env_prefix = '';
|
||||
if (env_prefix !== undefined) {
|
||||
this.env_prefix = env_prefix + "_";
|
||||
}
|
||||
}
|
||||
|
||||
public process() {
|
||||
const d = fs.readdirSync(this.filepath);
|
||||
|
||||
const r = /.*\.ini$/;
|
||||
for (let i = 0; i < d.length; i++) {
|
||||
const f = d[i];
|
||||
if (!f.match(r)) {
|
||||
return;
|
||||
}
|
||||
|
||||
const fp = path.join(this.filepath, f);
|
||||
const v = fs.readFileSync(fp, 'utf-8');
|
||||
const inid = ini.decode(v);
|
||||
const inik = Object.keys(inid);
|
||||
for (let j = 0; j < inik.length; j++) {
|
||||
const k_section = inik[j]
|
||||
const k = k_section.toUpperCase();
|
||||
Object.keys(inid[k_section]).forEach((k_directive) => {
|
||||
const kk = k_directive.toUpperCase();
|
||||
const kkk = k + '_' + kk;
|
||||
|
||||
let r = inid[k_section][k_directive];
|
||||
const k_env = this.env_prefix + kkk
|
||||
const env = process.env[k_env];
|
||||
if (env !== undefined) {
|
||||
console.debug('Environment variable ' + k_env + ' overrides ' + kkk);
|
||||
r = env;
|
||||
}
|
||||
this.store[kkk] = r;
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public get(s:string) {
|
||||
return this.store[s];
|
||||
}
|
||||
|
||||
public toString() {
|
||||
let s = '';
|
||||
Object.keys(this.store).forEach((k) => {
|
||||
s += k + '=' + this.store[k] + '\n';
|
||||
});
|
||||
return s;
|
||||
}
|
||||
}
|
||||
|
||||
export { Config };
|
||||
@@ -1,38 +0,0 @@
|
||||
import { JSONSerializable } from './format';
|
||||
|
||||
const ENGINE_NAME = 'automerge';
|
||||
const ENGINE_VERSION = '0.14.1';
|
||||
|
||||
const NETWORK_NAME = 'cic';
|
||||
const NETWORK_VERSION = '1';
|
||||
|
||||
const CRYPTO_NAME = 'pgp';
|
||||
const CRYPTO_VERSION = '2';
|
||||
|
||||
type VersionedSpec = {
|
||||
name: string
|
||||
version: string
|
||||
ext?: Object
|
||||
}
|
||||
|
||||
const engineSpec:VersionedSpec = {
|
||||
name: ENGINE_NAME,
|
||||
version: ENGINE_VERSION,
|
||||
}
|
||||
|
||||
const cryptoSpec:VersionedSpec = {
|
||||
name: CRYPTO_NAME,
|
||||
version: CRYPTO_VERSION,
|
||||
}
|
||||
|
||||
const networkSpec:VersionedSpec = {
|
||||
name: NETWORK_NAME,
|
||||
version: NETWORK_VERSION,
|
||||
}
|
||||
|
||||
export {
|
||||
engineSpec,
|
||||
cryptoSpec,
|
||||
networkSpec,
|
||||
VersionedSpec,
|
||||
};
|
||||
@@ -1,27 +0,0 @@
|
||||
import * as crypto from 'crypto';
|
||||
|
||||
const _algs = {
|
||||
'SHA-256': 'sha256',
|
||||
}
|
||||
|
||||
function cryptoWrapper() {
|
||||
}
|
||||
|
||||
cryptoWrapper.prototype.digest = async function(s, d) {
|
||||
const h = crypto.createHash(_algs[s]);
|
||||
h.update(d);
|
||||
return h.digest();
|
||||
}
|
||||
|
||||
let subtle = undefined;
|
||||
if (typeof window !== 'undefined') {
|
||||
subtle = window.crypto.subtle;
|
||||
} else {
|
||||
subtle = new cryptoWrapper();
|
||||
}
|
||||
|
||||
|
||||
export {
|
||||
subtle,
|
||||
}
|
||||
|
||||
@@ -1,90 +0,0 @@
|
||||
import * as pg from 'pg';
|
||||
import * as sqlite from 'sqlite3';
|
||||
|
||||
type DbConfig = {
|
||||
name: string
|
||||
host: string
|
||||
port: number
|
||||
user: string
|
||||
password: string
|
||||
}
|
||||
|
||||
interface DbAdapter {
|
||||
query: (s:string, callback:(e:any, rs:any) => void) => void
|
||||
close: () => void
|
||||
}
|
||||
|
||||
const re_creatematch = /^(CREATE)/i
|
||||
const re_getmatch = /^(SELECT)/i;
|
||||
const re_setmatch = /^(INSERT|UPDATE)/i;
|
||||
|
||||
class SqliteAdapter implements DbAdapter {
|
||||
|
||||
db: any
|
||||
|
||||
constructor(dbConfig:DbConfig, callback?:(any) => void) {
|
||||
this.db = new sqlite.Database(dbConfig.name); //, callback);
|
||||
}
|
||||
|
||||
public query(s:string, callback:(e:any, rs?:any) => void): void {
|
||||
const local_callback = (e, rs) => {
|
||||
let r = undefined;
|
||||
if (rs !== undefined) {
|
||||
r = {
|
||||
rowCount: rs.length,
|
||||
rows: rs,
|
||||
}
|
||||
}
|
||||
callback(e, r);
|
||||
};
|
||||
if (s.match(re_getmatch)) {
|
||||
this.db.all(s, local_callback);
|
||||
} else if (s.match(re_setmatch)) {
|
||||
this.db.run(s, local_callback);
|
||||
} else if (s.match(re_creatematch)) {
|
||||
this.db.run(s, callback);
|
||||
} else {
|
||||
throw 'unhandled query';
|
||||
}
|
||||
}
|
||||
|
||||
public close() {
|
||||
this.db.close();
|
||||
}
|
||||
}
|
||||
|
||||
class PostgresAdapter implements DbAdapter {
|
||||
|
||||
db: any
|
||||
|
||||
constructor(dbConfig:DbConfig) {
|
||||
let o = dbConfig;
|
||||
o['database'] = o.name;
|
||||
this.db = new pg.Pool(o);
|
||||
return this.db;
|
||||
}
|
||||
|
||||
public query(s:string, callback:(e:any, rs:any) => void): void {
|
||||
this.db.query(s, (e, rs) => {
|
||||
let r = {
|
||||
length: rs.rowCount,
|
||||
}
|
||||
rs.length = rs.rowCount;
|
||||
if (e === undefined) {
|
||||
e = null;
|
||||
}
|
||||
console.debug(e, rs);
|
||||
callback(e, rs);
|
||||
});
|
||||
}
|
||||
|
||||
public close() {
|
||||
this.db.end();
|
||||
}
|
||||
}
|
||||
|
||||
export {
|
||||
DbConfig,
|
||||
SqliteAdapter,
|
||||
PostgresAdapter,
|
||||
}
|
||||
@@ -1,68 +0,0 @@
|
||||
import * as crypto from './crypto';
|
||||
|
||||
interface Addressable {
|
||||
key(): string
|
||||
digest(): string
|
||||
}
|
||||
|
||||
function stringToBytes(s:string) {
|
||||
const a = new Uint8Array(20);
|
||||
let j = 2;
|
||||
for (let i = 0; i < a.byteLength; i++) {
|
||||
const n = parseInt(s.substring(j, j+2), 16);
|
||||
a[i] = n;
|
||||
j += 2;
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
function bytesToHex(a:Uint8Array) {
|
||||
let s = '';
|
||||
for (let i = 0; i < a.byteLength; i++) {
|
||||
const h = '00' + a[i].toString(16);
|
||||
s += h.slice(-2);
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
async function mergeKey(a:Uint8Array, s:Uint8Array) {
|
||||
const y = new Uint8Array(a.byteLength + s.byteLength);
|
||||
for (let i = 0; i < a.byteLength; i++) {
|
||||
y[i] = a[i];
|
||||
}
|
||||
for (let i = 0; i < s.byteLength; i++) {
|
||||
y[a.byteLength + i] = s[i];
|
||||
}
|
||||
const z = await crypto.subtle.digest('SHA-256', y);
|
||||
return bytesToHex(new Uint8Array(z));
|
||||
}
|
||||
|
||||
async function toKey(v:string, salt:string) {
|
||||
const a = stringToBytes(v);
|
||||
const s = new TextEncoder().encode(salt);
|
||||
return await mergeKey(a, s);
|
||||
}
|
||||
|
||||
|
||||
async function toAddressKey(zeroExHex:string, salt:string) {
|
||||
const a = addressToBytes(zeroExHex);
|
||||
const s = new TextEncoder().encode(salt);
|
||||
return await mergeKey(a, s);
|
||||
}
|
||||
|
||||
const re_addrHex = /^0[xX][a-fA-F0-9]{40}$/;
|
||||
function addressToBytes(s:string) {
|
||||
if (!s.match(re_addrHex)) {
|
||||
throw 'invalid address hex';
|
||||
}
|
||||
return stringToBytes(s);
|
||||
}
|
||||
|
||||
export {
|
||||
toKey,
|
||||
toAddressKey,
|
||||
mergeKey,
|
||||
bytesToHex,
|
||||
addressToBytes,
|
||||
Addressable,
|
||||
}
|
||||
@@ -1,58 +0,0 @@
|
||||
import { v4 as uuidv4 } from 'uuid';
|
||||
import { Syncable } from './sync';
|
||||
import { Store } from './store';
|
||||
import { PubSub } from './transport';
|
||||
|
||||
function toIndexKey(id:string):string {
|
||||
const d = Date.now();
|
||||
return d + '_' + id + '_' + uuidv4();
|
||||
}
|
||||
|
||||
const _re_indexKey = /^\d+_(.+)_[-\d\w]+$/;
|
||||
function fromIndexKey(s:string):string {
|
||||
const m = s.match(_re_indexKey);
|
||||
if (m === null) {
|
||||
throw 'Invalid index key';
|
||||
}
|
||||
return m[1];
|
||||
}
|
||||
|
||||
class Dispatcher {
|
||||
|
||||
idx: Array<string>
|
||||
syncer: PubSub
|
||||
store: Store
|
||||
|
||||
constructor(store:Store, syncer:PubSub) {
|
||||
this.idx = new Array<string>()
|
||||
this.syncer = syncer;
|
||||
this.store = store;
|
||||
}
|
||||
|
||||
public isDirty(): boolean {
|
||||
return this.idx.length > 0;
|
||||
}
|
||||
|
||||
public add(id:string, item:Syncable): string {
|
||||
const v = item.toJSON();
|
||||
const k = toIndexKey(id);
|
||||
this.store.put(k, v, true);
|
||||
localStorage.setItem(k, v);
|
||||
this.idx.push(k);
|
||||
return k;
|
||||
}
|
||||
|
||||
public sync(offset:number): number {
|
||||
let i = 0;
|
||||
this.idx.forEach((k) => {
|
||||
const v = localStorage.getItem(k);
|
||||
const k_id = fromIndexKey(k);
|
||||
this.syncer.pub(v); // this must block until guaranteed delivery
|
||||
localStorage.removeItem(k);
|
||||
i++;
|
||||
});
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
export { Dispatcher, toIndexKey, fromIndexKey }
|
||||
@@ -1,5 +0,0 @@
|
||||
interface JSONSerializable {
|
||||
toJSON(): string
|
||||
}
|
||||
|
||||
export { JSONSerializable };
|
||||
@@ -1,5 +1,2 @@
|
||||
export { PGPSigner, PGPKeyStore, Signer, KeyStore } from './auth';
|
||||
export { ArgPair, Envelope, Syncable } from './sync';
|
||||
export { User } from './assets/user';
|
||||
export { Phone } from './assets/phone';
|
||||
export { Config } from './config';
|
||||
export { User } from './user';
|
||||
export { Phone } from './phone';
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
import { ArgPair, Syncable } from '../sync';
|
||||
import { Addressable, mergeKey } from '../digest';
|
||||
import { Syncable, Addressable, mergeKey } from 'crdt-meta';
|
||||
|
||||
class Phone extends Syncable implements Addressable {
|
||||
|
||||
@@ -1,9 +0,0 @@
|
||||
import { Syncable } from './sync';
|
||||
|
||||
interface Store {
|
||||
put(string, Syncable, boolean?)
|
||||
get(string):Syncable
|
||||
delete(string)
|
||||
}
|
||||
|
||||
export { Store };
|
||||
@@ -1,266 +0,0 @@
|
||||
import * as Automerge from 'automerge';
|
||||
|
||||
import { JSONSerializable } from './format';
|
||||
|
||||
import { Authoritative, Signer, PGPSigner, Signable, Signature } from './auth';
|
||||
|
||||
import { engineSpec, cryptoSpec, networkSpec, VersionedSpec } from './constants';
|
||||
|
||||
const fullSpec:VersionedSpec = {
|
||||
name: 'cic',
|
||||
version: '1',
|
||||
ext: {
|
||||
network: cryptoSpec,
|
||||
engine: engineSpec,
|
||||
},
|
||||
}
|
||||
|
||||
class Envelope {
|
||||
|
||||
o = fullSpec
|
||||
|
||||
constructor(payload:Object) {
|
||||
this.set(payload);
|
||||
}
|
||||
|
||||
public set(payload:Object) {
|
||||
this.o['payload'] = payload
|
||||
}
|
||||
|
||||
public get():string {
|
||||
return this.o['payload'];
|
||||
}
|
||||
|
||||
public toJSON() {
|
||||
return JSON.stringify(this.o);
|
||||
}
|
||||
|
||||
public static fromJSON(s:string): Envelope {
|
||||
const e = new Envelope(undefined);
|
||||
e.o = JSON.parse(s);
|
||||
return e;
|
||||
}
|
||||
|
||||
public unwrap(): Syncable {
|
||||
return Syncable.fromJSON(this.o['payload']);
|
||||
}
|
||||
}
|
||||
|
||||
class ArgPair {
|
||||
|
||||
k:string
|
||||
v:any
|
||||
|
||||
constructor(k:string, v:any) {
|
||||
this.k = k;
|
||||
this.v = v;
|
||||
}
|
||||
}
|
||||
|
||||
class SignablePart implements Signable {
|
||||
|
||||
s: string
|
||||
|
||||
constructor(s:string) {
|
||||
this.s = s;
|
||||
}
|
||||
|
||||
public digest():string {
|
||||
return this.s;
|
||||
}
|
||||
}
|
||||
|
||||
function orderDict(src) {
|
||||
let dst;
|
||||
if (Array.isArray(src)) {
|
||||
dst = [];
|
||||
src.forEach((v) => {
|
||||
if (typeof(v) == 'object') {
|
||||
v = orderDict(v);
|
||||
}
|
||||
dst.push(v);
|
||||
});
|
||||
} else {
|
||||
dst = {}
|
||||
Object.keys(src).sort().forEach((k) => {
|
||||
let v = src[k];
|
||||
if (typeof(v) == 'object') {
|
||||
v = orderDict(v);
|
||||
}
|
||||
dst[k] = v;
|
||||
});
|
||||
}
|
||||
return dst;
|
||||
}
|
||||
|
||||
class Syncable implements JSONSerializable, Authoritative, Signable {
|
||||
|
||||
id: string
|
||||
timestamp: number
|
||||
m: any // automerge object
|
||||
e: Envelope
|
||||
signer: Signer
|
||||
onwrap: (string) => void
|
||||
onauthenticate: (boolean) => void
|
||||
|
||||
// TODO: Move data to sub-object so timestamp, id, signature don't collide
|
||||
constructor(id:string, v:Object) {
|
||||
this.id = id;
|
||||
const o = {
|
||||
'id': id,
|
||||
'timestamp': Math.floor(Date.now() / 1000),
|
||||
'data': v,
|
||||
}
|
||||
//this.m = Automerge.from(v)
|
||||
this.m = Automerge.from(o)
|
||||
}
|
||||
|
||||
public setSigner(signer:Signer) {
|
||||
this.signer = signer;
|
||||
this.signer.onsign = (s) => {
|
||||
this.wrap(s);
|
||||
};
|
||||
}
|
||||
|
||||
// TODO: To keep integrity, the non-link key/value pairs for each step also need to be hashed
|
||||
public digest(): string {
|
||||
const links = [];
|
||||
Automerge.getAllChanges(this.m).forEach((ch:Object) => {
|
||||
const op:Array<any> = ch['ops'];
|
||||
ch['ops'].forEach((op:Array<Object>) => {
|
||||
if (op['action'] == 'link') {
|
||||
//console.log('op link', op);
|
||||
links.push([op['obj'], op['value']]);
|
||||
}
|
||||
});
|
||||
});
|
||||
//return JSON.stringify(links);
|
||||
const j = JSON.stringify(links);
|
||||
return Buffer.from(j).toString('base64');
|
||||
}
|
||||
|
||||
private wrap(s:any) {
|
||||
this.m = Automerge.change(this.m, 'sign', (doc) => {
|
||||
doc['signature'] = s;
|
||||
});
|
||||
this.e = new Envelope(this.toJSON());
|
||||
console.log('wrappin s', s, typeof(s));
|
||||
this.e.o['digest'] = s.digest;
|
||||
if (this.onwrap !== undefined) {
|
||||
this.onwrap(this.e);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// private _verifyLoop(i:number, history:Array<any>, signable:Signable, result:boolean) {
|
||||
// if (!result) {
|
||||
// this.onauthenticate(false);
|
||||
// return;
|
||||
// } else if (history.length == 0) {
|
||||
// this.onauthenticate(true);
|
||||
// return;
|
||||
// }
|
||||
// const h = history.shift()
|
||||
// if (i % 2 == 0) {
|
||||
// i++;
|
||||
// signable = {
|
||||
// digest: () => {
|
||||
// return Automerge.save(h.snapshot)
|
||||
// },
|
||||
// };
|
||||
// this._verifyLoop(i, history, signable, true);
|
||||
// } else {
|
||||
// i++;
|
||||
// const signature = h.snapshot['signature'];
|
||||
// console.debug('signature', signature, signable.digest());
|
||||
// this.signer.onverify = (v) => {
|
||||
// this._verifyLoop(i, history, signable, v)
|
||||
// }
|
||||
// this.signer.verify(signable, signature);
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// // TODO: This should replay the graph and check signatures on each step
|
||||
// public _authenticate(full:boolean=false) {
|
||||
// let h = Automerge.getHistory(this.m);
|
||||
// h.forEach((m) => {
|
||||
// //console.debug(m.snapshot);
|
||||
// });
|
||||
// const signable = {
|
||||
// digest: () => { return '' },
|
||||
// }
|
||||
// if (!full) {
|
||||
// h = h.slice(h.length-2);
|
||||
// }
|
||||
// this._verifyLoop(0, h, signable, true);
|
||||
// }
|
||||
|
||||
public authenticate(full:boolean=false) {
|
||||
if (full) {
|
||||
console.warn('only doing shallow authentication for now, sorry');
|
||||
}
|
||||
//console.log('authenticating', signable.digest());
|
||||
//console.log('signature', this.m.signature);
|
||||
this.signer.onverify = (v) => {
|
||||
//this._verifyLoop(i, history, signable, v)
|
||||
this.onauthenticate(v);
|
||||
}
|
||||
this.signer.verify(this.m.signature.digest, this.m.signature);
|
||||
}
|
||||
|
||||
|
||||
public sign() {
|
||||
//this.signer.prepare(this);
|
||||
this.signer.sign(this.digest());
|
||||
}
|
||||
|
||||
public update(changes:Array<ArgPair>, changesDescription:string) {
|
||||
this.m = Automerge.change(this.m, changesDescription, (m) => {
|
||||
changes.forEach((c) => {
|
||||
let path = c.k.split('.');
|
||||
let target = m['data'];
|
||||
while (path.length > 1) {
|
||||
const part = path.shift();
|
||||
target = target[part];
|
||||
}
|
||||
target[path[0]] = c.v;
|
||||
});
|
||||
m['timestamp'] = Math.floor(Date.now() / 1000);
|
||||
});
|
||||
}
|
||||
|
||||
public replace(o:Object, changesDescription:string) {
|
||||
this.m = Automerge.change(this.m, changesDescription, (m) => {
|
||||
Object.keys(o).forEach((k) => {
|
||||
m['data'][k] = o[k];
|
||||
});
|
||||
Object.keys(m).forEach((k) => {
|
||||
if (o[k] == undefined) {
|
||||
delete m['data'][k];
|
||||
}
|
||||
});
|
||||
m['timestamp'] = Math.floor(Date.now() / 1000);
|
||||
});
|
||||
}
|
||||
|
||||
public merge(s:Syncable) {
|
||||
this.m = Automerge.merge(s.m, this.m);
|
||||
}
|
||||
|
||||
public toJSON(): string {
|
||||
const s = Automerge.save(this.m);
|
||||
const o = JSON.parse(s);
|
||||
const oo = orderDict(o)
|
||||
return JSON.stringify(oo);
|
||||
|
||||
}
|
||||
|
||||
public static fromJSON(s:string): Syncable {
|
||||
const doc = Automerge.load(s);
|
||||
let y = new Syncable(doc['id'], {});
|
||||
y.m = doc
|
||||
return y
|
||||
}
|
||||
}
|
||||
|
||||
export { JSONSerializable, Syncable, ArgPair, Envelope };
|
||||
@@ -1,11 +0,0 @@
|
||||
interface SubConsumer {
|
||||
post(string)
|
||||
}
|
||||
|
||||
interface PubSub {
|
||||
pub(v:string):boolean
|
||||
close()
|
||||
}
|
||||
|
||||
export { PubSub, SubConsumer };
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
import { ArgPair, Syncable } from '../sync';
|
||||
import { Addressable, addressToBytes, bytesToHex, toAddressKey } from '../digest';
|
||||
import { Syncable, Addressable, toAddressKey } from 'crdt-meta';
|
||||
|
||||
const keySalt = new TextEncoder().encode(':cic.person');
|
||||
class User extends Syncable implements Addressable {
|
||||
Reference in New Issue
Block a user