cojson 0.0.7 → 0.0.8

package/dist/contentType.test.mjs

@@ -1,179 +0,0 @@
-"use strict";
-import {
-  agentIDfromSessionID,
-  getAgent,
-  getAgentID,
-  newRandomAgentCredential,
-  newRandomSessionID
-} from "./coValue";
-import { createdNowUnique } from "./crypto";
-import { LocalNode } from "./node";
-test("Empty COJSON Map works", () => {
-  const agentCredential = newRandomAgentCredential("agent1");
-  const node = new LocalNode(
-    agentCredential,
-    newRandomSessionID(getAgentID(getAgent(agentCredential)))
-  );
-  const coValue = node.createCoValue({
-    type: "comap",
-    ruleset: { type: "unsafeAllowAll" },
-    meta: null,
-    ...createdNowUnique()
-  });
-  const content = coValue.getCurrentContent();
-  if (content.type !== "comap") {
-    throw new Error("Expected map");
-  }
-  expect(content.type).toEqual("comap");
-  expect([...content.keys()]).toEqual([]);
-  expect(content.toJSON()).toEqual({});
-});
-test("Can insert and delete Map entries in edit()", () => {
-  const agentCredential = newRandomAgentCredential("agent1");
-  const node = new LocalNode(
-    agentCredential,
-    newRandomSessionID(getAgentID(getAgent(agentCredential)))
-  );
-  const coValue = node.createCoValue({
-    type: "comap",
-    ruleset: { type: "unsafeAllowAll" },
-    meta: null,
-    ...createdNowUnique()
-  });
-  const content = coValue.getCurrentContent();
-  if (content.type !== "comap") {
-    throw new Error("Expected map");
-  }
-  expect(content.type).toEqual("comap");
-  content.edit((editable) => {
-    editable.set("hello", "world", "trusting");
-    expect(editable.get("hello")).toEqual("world");
-    editable.set("foo", "bar", "trusting");
-    expect(editable.get("foo")).toEqual("bar");
-    expect([...editable.keys()]).toEqual(["hello", "foo"]);
-    editable.delete("foo", "trusting");
-    expect(editable.get("foo")).toEqual(void 0);
-  });
-});
-test("Can get map entry values at different points in time", () => {
-  const agentCredential = newRandomAgentCredential("agent1");
-  const node = new LocalNode(
-    agentCredential,
-    newRandomSessionID(getAgentID(getAgent(agentCredential)))
-  );
-  const coValue = node.createCoValue({
-    type: "comap",
-    ruleset: { type: "unsafeAllowAll" },
-    meta: null,
-    ...createdNowUnique()
-  });
-  const content = coValue.getCurrentContent();
-  if (content.type !== "comap") {
-    throw new Error("Expected map");
-  }
-  expect(content.type).toEqual("comap");
-  content.edit((editable) => {
-    const beforeA = Date.now();
-    while (Date.now() < beforeA + 10) {
-    }
-    editable.set("hello", "A", "trusting");
-    const beforeB = Date.now();
-    while (Date.now() < beforeB + 10) {
-    }
-    editable.set("hello", "B", "trusting");
-    const beforeC = Date.now();
-    while (Date.now() < beforeC + 10) {
-    }
-    editable.set("hello", "C", "trusting");
-    expect(editable.get("hello")).toEqual("C");
-    expect(editable.getAtTime("hello", Date.now())).toEqual("C");
-    expect(editable.getAtTime("hello", beforeA)).toEqual(void 0);
-    expect(editable.getAtTime("hello", beforeB)).toEqual("A");
-    expect(editable.getAtTime("hello", beforeC)).toEqual("B");
-  });
-});
-test("Can get all historic values of key", () => {
-  const agentCredential = newRandomAgentCredential("agent1");
-  const node = new LocalNode(
-    agentCredential,
-    newRandomSessionID(getAgentID(getAgent(agentCredential)))
-  );
-  const coValue = node.createCoValue({
-    type: "comap",
-    ruleset: { type: "unsafeAllowAll" },
-    meta: null,
-    ...createdNowUnique()
-  });
-  const content = coValue.getCurrentContent();
-  if (content.type !== "comap") {
-    throw new Error("Expected map");
-  }
-  expect(content.type).toEqual("comap");
-  content.edit((editable) => {
-    var _a, _b, _c, _d;
-    editable.set("hello", "A", "trusting");
-    const txA = editable.getLastTxID("hello");
-    editable.set("hello", "B", "trusting");
-    const txB = editable.getLastTxID("hello");
-    editable.delete("hello", "trusting");
-    const txDel = editable.getLastTxID("hello");
-    editable.set("hello", "C", "trusting");
-    const txC = editable.getLastTxID("hello");
-    expect(
-      editable.getHistory("hello")
-    ).toEqual([
-      {
-        txID: txA,
-        value: "A",
-        at: txA && ((_a = coValue.getTx(txA)) == null ? void 0 : _a.madeAt)
-      },
-      {
-        txID: txB,
-        value: "B",
-        at: txB && ((_b = coValue.getTx(txB)) == null ? void 0 : _b.madeAt)
-      },
-      {
-        txID: txDel,
-        value: void 0,
-        at: txDel && ((_c = coValue.getTx(txDel)) == null ? void 0 : _c.madeAt)
-      },
-      {
-        txID: txC,
-        value: "C",
-        at: txC && ((_d = coValue.getTx(txC)) == null ? void 0 : _d.madeAt)
-      }
-    ]);
-  });
-});
-test("Can get last tx ID for a key", () => {
-  const agentCredential = newRandomAgentCredential("agent1");
-  const node = new LocalNode(
-    agentCredential,
-    newRandomSessionID(getAgentID(getAgent(agentCredential)))
-  );
-  const coValue = node.createCoValue({
-    type: "comap",
-    ruleset: { type: "unsafeAllowAll" },
-    meta: null,
-    ...createdNowUnique()
-  });
-  const content = coValue.getCurrentContent();
-  if (content.type !== "comap") {
-    throw new Error("Expected map");
-  }
-  expect(content.type).toEqual("comap");
-  content.edit((editable) => {
-    var _a, _b, _c, _d;
-    expect(editable.getLastTxID("hello")).toEqual(void 0);
-    editable.set("hello", "A", "trusting");
-    const sessionID = (_a = editable.getLastTxID("hello")) == null ? void 0 : _a.sessionID;
-    expect(sessionID && agentIDfromSessionID(sessionID)).toEqual(
-      getAgentID(getAgent(agentCredential))
-    );
-    expect((_b = editable.getLastTxID("hello")) == null ? void 0 : _b.txIndex).toEqual(0);
-    editable.set("hello", "B", "trusting");
-    expect((_c = editable.getLastTxID("hello")) == null ? void 0 : _c.txIndex).toEqual(1);
-    editable.set("hello", "C", "trusting");
-    expect((_d = editable.getLastTxID("hello")) == null ? void 0 : _d.txIndex).toEqual(2);
-  });
-});

package/dist/contentTypes/coList.mjs

@@ -1,18 +0,0 @@
-"use strict";
-export class CoList {
-  id;
-  type = "colist";
-  coValue;
-  constructor(coValue) {
-    this.id = coValue.id;
-    this.coValue = coValue;
-  }
-  toJSON() {
-    throw new Error("Method not implemented.");
-  }
-  subscribe(listener) {
-    return this.coValue.subscribe((content) => {
-      listener(content);
-    });
-  }
-}

package/dist/contentTypes/coMap.mjs

@@ -1,126 +0,0 @@
-"use strict";
-export class CoMap {
-  id;
-  coValue;
-  type = "comap";
-  ops;
-  constructor(coValue) {
-    this.id = coValue.id;
-    this.coValue = coValue;
-    this.ops = {};
-    this.fillOpsFromCoValue();
-  }
-  fillOpsFromCoValue() {
-    this.ops = {};
-    for (const { txID, changes, madeAt } of this.coValue.getValidSortedTransactions()) {
-      for (const [changeIdx, changeUntyped] of changes.entries()) {
-        const change = changeUntyped;
-        let entries = this.ops[change.key];
-        if (!entries) {
-          entries = [];
-          this.ops[change.key] = entries;
-        }
-        entries.push({
-          txID,
-          madeAt,
-          changeIdx,
-          ...change
-        });
-      }
-    }
-  }
-  keys() {
-    return Object.keys(this.ops);
-  }
-  get(key) {
-    const ops = this.ops[key];
-    if (!ops) {
-      return void 0;
-    }
-    const lastEntry = ops[ops.length - 1];
-    if (lastEntry.op === "delete") {
-      return void 0;
-    } else {
-      return lastEntry.value;
-    }
-  }
-  getAtTime(key, time) {
-    const ops = this.ops[key];
-    if (!ops) {
-      return void 0;
-    }
-    const lastOpBeforeOrAtTime = ops.findLast((op) => op.madeAt <= time);
-    if (!lastOpBeforeOrAtTime) {
-      return void 0;
-    }
-    if (lastOpBeforeOrAtTime.op === "delete") {
-      return void 0;
-    } else {
-      return lastOpBeforeOrAtTime.value;
-    }
-  }
-  getLastTxID(key) {
-    const ops = this.ops[key];
-    if (!ops) {
-      return void 0;
-    }
-    const lastEntry = ops[ops.length - 1];
-    return lastEntry.txID;
-  }
-  getHistory(key) {
-    const ops = this.ops[key];
-    if (!ops) {
-      return [];
-    }
-    const history = [];
-    for (const op of ops) {
-      if (op.op === "delete") {
-        history.push({ at: op.madeAt, txID: op.txID, value: void 0 });
-      } else {
-        history.push({ at: op.madeAt, txID: op.txID, value: op.value });
-      }
-    }
-    return history;
-  }
-  toJSON() {
-    const json = {};
-    for (const key of this.keys()) {
-      const value = this.get(key);
-      if (value !== void 0) {
-        json[key] = value;
-      }
-    }
-    return json;
-  }
-  edit(changer) {
-    const editable = new WriteableCoMap(this.coValue);
-    changer(editable);
-    return new CoMap(this.coValue);
-  }
-  subscribe(listener) {
-    return this.coValue.subscribe((content) => {
-      listener(content);
-    });
-  }
-}
-export class WriteableCoMap extends CoMap {
-  set(key, value, privacy = "private") {
-    this.coValue.makeTransaction([
-      {
-        op: "insert",
-        key,
-        value
-      }
-    ], privacy);
-    this.fillOpsFromCoValue();
-  }
-  delete(key, privacy = "private") {
-    this.coValue.makeTransaction([
-      {
-        op: "delete",
-        key
-      }
-    ], privacy);
-    this.fillOpsFromCoValue();
-  }
-}

package/dist/contentTypes/coStream.mjs

@@ -1,18 +0,0 @@
-"use strict";
-export class CoStream {
-  id;
-  type = "costream";
-  coValue;
-  constructor(coValue) {
-    this.id = coValue.id;
-    this.coValue = coValue;
-  }
-  toJSON() {
-    throw new Error("Method not implemented.");
-  }
-  subscribe(listener) {
-    return this.coValue.subscribe((content) => {
-      listener(content);
-    });
-  }
-}

package/dist/contentTypes/static.mjs

@@ -1,16 +0,0 @@
-"use strict";
-export class Static {
-  id;
-  type = "static";
-  coValue;
-  constructor(coValue) {
-    this.id = coValue.id;
-    this.coValue = coValue;
-  }
-  toJSON() {
-    throw new Error("Method not implemented.");
-  }
-  subscribe(listener) {
-    throw new Error("Method not implemented.");
-  }
-}

package/dist/crypto.mjs

@@ -1,207 +0,0 @@
-"use strict";
-import { ed25519, x25519 } from "@noble/curves/ed25519";
-import { xsalsa20_poly1305, xsalsa20 } from "@noble/ciphers/salsa";
-import { base58, base64url } from "@scure/base";
-import stableStringify from "fast-json-stable-stringify";
-import { blake3 } from "@noble/hashes/blake3";
-import { randomBytes } from "@noble/ciphers/webcrypto/utils";
-const textEncoder = new TextEncoder();
-const textDecoder = new TextDecoder();
-export function newRandomSignatory() {
-  return `signatorySecret_z${base58.encode(
-    ed25519.utils.randomPrivateKey()
-  )}`;
-}
-export function signatorySecretToBytes(secret) {
-  return base58.decode(secret.substring("signatorySecret_z".length));
-}
-export function signatorySecretFromBytes(bytes) {
-  return `signatorySecret_z${base58.encode(bytes)}`;
-}
-export function getSignatoryID(secret) {
-  return `signatory_z${base58.encode(
-    ed25519.getPublicKey(
-      base58.decode(secret.substring("signatorySecret_z".length))
-    )
-  )}`;
-}
-export function sign(secret, message) {
-  const signature = ed25519.sign(
-    textEncoder.encode(stableStringify(message)),
-    base58.decode(secret.substring("signatorySecret_z".length))
-  );
-  return `signature_z${base58.encode(signature)}`;
-}
-export function verify(signature, message, id) {
-  return ed25519.verify(
-    base58.decode(signature.substring("signature_z".length)),
-    textEncoder.encode(stableStringify(message)),
-    base58.decode(id.substring("signatory_z".length))
-  );
-}
-export function newRandomRecipient() {
-  return `recipientSecret_z${base58.encode(x25519.utils.randomPrivateKey())}`;
-}
-export function recipientSecretToBytes(secret) {
-  return base58.decode(secret.substring("recipientSecret_z".length));
-}
-export function recipientSecretFromBytes(bytes) {
-  return `recipientSecret_z${base58.encode(bytes)}`;
-}
-export function getRecipientID(secret) {
-  return `recipient_z${base58.encode(
-    x25519.getPublicKey(
-      base58.decode(secret.substring("recipientSecret_z".length))
-    )
-  )}`;
-}
-export function seal(message, from, to, nOnceMaterial) {
-  const nOnce = blake3(
-    textEncoder.encode(stableStringify(nOnceMaterial))
-  ).slice(0, 24);
-  const recipientsSorted = Array.from(to).sort();
-  const recipientPubs = recipientsSorted.map((recipient) => {
-    return base58.decode(recipient.substring("recipient_z".length));
-  });
-  const senderPriv = base58.decode(
-    from.substring("recipientSecret_z".length)
-  );
-  const plaintext = textEncoder.encode(stableStringify(message));
-  const sealedSet = {};
-  for (let i = 0; i < recipientsSorted.length; i++) {
-    const recipient = recipientsSorted[i];
-    const sharedSecret = x25519.getSharedSecret(
-      senderPriv,
-      recipientPubs[i]
-    );
-    const sealedBytes = xsalsa20_poly1305(sharedSecret, nOnce).encrypt(
-      plaintext
-    );
-    sealedSet[recipient] = `sealed_U${base64url.encode(
-      sealedBytes
-    )}`;
-  }
-  return sealedSet;
-}
-export function openAs(sealedSet, recipient, from, nOnceMaterial) {
-  const nOnce = blake3(
-    textEncoder.encode(stableStringify(nOnceMaterial))
-  ).slice(0, 24);
-  const recipientPriv = base58.decode(
-    recipient.substring("recipientSecret_z".length)
-  );
-  const senderPub = base58.decode(from.substring("recipient_z".length));
-  const sealed = sealedSet[getRecipientID(recipient)];
-  if (!sealed) {
-    return void 0;
-  }
-  const sealedBytes = base64url.decode(sealed.substring("sealed_U".length));
-  const sharedSecret = x25519.getSharedSecret(recipientPriv, senderPub);
-  const plaintext = xsalsa20_poly1305(sharedSecret, nOnce).decrypt(
-    sealedBytes
-  );
-  try {
-    return JSON.parse(textDecoder.decode(plaintext));
-  } catch (e) {
-    console.error("Failed to decrypt/parse sealed message", e);
-    return void 0;
-  }
-}
-export function secureHash(value) {
-  return `hash_z${base58.encode(
-    blake3(textEncoder.encode(stableStringify(value)))
-  )}`;
-}
-export class StreamingHash {
-  state;
-  constructor(fromClone) {
-    this.state = fromClone || blake3.create({});
-  }
-  update(value) {
-    this.state.update(textEncoder.encode(stableStringify(value)));
-  }
-  digest() {
-    const hash = this.state.digest();
-    return `hash_z${base58.encode(hash)}`;
-  }
-  clone() {
-    return new StreamingHash(this.state.clone());
-  }
-}
-export function shortHash(value) {
-  return `shortHash_z${base58.encode(
-    blake3(textEncoder.encode(stableStringify(value))).slice(0, 19)
-  )}`;
-}
-export function newRandomKeySecret() {
-  return {
-    secret: `keySecret_z${base58.encode(randomBytes(32))}`,
-    id: `key_z${base58.encode(randomBytes(12))}`
-  };
-}
-function encrypt(value, keySecret, nOnceMaterial) {
-  const keySecretBytes = base58.decode(
-    keySecret.substring("keySecret_z".length)
-  );
-  const nOnce = blake3(
-    textEncoder.encode(stableStringify(nOnceMaterial))
-  ).slice(0, 24);
-  const plaintext = textEncoder.encode(stableStringify(value));
-  const ciphertext = xsalsa20(keySecretBytes, nOnce, plaintext);
-  return `encrypted_U${base64url.encode(ciphertext)}`;
-}
-export function encryptForTransaction(value, keySecret, nOnceMaterial) {
-  return encrypt(value, keySecret, nOnceMaterial);
-}
-export function sealKeySecret(keys) {
-  const nOnceMaterial = {
-    sealed: keys.toSeal.id,
-    sealing: keys.sealing.id
-  };
-  return {
-    sealed: keys.toSeal.id,
-    sealing: keys.sealing.id,
-    encrypted: encrypt(
-      keys.toSeal.secret,
-      keys.sealing.secret,
-      nOnceMaterial
-    )
-  };
-}
-function decrypt(encrypted, keySecret, nOnceMaterial) {
-  const keySecretBytes = base58.decode(
-    keySecret.substring("keySecret_z".length)
-  );
-  const nOnce = blake3(
-    textEncoder.encode(stableStringify(nOnceMaterial))
-  ).slice(0, 24);
-  const ciphertext = base64url.decode(
-    encrypted.substring("encrypted_U".length)
-  );
-  const plaintext = xsalsa20(keySecretBytes, nOnce, ciphertext);
-  try {
-    return JSON.parse(textDecoder.decode(plaintext));
-  } catch (e) {
-    return void 0;
-  }
-}
-export function decryptForTransaction(encrypted, keySecret, nOnceMaterial) {
-  return decrypt(encrypted, keySecret, nOnceMaterial);
-}
-export function unsealKeySecret(sealedInfo, sealingSecret) {
-  const nOnceMaterial = {
-    sealed: sealedInfo.sealed,
-    sealing: sealedInfo.sealing
-  };
-  return decrypt(sealedInfo.encrypted, sealingSecret, nOnceMaterial);
-}
-export function uniquenessForHeader() {
-  return `z${base58.encode(randomBytes(12))}`;
-}
-export function createdNowUnique() {
-  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-  return {
-    createdAt,
-    uniqueness: uniquenessForHeader()
-  };
-}