ox 0.14.18 → 0.14.19

package/tempo/internal/mine.c

@@ -0,0 +1,182 @@
+// TIP-1022 salt mining — isomorphic WASM (Node + browser).
+// Specialized single-block keccak256 for 52-byte input.
+//
+// Memory layout at offset 1024:
+//   [0..19]   address   (set by JS)
+//   [20..51]  salt      (set by JS, incremented in-place)
+//   [52..83]  hash out  (written on match)
+
+typedef unsigned char      uint8_t;
+typedef unsigned int       uint32_t;
+typedef unsigned long long uint64_t;
+
+#define DATA_OFFSET 1024
+
+// ---------------------------------------------------------------------------
+// Keccak-f[1600] — fully unrolled, native uint64_t → wasm i64.
+// Based on XKCP / hash-wasm structure.
+// ---------------------------------------------------------------------------
+
+#define ROTL64(x, n) (((x) << (n)) | ((x) >> (64 - (n))))
+
+static const uint64_t RC[24] = {
+    0x0000000000000001ULL, 0x0000000000008082ULL, 0x800000000000808aULL,
+    0x8000000080008000ULL, 0x000000000000808bULL, 0x0000000080000001ULL,
+    0x8000000080008081ULL, 0x8000000000008009ULL, 0x000000000000008aULL,
+    0x0000000000000088ULL, 0x0000000080008009ULL, 0x000000008000000aULL,
+    0x000000008000808bULL, 0x800000000000008bULL, 0x8000000000008089ULL,
+    0x8000000000008003ULL, 0x8000000000008002ULL, 0x8000000000000080ULL,
+    0x000000000000800aULL, 0x800000008000000aULL, 0x8000000080008081ULL,
+    0x8000000000008080ULL, 0x0000000080000001ULL, 0x8000000080008008ULL,
+};
+
+// Theta — fully unrolled column parity + diffusion
+#define XORED(i) (A[(i)] ^ A[(i)+5] ^ A[(i)+10] ^ A[(i)+15] ^ A[(i)+20])
+
+static inline void theta(uint64_t *A) {
+    uint64_t D[5];
+    D[0] = ROTL64(XORED(1), 1) ^ XORED(4);
+    D[1] = ROTL64(XORED(2), 1) ^ XORED(0);
+    D[2] = ROTL64(XORED(3), 1) ^ XORED(1);
+    D[3] = ROTL64(XORED(4), 1) ^ XORED(2);
+    D[4] = ROTL64(XORED(0), 1) ^ XORED(3);
+    A[ 0]^=D[0]; A[ 1]^=D[1]; A[ 2]^=D[2]; A[ 3]^=D[3]; A[ 4]^=D[4];
+    A[ 5]^=D[0]; A[ 6]^=D[1]; A[ 7]^=D[2]; A[ 8]^=D[3]; A[ 9]^=D[4];
+    A[10]^=D[0]; A[11]^=D[1]; A[12]^=D[2]; A[13]^=D[3]; A[14]^=D[4];
+    A[15]^=D[0]; A[16]^=D[1]; A[17]^=D[2]; A[18]^=D[3]; A[19]^=D[4];
+    A[20]^=D[0]; A[21]^=D[1]; A[22]^=D[2]; A[23]^=D[3]; A[24]^=D[4];
+}
+
+// Rho — explicit per-lane rotations with compile-time constants
+static inline void rho(uint64_t *A) {
+    A[ 1] = ROTL64(A[ 1],  1); A[ 2] = ROTL64(A[ 2], 62);
+    A[ 3] = ROTL64(A[ 3], 28); A[ 4] = ROTL64(A[ 4], 27);
+    A[ 5] = ROTL64(A[ 5], 36); A[ 6] = ROTL64(A[ 6], 44);
+    A[ 7] = ROTL64(A[ 7],  6); A[ 8] = ROTL64(A[ 8], 55);
+    A[ 9] = ROTL64(A[ 9], 20); A[10] = ROTL64(A[10],  3);
+    A[11] = ROTL64(A[11], 10); A[12] = ROTL64(A[12], 43);
+    A[13] = ROTL64(A[13], 25); A[14] = ROTL64(A[14], 39);
+    A[15] = ROTL64(A[15], 41); A[16] = ROTL64(A[16], 45);
+    A[17] = ROTL64(A[17], 15); A[18] = ROTL64(A[18], 21);
+    A[19] = ROTL64(A[19],  8); A[20] = ROTL64(A[20], 18);
+    A[21] = ROTL64(A[21],  2); A[22] = ROTL64(A[22], 61);
+    A[23] = ROTL64(A[23], 56); A[24] = ROTL64(A[24], 14);
+}
+
+// Pi — single-temporary rotation chain (no scratch buffer)
+static inline void pi(uint64_t *A) {
+    uint64_t A1 = A[1];
+    A[ 1]=A[ 6]; A[ 6]=A[ 9]; A[ 9]=A[22]; A[22]=A[14]; A[14]=A[20];
+    A[20]=A[ 2]; A[ 2]=A[12]; A[12]=A[13]; A[13]=A[19]; A[19]=A[23];
+    A[23]=A[15]; A[15]=A[ 4]; A[ 4]=A[24]; A[24]=A[21]; A[21]=A[ 8];
+    A[ 8]=A[16]; A[16]=A[ 5]; A[ 5]=A[ 3]; A[ 3]=A[18]; A[18]=A[17];
+    A[17]=A[11]; A[11]=A[ 7]; A[ 7]=A[10]; A[10]=A1;
+}
+
+// Chi — unrolled nonlinear step
+#define CHI_ROW(i) { \
+    uint64_t a0 = A[(i)], a1 = A[(i)+1]; \
+    A[(i)  ] ^= ~a1        & A[(i)+2]; \
+    A[(i)+1] ^= ~A[(i)+2]  & A[(i)+3]; \
+    A[(i)+2] ^= ~A[(i)+3]  & A[(i)+4]; \
+    A[(i)+3] ^= ~A[(i)+4]  & a0;       \
+    A[(i)+4] ^= ~a0        & a1;       \
+}
+
+static inline void chi(uint64_t *A) {
+    CHI_ROW(0); CHI_ROW(5); CHI_ROW(10); CHI_ROW(15); CHI_ROW(20);
+}
+
+static void keccak_f1600(uint64_t *A) {
+    for (int r = 0; r < 24; r++) {
+        theta(A); rho(A); pi(A); chi(A);
+        A[0] ^= RC[r];
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+static inline uint64_t load64_le(const uint8_t *p) {
+    return (uint64_t)p[0]       | ((uint64_t)p[1] << 8)  |
+           ((uint64_t)p[2] <<16)| ((uint64_t)p[3] << 24) |
+           ((uint64_t)p[4] <<32)| ((uint64_t)p[5] << 40) |
+           ((uint64_t)p[6] <<48)| ((uint64_t)p[7] << 56);
+}
+
+static inline void store64_le(uint8_t *p, uint64_t v) {
+    p[0]=(uint8_t)v; p[1]=(uint8_t)(v>>8); p[2]=(uint8_t)(v>>16); p[3]=(uint8_t)(v>>24);
+    p[4]=(uint8_t)(v>>32); p[5]=(uint8_t)(v>>40); p[6]=(uint8_t)(v>>48); p[7]=(uint8_t)(v>>56);
+}
+
+static inline uint32_t load32_le(const uint8_t *p) {
+    return (uint32_t)p[0] | ((uint32_t)p[1]<<8) | ((uint32_t)p[2]<<16) | ((uint32_t)p[3]<<24);
+}
+
+// ---------------------------------------------------------------------------
+// Mining entry point
+// ---------------------------------------------------------------------------
+
+__attribute__((export_name("mine")))
+int mine(int count) {
+    uint8_t *mem   = (uint8_t *)DATA_OFFSET;
+    uint8_t *addr  = mem;       // 20 bytes
+    uint8_t *salt  = mem + 20;  // 32 bytes
+    uint8_t *hout  = mem + 52;  // 32 bytes
+
+    // Pre-build base state for 52-byte keccak256 (one block, rate=136).
+    // Block = [address(20) | salt(32) | 0x01 | zeros | 0x80]
+    // Only lanes 0..6 are non-zero from the message, plus padding in lanes 6 & 16.
+    uint64_t base[25];
+    for (int i = 0; i < 25; i++) base[i] = 0;
+
+    // Load address into lanes 0..2 (bytes 0..23, only 0..19 used)
+    uint8_t buf[24];
+    for (int i = 0; i < 20; i++) buf[i] = addr[i];
+    for (int i = 20; i < 24; i++) buf[i] = 0;
+    base[0] = load64_le(buf);
+    base[1] = load64_le(buf + 8);
+    base[2] = load64_le(buf + 16);
+
+    // Keccak padding: byte 52 = 0x01, byte 135 = 0x80
+    // Lane 6 (bytes 48..55): byte 52 = lane offset 4 → bit 32
+    base[6] = (uint64_t)0x01 << 32;
+    // Lane 16 (bytes 128..135): byte 135 = lane offset 7 → bit 56
+    base[16] = (uint64_t)0x80 << 56;
+
+    for (int iter = 0; iter < count; iter++) {
+        // Copy base, XOR salt.
+        // Salt occupies bytes 20..51 → lanes 2..6.
+        uint64_t A[25];
+        for (int i = 0; i < 25; i++) A[i] = base[i];
+
+        // Lane 2 (bytes 16..23): upper 4 bytes = salt[0..3]
+        A[2] ^= (uint64_t)load32_le(salt) << 32;
+        // Lane 3 (bytes 24..31): salt[4..11]
+        A[3] ^= load64_le(salt + 4);
+        // Lane 4 (bytes 32..39): salt[12..19]
+        A[4] ^= load64_le(salt + 12);
+        // Lane 5 (bytes 40..47): salt[20..27]
+        A[5] ^= load64_le(salt + 20);
+        // Lane 6 (bytes 48..55): lower 4 bytes = salt[28..31]
+        A[6] ^= (uint64_t)load32_le(salt + 28);
+
+        keccak_f1600(A);
+
+        // PoW check: first 4 bytes = low 32 bits of lane 0 must be zero.
+        if ((uint32_t)A[0] == 0) {
+            for (int i = 0; i < 4; i++)
+                store64_le(hout + i * 8, A[i]);
+            return 1;
+        }
+
+        // Increment big-endian salt.
+        for (int i = 31; i >= 0; i--) {
+            if (salt[i] < 0xFF) { salt[i]++; break; }
+            salt[i] = 0;
+        }
+    }
+
+    return 0;
+}

package/tempo/internal/mine.wasm.ts

@@ -0,0 +1,17 @@
+// Embedded TIP-1022 WASM keccak256 salt miner (compiled from mine.c).
+//
+// Memory layout at offset 1024:
+//   [0..19]   address   (20 bytes, set by JS)
+//   [20..51]  salt      (32 bytes, set/read by JS, incremented in-place)
+//   [52..83]  hash out  (32 bytes, written on match)
+//
+// Exported: mine(count: i32) -> i32 — returns 1 if found, 0 if not.
+//
+// Generated by: pnpm tsx scripts/build-mine-wasm.ts
+
+/** Base64-encoded WASM binary for the TIP-1022 salt miner. */
+export const wasmBase64 =
+  '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'
+
+/** Byte offset in WASM linear memory where mining I/O begins. */
+export const dataOffset = 1024

package/tempo/internal/virtualMasterPool.ts

@@ -0,0 +1,254 @@
+import * as Errors from '../../core/Errors.js'
+
+/** Message sent from a mining worker to the main thread. */
+export type Message =
+  | { type: 'done' }
+  | { type: 'error'; message: string }
+  | {
+      type: 'found'
+      result: {
+        /** The 4-byte master identifier. */
+        masterId: string
+        /** The full 32-byte registration hash. */
+        registrationHash: string
+        /** The discovered 32-byte salt. */
+        salt: string
+      }
+    }
+  | { type: 'progress'; attempts: number }
+
+/** A platform-agnostic worker pool for parallel salt mining. */
+export type Pool = {
+  spawn(
+    index: number,
+    onMessage: (msg: Message) => void,
+    onError: (err: unknown) => void,
+  ): { postMessage(data: unknown): void; terminate(): void }
+}
+
+let cachedPool: Pool | undefined
+
+/**
+ * Whether the current runtime is Node.js.
+ *
+ * @internal
+ */
+const isNode =
+  typeof globalThis.process !== 'undefined' &&
+  typeof globalThis.process.versions?.node === 'string'
+
+/**
+ * Resolves the best available worker pool for the current runtime.
+ *
+ * @internal
+ */
+export async function resolve(): Promise<Pool | undefined> {
+  if (cachedPool) return cachedPool
+  cachedPool = isNode ? await resolveNode() : await resolveBrowser()
+  return cachedPool
+}
+
+/**
+ * Creates a worker pool backed by Node.js `worker_threads`.
+ *
+ * @internal
+ */
+export async function resolveNode(): Promise<Pool | undefined> {
+  const { Worker } = await import('node:worker_threads')
+  const { wasmBase64 } = await import('./mine.wasm.js')
+  const workerSource = getNodeWorkerSource()
+
+  return {
+    spawn(index, onMessage, onError) {
+      const worker = new Worker(workerSource, {
+        eval: true,
+        workerData: {
+          wasmBase64,
+          workerIndex: index,
+        },
+      })
+      worker.on('message', (msg: Message) => onMessage(msg))
+      worker.on('error', (err) => onError(err))
+      worker.on('exit', (code) => {
+        if (code !== 0)
+          onError(
+            new Errors.BaseError(
+              `A salt mining worker exited with code "${code}".`,
+            ),
+          )
+      })
+      return {
+        postMessage(data) {
+          worker.postMessage(data)
+        },
+        terminate() {
+          void worker.terminate().catch(() => {})
+        },
+      }
+    },
+  }
+}
+
+/**
+ * Creates a worker pool backed by browser `Worker` with Blob URLs.
+ *
+ * @internal
+ */
+export async function resolveBrowser(): Promise<Pool | undefined> {
+  if (typeof globalThis.Worker === 'undefined') return undefined
+  if (typeof globalThis.Blob === 'undefined') return undefined
+
+  const { wasmBase64 } = await import('./mine.wasm.js')
+  const source = getBrowserWorkerSource(wasmBase64)
+  const blob = new Blob([source], { type: 'application/javascript' })
+  const url = URL.createObjectURL(blob)
+
+  return {
+    spawn(_index, onMessage, onError) {
+      const worker = new globalThis.Worker(url)
+      worker.onmessage = (e: MessageEvent<Message>) => onMessage(e.data)
+      worker.onerror = (e) => onError(e.error)
+      return {
+        postMessage(data) {
+          worker.postMessage(data)
+        },
+        terminate() {
+          worker.terminate()
+        },
+      }
+    },
+  }
+}
+
+/**
+ * Returns the inline JavaScript source for a browser Web Worker.
+ *
+ * @internal
+ */
+function getBrowserWorkerSource(wasmBase64: string): string {
+  return `
+'use strict'
+
+${getWorkerMineLoop()}
+
+var binary = Uint8Array.from(atob(${JSON.stringify(wasmBase64)}), function(c) { return c.charCodeAt(0) })
+
+WebAssembly.instantiate(binary).then(function(result) {
+  var wasm = result.instance.exports
+  var mem = new Uint8Array(wasm.memory.buffer)
+
+  self.onmessage = function(e) {
+    if (e.data.type !== 'start') return
+    mineLoop(e.data, wasm, mem, function(msg) { self.postMessage(msg) })
+  }
+}).catch(function(error) {
+  self.postMessage({ type: 'error', message: error && error.message || String(error) })
+})
+`
+}
+
+/**
+ * Returns the eval'd JavaScript source for a Node.js `worker_threads` worker.
+ *
+ * @internal
+ */
+function getNodeWorkerSource(): string {
+  return `
+'use strict'
+var { parentPort, workerData } = require('node:worker_threads')
+
+${getWorkerMineLoop()}
+
+async function main() {
+  var binary = Buffer.from(workerData.wasmBase64, 'base64')
+  var { instance } = await WebAssembly.instantiate(binary)
+  var wasm = instance.exports
+  var mem = new Uint8Array(wasm.memory.buffer)
+
+  parentPort.on('message', function(data) {
+    if (data.type !== 'start') return
+    mineLoop(data, wasm, mem, function(msg) { parentPort.postMessage(msg) })
+  })
+}
+
+main().catch(function(error) {
+  parentPort.postMessage({ type: 'error', message: error && error.message || String(error) })
+})
+`
+}
+
+/**
+ * Returns the shared WASM mining loop source used by both Node and browser workers.
+ *
+ * @internal
+ */
+function getWorkerMineLoop(): string {
+  return `
+var dataOffset = 1024
+
+function hexToBytes(hex) {
+  var h = hex.startsWith('0x') ? hex.slice(2) : hex
+  var bytes = new Uint8Array(h.length / 2)
+  for (var i = 0; i < bytes.length; i++)
+    bytes[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16)
+  return bytes
+}
+
+function bytesToHex(bytes) {
+  var hex = '0x'
+  for (var i = 0; i < bytes.length; i++)
+    hex += bytes[i].toString(16).padStart(2, '0')
+  return hex
+}
+
+function bigIntToBytes32(value, out, offset) {
+  var v = value
+  for (var i = 31; i >= 0; i--) {
+    out[offset + i] = Number(v & 0xFFn)
+    v >>= 8n
+  }
+}
+
+function mineLoop(data, wasm, mem, postMessage) {
+  var addressBytes = hexToBytes(data.address)
+  var chunkSize = data.chunkSize
+  var count = data.count
+  var workerCount = data.workerCount
+  var workerIndex = data.workerIndex
+  var startBigInt = BigInt(data.start)
+
+  mem.set(addressBytes, dataOffset)
+
+  for (
+    var chunkIdx = workerIndex;
+    chunkIdx * chunkSize < count;
+    chunkIdx += workerCount
+  ) {
+    var chunkStart = chunkIdx * chunkSize
+    var limit = Math.min(chunkSize, count - chunkStart)
+
+    bigIntToBytes32(startBigInt + BigInt(chunkStart), mem, dataOffset + 20)
+
+    var found = wasm.mine(limit)
+
+    if (found) {
+      var hashOut = mem.slice(dataOffset + 52, dataOffset + 84)
+      var salt = mem.slice(dataOffset + 20, dataOffset + 52)
+      postMessage({
+        type: 'found',
+        result: {
+          masterId: bytesToHex(hashOut.subarray(4, 8)),
+          registrationHash: bytesToHex(hashOut),
+          salt: bytesToHex(salt),
+        },
+      })
+      return
+    }
+
+    postMessage({ type: 'progress', attempts: limit })
+  }
+
+  postMessage({ type: 'done' })
+}
+`
+}

package/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '0.14.18'
+export const version = '0.14.19'