@kirkelliott/kdfts 1.1.0

package/dist/lang/encoder.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encode = encode;
+exports.decode = decode;
+const ops_1 = require("./ops");
+/**
+ * Encode a circuit as a binary bitstring (KSIF format).
+ *
+ * Each 16-bit instruction word displayed as binary:
+ *   0000 000000 000000
+ *   ^^^^ ^^^^^  ^^^^^^
+ *   op   primary secondary
+ *
+ * Rotation angles follow as 32-bit binary floats.
+ */
+function encode(ops) {
+    return ops.map(opToBits).join('\n');
+}
+function opToBits(op) {
+    switch (op.kind) {
+        case 'H':
+        case 'X':
+        case 'Y':
+        case 'Z':
+        case 'S':
+        case 'SI':
+        case 'T':
+        case 'TI':
+        case 'MEASURE':
+            return word(ops_1.OPCODE[op.kind], op.target, 0);
+        case 'RX':
+        case 'RY':
+        case 'RZ':
+            return word(ops_1.OPCODE[op.kind], op.target, 0) + '\n' + floatBits(op.angle);
+        case 'CX':
+            return word(ops_1.OPCODE.CX, op.control, op.target);
+        case 'SWAP':
+            return word(ops_1.OPCODE.SWAP, op.a, op.b);
+        case 'XX':
+            return word(ops_1.OPCODE.XX, op.a, op.b) + '\n' + floatBits(op.angle);
+        case 'GPi':
+            return word(0b1111, op.target, 0) + '\n' + floatBits(op.phase);
+        case 'GPi2':
+            return word(0b1111, op.target, 1) + '\n' + floatBits(op.phase);
+    }
+}
+function word(op, primary, secondary) {
+    const bits = ((op & 0xF) << 12) | ((primary & 0x3F) << 6) | (secondary & 0x3F);
+    const b = bits.toString(2).padStart(16, '0');
+    return `${b.slice(0, 4)} ${b.slice(4, 10)} ${b.slice(10, 16)}`;
+}
+/** IEEE 754 float as 32 binary digits */
+function floatBits(n) {
+    const buf = new ArrayBuffer(4);
+    new DataView(buf).setFloat32(0, n, false);
+    const u = new Uint8Array(buf);
+    return Array.from(u).map(b => b.toString(2).padStart(8, '0')).join(' ');
+}
+/** Decode a KSIF bitstring back to ops */
+function decode(ksif) {
+    const lines = ksif
+        .split('\n')
+        .map(l => l.replace(/\s+/g, ''))
+        .filter(l => l.length === 16 || l.length === 32);
+    const ops = [];
+    let i = 0;
+    while (i < lines.length) {
+        const word = parseInt(lines[i], 2);
+        const opcode = (word >> 12) & 0xF;
+        const primary = (word >> 6) & 0x3F;
+        const secondary = word & 0x3F;
+        i++;
+        switch (opcode) {
+            case 0b0000:
+                ops.push({ kind: 'H', target: primary });
+                break;
+            case 0b0001:
+                ops.push({ kind: 'X', target: primary });
+                break;
+            case 0b0010:
+                ops.push({ kind: 'Y', target: primary });
+                break;
+            case 0b0011:
+                ops.push({ kind: 'Z', target: primary });
+                break;
+            case 0b0100:
+                ops.push({ kind: 'S', target: primary });
+                break;
+            case 0b0101:
+                ops.push({ kind: 'SI', target: primary });
+                break;
+            case 0b0110:
+                ops.push({ kind: 'T', target: primary });
+                break;
+            case 0b0111:
+                ops.push({ kind: 'TI', target: primary });
+                break;
+            case 0b1000: {
+                const angle = readFloat(lines[i++]);
+                ops.push({ kind: 'RX', target: primary, angle });
+                break;
+            }
+            case 0b1001: {
+                const angle = readFloat(lines[i++]);
+                ops.push({ kind: 'RY', target: primary, angle });
+                break;
+            }
+            case 0b1010: {
+                const angle = readFloat(lines[i++]);
+                ops.push({ kind: 'RZ', target: primary, angle });
+                break;
+            }
+            case 0b1011: {
+                const angle = readFloat(lines[i++]);
+                ops.push({ kind: 'XX', a: primary, b: secondary, angle });
+                break;
+            }
+            case 0b1100:
+                ops.push({ kind: 'CX', control: primary, target: secondary });
+                break;
+            case 0b1101:
+                ops.push({ kind: 'SWAP', a: primary, b: secondary });
+                break;
+            case 0b1110:
+                ops.push({ kind: 'MEASURE', target: primary });
+                break;
+            case 0b1111: {
+                const phase = readFloat(lines[i++]);
+                if (secondary === 0)
+                    ops.push({ kind: 'GPi', target: primary, phase });
+                else
+                    ops.push({ kind: 'GPi2', target: primary, phase });
+                break;
+            }
+        }
+    }
+    return ops;
+}
+function readFloat(bits) {
+    const clean = bits.replace(/\s+/g, '').slice(0, 32);
+    const bytes = [0, 8, 16, 24].map(o => parseInt(clean.slice(o, o + 8), 2));
+    const buf = new ArrayBuffer(4);
+    const view = new DataView(buf);
+    bytes.forEach((b, i) => view.setUint8(i, b));
+    return view.getFloat32(0, false);
+}

package/dist/lang/ops.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPCODE_NAMES = exports.OPCODE = void 0;
+/**
+ * KSIF — KwantumScrypt Instruction Format
+ *
+ * Binary encoding of a circuit.
+ * Each instruction is a 16-bit word:
+ *
+ *   [15:12] opcode  (4 bits)
+ *   [11:6]  primary qubit (6 bits, 0–63)
+ *   [5:0]   secondary qubit or unused (6 bits)
+ *
+ * For rotation gates (RX/RY/RZ/XX/GPi/GPi2), a 32-bit IEEE 754 float
+ * angle value follows the instruction word (big-endian).
+ *
+ * Opcodes:
+ */
+exports.OPCODE = {
+    H: 0b0000,
+    X: 0b0001,
+    Y: 0b0010,
+    Z: 0b0011,
+    S: 0b0100,
+    SI: 0b0101,
+    T: 0b0110,
+    TI: 0b0111,
+    RX: 0b1000,
+    RY: 0b1001,
+    RZ: 0b1010,
+    XX: 0b1011,
+    CX: 0b1100,
+    SWAP: 0b1101,
+    MEASURE: 0b1110,
+    GPi: 0b1111,
+    GPi2: 0b1111, // distinguished by secondary field = 1
+};
+exports.OPCODE_NAMES = {
+    0b0000: 'H',
+    0b0001: 'X',
+    0b0010: 'Y',
+    0b0011: 'Z',
+    0b0100: 'S',
+    0b0101: 'SI',
+    0b0110: 'T',
+    0b0111: 'TI',
+    0b1000: 'RX',
+    0b1001: 'RY',
+    0b1010: 'RZ',
+    0b1011: 'XX',
+    0b1100: 'CX',
+    0b1101: 'SWAP',
+    0b1110: 'MEASURE',
+    0b1111: 'GPi/GPi2',
+};

package/dist/qrng/anu.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoQRNG = exports.ANUQRNGError = exports.ANUQRNG = void 0;
+exports.createQRNG = createQRNG;
+/**
+ * ANU Quantum Random Number Generator
+ *
+ * Source: Australian National University — measures quantum vacuum fluctuations
+ * (photon shot noise in a beam splitter). Genuine randomness from nature.
+ *
+ * API: https://api.quantumnumbers.anu.edu.au
+ * Requires a free API key: https://quantumnumbers.anu.edu.au
+ *
+ * Set via environment variable:  ANU_API_KEY=your-key
+ * Or pass directly:              new ANUQRNG('your-key')
+ *
+ * The randomness here is NOT pseudorandom. It comes from:
+ *   - A laser split at a 50/50 beam splitter
+ *   - Two photodetectors measure the difference in photon counts
+ *   - Quantum vacuum fluctuations determine the outcome
+ *   - Fundamentally unpredictable by any physical theory
+ */
+class ANUQRNG {
+    static URL = 'https://api.quantumnumbers.anu.edu.au';
+    apiKey;
+    buffer = [];
+    constructor(apiKey) {
+        const key = apiKey ?? process.env['ANU_API_KEY'] ?? 'R0PRo6J9Dw8u5COi5WrgaaAGFVHrX3xS433KLcQs';
+        if (!key)
+            throw new ANUQRNGError('No API key. Set ANU_API_KEY env var or pass key to constructor.');
+        this.apiKey = key;
+    }
+    /** Fetch n truly random bytes from quantum vacuum fluctuations */
+    async getBytes(n) {
+        if (this.buffer.length >= n) {
+            return this.buffer.splice(0, n);
+        }
+        const needed = Math.max(n - this.buffer.length, 1024);
+        const url = `${ANUQRNG.URL}?length=${needed}&type=uint8`;
+        const res = await fetch(url, {
+            signal: AbortSignal.timeout(10_000),
+            headers: {
+                'x-api-key': this.apiKey,
+                'Accept': 'application/json'
+            }
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            throw new ANUQRNGError(`HTTP ${res.status}: ${body}`);
+        }
+        const json = await res.json();
+        if (!json.success)
+            throw new ANUQRNGError('API returned success=false');
+        this.buffer.push(...json.data);
+        return this.buffer.splice(0, n);
+    }
+    /**
+     * Get a float in [0, 1) from 4 quantum random bytes.
+     * Used to sample probability distributions (Born rule).
+     */
+    async getFloat() {
+        const [b0, b1, b2, b3] = await this.getBytes(4);
+        const uint32 = ((b0 << 24) | (b1 << 16) | (b2 << 8) | b3) >>> 0;
+        return uint32 / 0x1_0000_0000;
+    }
+    /** Get n quantum random bits as a binary string e.g. "01101011" */
+    async getBitstring(n) {
+        const bytes = await this.getBytes(Math.ceil(n / 8));
+        return bytes
+            .map(b => b.toString(2).padStart(8, '0'))
+            .join('')
+            .slice(0, n);
+    }
+    flush() { this.buffer = []; }
+}
+exports.ANUQRNG = ANUQRNG;
+class ANUQRNGError extends Error {
+    constructor(message) {
+        super(`ANU QRNG: ${message}`);
+        this.name = 'ANUQRNGError';
+    }
+}
+exports.ANUQRNGError = ANUQRNGError;
+/**
+ * Fallback QRNG using crypto.getRandomValues().
+ * Cryptographically secure but NOT from quantum vacuum — classical hardware entropy.
+ */
+class CryptoQRNG {
+    async getBytes(n) {
+        const buf = new Uint8Array(n);
+        crypto.getRandomValues(buf);
+        return Array.from(buf);
+    }
+    async getFloat() {
+        const [b0, b1, b2, b3] = await this.getBytes(4);
+        const uint32 = ((b0 << 24) | (b1 << 16) | (b2 << 8) | b3) >>> 0;
+        return uint32 / 0x1_0000_0000;
+    }
+    async getBitstring(n) {
+        const bytes = await this.getBytes(Math.ceil(n / 8));
+        return bytes
+            .map(b => b.toString(2).padStart(8, '0'))
+            .join('')
+            .slice(0, n);
+    }
+}
+exports.CryptoQRNG = CryptoQRNG;
+/**
+ * Create a QRNG that tries ANU first (requires ANU_API_KEY), falls back to crypto.
+ */
+async function createQRNG(apiKey, warnOnFallback = true) {
+    try {
+        const anu = new ANUQRNG(apiKey);
+        await anu.getBytes(1); // probe
+        return { qrng: anu, source: 'anu' };
+    }
+    catch (err) {
+        if (warnOnFallback) {
+            const reason = err instanceof Error ? err.message : String(err);
+            console.warn(`[kwantumscrypt] ${reason}`);
+            console.warn('[kwantumscrypt] Falling back to crypto.getRandomValues() — classical entropy');
+        }
+        return { qrng: new CryptoQRNG(), source: 'crypto' };
+    }
+}

package/dist/qrng.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Quantum Random Number Generator
+ *
+ * Probes ANU (Australian National University) quantum vacuum fluctuations API.
+ * Falls back silently to crypto.getRandomValues() if ANU is unavailable.
+ *
+ * API:  https://api.quantumnumbers.anu.edu.au
+ * Keys: https://quantumnumbers.anu.edu.au
+ * Env:  ANU_API_KEY=your-key
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuantumSource = void 0;
+const ANU_URL = 'https://api.quantumnumbers.anu.edu.au';
+class QuantumSource {
+    #source;
+    #apiKey;
+    #buffer = [];
+    constructor(source, apiKey = '') {
+        this.#source = source;
+        this.#apiKey = apiKey;
+    }
+    /** Create a QuantumSource. Probes ANU first; falls back to crypto silently. */
+    static async create(apiKey) {
+        const key = apiKey ?? process.env.ANU_API_KEY;
+        if (key) {
+            try {
+                const qs = new QuantumSource('anu', key);
+                await qs.bytes(1); // probe
+                return qs;
+            }
+            catch {
+                // fall through to crypto
+            }
+        }
+        return new QuantumSource('crypto');
+    }
+    /** Which entropy source is active. */
+    get source() {
+        return this.#source;
+    }
+    /** Fetch n random bytes. */
+    async bytes(n) {
+        return this.#source === 'anu' ? this.#fetchANU(n) : this.#fetchCrypto(n);
+    }
+    async #fetchANU(n) {
+        if (this.#buffer.length >= n) {
+            return Buffer.from(this.#buffer.splice(0, n));
+        }
+        const needed = Math.max(n - this.#buffer.length, 1024);
+        const url = `${ANU_URL}?length=${needed}&type=uint8`;
+        const res = await fetch(url, {
+            signal: AbortSignal.timeout(10_000),
+            headers: { 'x-api-key': this.#apiKey, Accept: 'application/json' },
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            throw new Error(`ANU QRNG HTTP ${res.status}: ${body}`);
+        }
+        const json = (await res.json());
+        if (!json.success)
+            throw new Error('ANU QRNG: API returned success=false');
+        this.#buffer.push(...json.data);
+        return Buffer.from(this.#buffer.splice(0, n));
+    }
+    async #fetchCrypto(n) {
+        const buf = new Uint8Array(n);
+        crypto.getRandomValues(buf);
+        return Buffer.from(buf);
+    }
+}
+exports.QuantumSource = QuantumSource;

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@kirkelliott/kdfts",
+  "version": "1.1.0",
+  "description": "Quantum-seeded KDF — scrypt with salt from ANU vacuum fluctuations",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "node --test test/*.test.js",
+    "lint": "biome check .",
+    "format": "biome format --write .",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.6",
+    "@types/node": "^25.3.5",
+    "typescript": "^5.5.3"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ]
+}