Versie 0.2.0

server/ai/aliases.js

@@ -0,0 +1,88 @@
+// Generated, do not edit. sha256:09721f6e6374d0297156a1b8af0d4578d0bbb9c98d4ea7c96458dafbb2d56dcc
+import { createHmac } from 'node:crypto';
+
+const HANDLE_TEKENS = 6;
+
+const BECH32 = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';
+const BASE58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+const HEX    = '0123456789abcdef';
+
+const SOORTEN = Object.freeze({
+  address: Object.freeze({ prefix: 'bc1q', lengte: 42, alfabet: BECH32, onmogelijk: 'o' }),
+  xpub:    Object.freeze({ prefix: 'xpub', lengte: 111, alfabet: BASE58, onmogelijk: '0' }),
+  txid:    Object.freeze({ prefix: '',     lengte: 64,  alfabet: HEX,    onmogelijk: 'z' }),
+});
+
+export const ALIAS_SOORTEN = Object.freeze(Object.keys(SOORTEN));
+
+function vul(alfabet, lengte, zaad) {
+  let s = '';
+  for (let i = 0; i < lengte; i++) {
+    const paar = parseInt(zaad.slice((i * 2) % zaad.length, (i * 2) % zaad.length + 2) || '0', 16);
+    s += alfabet[(paar + i) % alfabet.length];
+  }
+  return s;
+}
+
+export function schijnwaarde(soort, zaad) {
+  const s = SOORTEN[soort];
+  if (!s) throw new Error(`unknown alias kind: ${soort}`);
+  const romp = vul(s.alfabet, s.lengte - s.prefix.length, String(zaad));
+  const met = `${romp.slice(0, 2)}${s.onmogelijk}${romp.slice(3)}`;
+  return `${s.prefix}${met}`;
+}
+
+export function isSchijnwaarde(tekst) {
+  if (typeof tekst !== 'string') return false;
+  for (const [, s] of Object.entries(SOORTEN)) {
+    if (s.prefix && !tekst.startsWith(s.prefix)) continue;
+    if (tekst.length !== s.lengte) continue;
+    const data = tekst.slice(s.prefix.length);
+    if (data.includes(s.onmogelijk)) return true;
+  }
+  return false;
+}
+
+export function createAliasRegistry({ secret } = {}) {
+  if (typeof secret !== 'string' || secret.length < 32) {
+    throw new Error('An alias registry without a secret is not allowed.');
+  }
+  const heen = new Map();
+  const terug = new Map();
+
+  const afgeleid = (soort, waarde) =>
+    createHmac('sha256', secret).update(`${soort}\0${waarde}`).digest('hex');
+
+  function onthoud(sleutel, uit, soort, waarde) {
+    const bestaand = terug.get(uit);
+    if (bestaand && bestaand.waarde !== waarde) {
+      throw new Error(`Handle collision on '${uit}': two different values yield the same handle.`);
+    }
+    heen.set(sleutel, uit);
+    terug.set(uit, { soort, waarde });
+    return uit;
+  }
+
+  return {
+    alias(soort, waarde) {
+      const sleutel = `${soort} ${waarde}`;
+      if (heen.has(sleutel)) return heen.get(sleutel);
+      return onthoud(sleutel, schijnwaarde(soort, afgeleid(soort, waarde)), soort, waarde);
+    },
+
+    handle(soort, waarde) {
+      const sleutel = `${soort} ${waarde}`;
+      if (heen.has(sleutel)) return heen.get(sleutel);
+      return onthoud(sleutel, `${soort}:${afgeleid(soort, waarde).slice(0, HANDLE_TEKENS)}`, soort, waarde);
+    },
+
+    resolve(uit) {
+      const r = terug.get(uit);
+      return r ? r.waarde : null;
+    },
+
+    uitgegeven() {
+      return [...terug.entries()].map(([uit, r]) => ({ uit, soort: r.soort }));
+    },
+  };
+}