nervur 0.14.0 → 0.16.0

package/tools.mjs

@@ -1,162 +0,0 @@
-import { ed25519 } from '@noble/curves/ed25519.js';
-import { sha256 } from '@noble/hashes/sha2.js';
-
-const HEX = '0123456789abcdef';
-
-const utf8 = new TextEncoder();
-const text8 = new TextDecoder();
-
-// Buffer is Node's alone. Every byte string here is a Uint8Array, and these
-// are the encodings the substrate names: hex on a digest, base64 on a
-// signature, utf8 under canon.
-const Bytes = Object.freeze({
-  base64: (bytes) => {
-    let binary = '';
-    for (const byte of bytes) {
-      binary += String.fromCharCode(byte);
-    }
-    return btoa(binary);
-  },
-  concat: (parts) => {
-    const whole = new Uint8Array(parts.reduce((run, one) => run + one.length, 0));
-    let at = 0;
-    for (const one of parts) {
-      whole.set(one, at);
-      at += one.length;
-    }
-    return whole;
-  },
-  equal: (one, other) => one.length === other.length && one.every((byte, at) => byte === other[at]),
-  hex: (bytes) => {
-    let out = '';
-    for (const byte of bytes) {
-      out += HEX[byte >> 4] + HEX[byte & 15];
-    }
-    return out;
-  },
-  of: (value) => utf8.encode(value),
-  read: (bytes) => text8.decode(bytes),
-  unbase64: (value) => {
-    const binary = atob(value);
-    const bytes = new Uint8Array(binary.length);
-    for (let at = 0; at < binary.length; at += 1) {
-      bytes[at] = binary.charCodeAt(at);
-    }
-    return bytes;
-  },
-  unhex: (value) => {
-    const bytes = new Uint8Array(value.length >> 1);
-    for (let at = 0; at < bytes.length; at += 1) {
-      bytes[at] = Number.parseInt(value.substr(at << 1, 2), 16);
-    }
-    return bytes;
-  },
-});
-
-const B32 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
-
-const VERSION_G = 6 << 3;
-
-const MEASURE = 8_388_608;
-
-const SPAN = 60_000;
-
-const ordered = (value) =>
-  value === null || typeof value !== 'object'
-    ? value
-    : Array.isArray(value)
-      ? value.map(ordered)
-      : Object.fromEntries(
-          Object.keys(value)
-            .sort()
-            .map((key) => [key, ordered(value[key])]),
-        );
-
-const crc16 = (bytes) => {
-  let crc = 0;
-  for (const b of bytes) {
-    crc ^= b << 8;
-    for (let i = 0; i < 8; i += 1) {
-      crc = (crc & 0x8000 ? (crc << 1) ^ 0x1021 : crc << 1) & 0xffff;
-    }
-  }
-  return crc;
-};
-
-const base32 = (bytes) => {
-  let bits = 0;
-  let value = 0;
-  let out = '';
-  for (const b of bytes) {
-    value = (value << 8) | b;
-    bits += 8;
-    while (bits >= 5) {
-      out += B32[(value >>> (bits - 5)) & 31];
-      bits -= 5;
-    }
-  }
-  return out;
-};
-
-const unbase32 = (text) => {
-  let bits = 0;
-  let value = 0;
-  const out = [];
-  for (const c of text) {
-    const index = B32.indexOf(c);
-    if (index < 0) {
-      return null;
-    }
-    value = (value << 5) | index;
-    bits += 5;
-    if (bits >= 8) {
-      out.push((value >>> (bits - 8)) & 0xff);
-      bits -= 8;
-    }
-  }
-  return Uint8Array.from(out);
-};
-
-const Tools = Object.freeze({
-  address: (pk) => {
-    const payload = Bytes.concat([Uint8Array.of(VERSION_G), pk]);
-    const crc = crc16(payload);
-    return base32(Bytes.concat([payload, Uint8Array.of(crc & 0xff, crc >> 8)]));
-  },
-  canon: (claim) => Bytes.of(JSON.stringify(ordered(claim))),
-  // The label arrives as text and the digest is over its utf8 bytes, which is
-  // the byte string the substrate has always hashed.
-  derive: (root, label) => sha256.create().update(root).update(Bytes.of(label)).digest(),
-  digest: (bytes) => Bytes.hex(sha256(bytes)),
-  envelope: async (voice, to, op, seq) => {
-    const from = Tools.address(voice.pk);
-    return { from, op, seq, sig: await voice.sign(Tools.canon({ from, op, seq, to })), to };
-  },
-  pkOf: (address) => {
-    const bytes = typeof address === 'string' && address.length === 56 ? unbase32(address) : null;
-    if (bytes === null || bytes[0] !== VERSION_G) {
-      return null;
-    }
-    const payload = bytes.subarray(0, 33);
-    const checksum = bytes[33] | (bytes[34] << 8);
-    return crc16(payload) === checksum ? payload.slice(1) : null;
-  },
-  secret: () => crypto.getRandomValues(new Uint8Array(32)),
-  verifies: (pk, bytes, sig) => {
-    try {
-      return ed25519.verify(Bytes.unbase64(sig), bytes, pk);
-    } catch {
-      return false;
-    }
-  },
-});
-
-const Stamp = () => {
-  let last = 0;
-  return () => {
-    last = Math.max(last + 1, Date.now());
-    return last;
-  };
-};
-
-export { Bytes, MEASURE, SPAN, Stamp, Tools };

package/voice.mjs

@@ -1,107 +0,0 @@
-import { ed25519, x25519 } from '@noble/curves/ed25519.js';
-import { sha256 } from '@noble/hashes/sha2.js';
-import { Bytes, Tools } from './tools.mjs';
-
-// A private key travels as PKCS8 DER in base64 — the shape every stored
-// bundle and every hand on the wire already carries — and a PKCS8 Ed25519 or
-// X25519 key is one fixed prefix and the thirty-two seed bytes, so the bytes
-// are the same whoever assembles them.
-const ED_PKCS8 = Bytes.unhex('302e020100300506032b657004220420');
-const X_PKCS8 = Bytes.unhex('302e020100300506032b656e04220420');
-
-const seeded = () => crypto.getRandomValues(new Uint8Array(32));
-
-const packed = (raw, prefix) => Bytes.base64(Bytes.concat([prefix, raw]));
-
-const unpacked = (text, prefix) => {
-  const der = Bytes.unbase64(text);
-  if (der.length !== prefix.length + 32 || !Bytes.equal(der.subarray(0, prefix.length), prefix)) {
-    throw new Error('not a key of this curve');
-  }
-  return der.subarray(prefix.length);
-};
-
-const agreed = (box, rawPub) => sha256(x25519.getSharedSecret(box, rawPub));
-
-const committed = /^[0-9a-f]{64}$/;
-
-const voiced = ({ present, next, box, nextPkHash }) =>
-  Object.freeze({
-    boxPk: x25519.getPublicKey(box),
-    nextPkHash: next === undefined ? nextPkHash : Tools.digest(ed25519.getPublicKey(next)),
-    open: (wrapped, cipher) => {
-      try {
-        const [ephemeral, sealed] = wrapped.split('.');
-        return cipher.unseal(agreed(box, Bytes.unbase64(ephemeral)), sealed);
-      } catch {
-        return undefined;
-      }
-    },
-    hand: () => ({
-      box: packed(box, X_PKCS8),
-      nextPkHash: next === undefined ? nextPkHash : Tools.digest(ed25519.getPublicKey(next)),
-      present: packed(present, ED_PKCS8),
-    }),
-    pack: () =>
-      next === undefined
-        ? { box: packed(box, X_PKCS8), nextPkHash, present: packed(present, ED_PKCS8) }
-        : {
-            box: packed(box, X_PKCS8),
-            next: packed(next, ED_PKCS8),
-            present: packed(present, ED_PKCS8),
-          },
-    pk: ed25519.getPublicKey(present),
-    sign: (bytes) => Bytes.base64(ed25519.sign(bytes, present)),
-    succeed: () =>
-      next === undefined
-        ? undefined
-        : voiced({
-            box: seeded(),
-            next: seeded(),
-            present: next,
-          }),
-  });
-
-const Voice = Object.freeze(
-  Object.assign(
-    (nextPkHash) => {
-      if (nextPkHash === undefined) {
-        return voiced({ box: seeded(), next: seeded(), present: seeded() });
-      }
-      return committed.test(nextPkHash)
-        ? voiced({ box: seeded(), nextPkHash, present: seeded() })
-        : undefined;
-    },
-    {
-      revive: (bundle) => {
-        try {
-          if (bundle.next === undefined) {
-            return committed.test(bundle.nextPkHash)
-              ? voiced({
-                  box: unpacked(bundle.box, X_PKCS8),
-                  nextPkHash: bundle.nextPkHash,
-                  present: unpacked(bundle.present, ED_PKCS8),
-                })
-              : undefined;
-          }
-          return voiced({
-            box: unpacked(bundle.box, X_PKCS8),
-            next: unpacked(bundle.next, ED_PKCS8),
-            present: unpacked(bundle.present, ED_PKCS8),
-          });
-        } catch {
-          return undefined;
-        }
-      },
-      sealTo: (boxPk, value, cipher) => {
-        const ephemeral = seeded();
-        const shut = cipher?.seal(agreed(ephemeral, boxPk), value);
-        return shut === undefined
-          ? undefined
-          : `${Bytes.base64(x25519.getPublicKey(ephemeral))}.${shut}`;
-      },
-    },
-  ),
-);
-
-export { Voice };