ox 1.0.4 → 1.1.0

package/src/tempo/internal/mine.c

@@ -1,182 +0,0 @@
-// 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;
-}