Files
miner/crates/engine-gpu/src/mining.wgsl
T
2025-11-23 10:31:47 +08:00

877 lines
32 KiB
WebGPU Shading Language

// Quantus Mining Shader - WGSL Compute Shader for GPU Mining
// Implements Poseidon2 hash function over Goldilocks field
// Goldilocks field constants: p = 2^64 - 2^32 + 1 = 18446744069414584321
// Since WGSL doesn't support 64-bit literals, we work with 32-bit chunks
// p = 0xFFFFFFFF00000001 = [0x00000001, 0xFFFFFFFF] in little-endian u32 pairs
const GOLDILOCKS_PRIME_LOW: u32 = 1u; // Low 32 bits
const GOLDILOCKS_PRIME_HIGH: u32 = 4294967295u; // High 32 bits (2^32 - 1)
// Poseidon2 constants
const WIDTH: u32 = 12u;
const RATE: u32 = 4u;
const EXTERNAL_ROUNDS: u32 = 4u;
const INTERNAL_ROUNDS: u32 = 22u;
// Individual constants for testing
const INTERNAL_CONST_0_LOW: u32 = 2018170979u;
const INTERNAL_CONST_0_HIGH: u32 = 2549578122u;
const INTERNAL_CONST_1_LOW: u32 = 794875120u;
const INTERNAL_CONST_1_HIGH: u32 = 3520249608u;
// Real Poseidon2 constants extracted from qp-poseidon-constants
// Internal round constants (22 values)
const INTERNAL_CONSTANTS: array<array<u32, 2>, 22> = array<array<u32, 2>, 22>(
array<u32, 2>(2018170979u, 2549578122u),
array<u32, 2>(794875120u, 3520249608u),
array<u32, 2>(2677723654u, 1772320679u),
array<u32, 2>(2743438884u, 2849007878u),
array<u32, 2>(518907317u, 693269760u),
array<u32, 2>(293328710u, 1484055617u),
array<u32, 2>(2834138828u, 2315799483u),
array<u32, 2>(1558078501u, 1039128420u),
array<u32, 2>(2266808631u, 966316006u),
array<u32, 2>(3393728842u, 1045622667u),
array<u32, 2>(2245828300u, 2521440415u),
array<u32, 2>(751064958u, 1070374632u),
array<u32, 2>(3490278765u, 2390340773u),
array<u32, 2>(3526960470u, 2224174634u),
array<u32, 2>(639988950u, 4000511088u),
array<u32, 2>(1839350858u, 504240201u),
array<u32, 2>(559852230u, 255489215u),
array<u32, 2>(2713771731u, 453385078u),
array<u32, 2>(1745082278u, 422331096u),
array<u32, 2>(2544763488u, 4141129721u),
array<u32, 2>(2700752774u, 1052996327u),
array<u32, 2>(4063512019u, 1429786100u)
);
// Initial external round constants (4 rounds x 12 elements)
const INITIAL_EXTERNAL_CONSTANTS: array<array<array<u32, 2>, 12>, 4> = array<array<array<u32, 2>, 12>, 4>(
array<array<u32, 2>, 12>(
array<u32, 2>(2539329031u, 3221415792u),
array<u32, 2>(4262746426u, 3164936845u),
array<u32, 2>(3883202553u, 1922272763u),
array<u32, 2>(3761386668u, 3841130025u),
array<u32, 2>(1411081289u, 3588274735u),
array<u32, 2>(4090250945u, 3962812520u),
array<u32, 2>(1100826458u, 1215155029u),
array<u32, 2>(1489773809u, 1813820067u),
array<u32, 2>(2585015995u, 3824356688u),
array<u32, 2>(2378857513u, 3651555078u),
array<u32, 2>(2864423342u, 3852156759u),
array<u32, 2>(1531416540u, 708695120u)
),
array<array<u32, 2>, 12>(
array<u32, 2>(1987505445u, 2913073372u),
array<u32, 2>(1426707734u, 655469195u),
array<u32, 2>(3385403543u, 1256631504u),
array<u32, 2>(1381422714u, 1458257259u),
array<u32, 2>(2453402910u, 528129365u),
array<u32, 2>(964329320u, 905986685u),
array<u32, 2>(1534247888u, 3842469367u),
array<u32, 2>(744525997u, 4241857185u),
array<u32, 2>(1756723870u, 3448331916u),
array<u32, 2>(3610291774u, 1105166073u),
array<u32, 2>(2596181885u, 3997051784u),
array<u32, 2>(3199845381u, 3533420525u)
),
array<array<u32, 2>, 12>(
array<u32, 2>(4127777666u, 2103183598u),
array<u32, 2>(2867888172u, 2309916828u),
array<u32, 2>(1831532055u, 3009056407u),
array<u32, 2>(2947502451u, 3675530062u),
array<u32, 2>(3565886616u, 2029012066u),
array<u32, 2>(3833391242u, 642945968u),
array<u32, 2>(1773785903u, 2577032347u),
array<u32, 2>(1770914259u, 1689297286u),
array<u32, 2>(3752758200u, 3993707216u),
array<u32, 2>(3389302766u, 1339375184u),
array<u32, 2>(2180141127u, 1466089441u),
array<u32, 2>(3199591357u, 4111832034u)
),
array<array<u32, 2>, 12>(
array<u32, 2>(1625498743u, 509487959u),
array<u32, 2>(4188712685u, 1646551713u),
array<u32, 2>(3451003566u, 2854767422u),
array<u32, 2>(1412166652u, 1674110767u),
array<u32, 2>(3410212320u, 1000704202u),
array<u32, 2>(3381743837u, 602777331u),
array<u32, 2>(3131873882u, 2866003620u),
array<u32, 2>(2610174026u, 3923414377u),
array<u32, 2>(3644719692u, 3450945356u),
array<u32, 2>(1458984419u, 2418851081u),
array<u32, 2>(3344519983u, 1531855103u),
array<u32, 2>(2721413879u, 3732495392u)
)
);
// Terminal external round constants (4 rounds x 12 elements)
const TERMINAL_EXTERNAL_CONSTANTS: array<array<array<u32, 2>, 12>, 4> = array<array<array<u32, 2>, 12>, 4>(
array<array<u32, 2>, 12>(
array<u32, 2>(3773451374u, 2071119161u),
array<u32, 2>(3805190518u, 340095962u),
array<u32, 2>(2402679944u, 2149591222u),
array<u32, 2>(743434178u, 1832305922u),
array<u32, 2>(2847530739u, 2718290175u),
array<u32, 2>(514243119u, 4142392203u),
array<u32, 2>(3844443492u, 888639642u),
array<u32, 2>(2008645578u, 2957397405u),
array<u32, 2>(3732799654u, 1692252629u),
array<u32, 2>(664231319u, 248567644u),
array<u32, 2>(287781771u, 482031345u),
array<u32, 2>(3486561978u, 1718871301u)
),
array<array<u32, 2>, 12>(
array<u32, 2>(814165505u, 1616875560u),
array<u32, 2>(2123759183u, 1070984082u),
array<u32, 2>(2722916813u, 3893372341u),
array<u32, 2>(3726899022u, 4157656693u),
array<u32, 2>(2824360073u, 4086907574u),
array<u32, 2>(4155973110u, 1837140488u),
array<u32, 2>(2297731723u, 4169165669u),
array<u32, 2>(707924090u, 1474243980u),
array<u32, 2>(1298483757u, 384287239u),
array<u32, 2>(4243798069u, 557703745u),
array<u32, 2>(1510569718u, 2968696976u),
array<u32, 2>(3174388759u, 3638808363u)
),
array<array<u32, 2>, 12>(
array<u32, 2>(2044277519u, 3835193622u),
array<u32, 2>(2743212840u, 1983595986u),
array<u32, 2>(3943309069u, 151568229u),
array<u32, 2>(424355060u, 1989274413u),
array<u32, 2>(867046322u, 239293714u),
array<u32, 2>(4230997871u, 2479068123u),
array<u32, 2>(1565052394u, 2566260552u),
array<u32, 2>(815274432u, 3822673712u),
array<u32, 2>(1051683535u, 519405993u),
array<u32, 2>(2687564964u, 186958263u),
array<u32, 2>(1450226471u, 1648586942u),
array<u32, 2>(1511122054u, 1595811937u)
),
array<array<u32, 2>, 12>(
array<u32, 2>(2426274859u, 4261676319u),
array<u32, 2>(1207777283u, 1918363057u),
array<u32, 2>(3090099832u, 3870167883u),
array<u32, 2>(4101522705u, 1460796764u),
array<u32, 2>(201900220u, 4164567654u),
array<u32, 2>(2587682901u, 752404845u),
array<u32, 2>(2967564913u, 2100296475u),
array<u32, 2>(3404347409u, 2242778408u),
array<u32, 2>(3350048952u, 1386431957u),
array<u32, 2>(4093308564u, 1347177553u),
array<u32, 2>(2633812729u, 3169012324u),
array<u32, 2>(1727753673u, 3768793234u)
)
);
// Helper function to create GoldilocksField from constant array
fn gf_from_const(val: array<u32, 2>) -> GoldilocksField {
return gf_from_u64_parts(val[0], val[1]);
}
// MDS matrix constants for width 12 - circulant matrix first row
// MDS matrix diagonal for width 12 Goldilocks (from p3_goldilocks constants)
// Each element is stored as [low32, high32] pairs
const MDS_MATRIX_DIAG_12: array<array<u32, 2>, 12> = array<array<u32, 2>, 12>(
array<u32, 2>(0x23ba9300u, 0xc3b6c08eu), // 0xc3b6c08e23ba9300u
array<u32, 2>(0x4a324fb6u, 0xd84b5de9u), // 0xd84b5de94a324fb6u
array<u32, 2>(0x5b35b84fu, 0x0d0c371cu), // 0x0d0c371c5b35b84fu
array<u32, 2>(0xe7188037u, 0x7964f570u), // 0x7964f570e7188037u
array<u32, 2>(0xd996604bu, 0x5daf18bbu), // 0x5daf18bbd996604bu
array<u32, 2>(0xb9595257u, 0x6743bc47u), // 0x6743bc47b9595257u
array<u32, 2>(0x2c59bb70u, 0x5528b936u), // 0x5528b9362c59bb70u
array<u32, 2>(0x7127b68bu, 0xac45e25bu), // 0xac45e25b7127b68bu
array<u32, 2>(0xfbb606b5u, 0xa2077d7du), // 0xa2077d7dfbb606b5u
array<u32, 2>(0xaee378aeu, 0xf3faac6fu), // 0xf3faac6faee378aeu
array<u32, 2>(0x1545e883u, 0x0c6388b5u), // 0x0c6388b51545e883u
array<u32, 2>(0x44917b60u, 0xd27dbb69u) // 0xd27dbb6944917b60u
);
// Storage buffers
@group(0) @binding(0) var<storage, read_write> results: array<u32>;
@group(0) @binding(1) var<storage, read> header: array<u32, 8>; // 32 bytes
@group(0) @binding(2) var<storage, read> start_nonce: array<u32, 16>; // 64 bytes
@group(0) @binding(3) var<storage, read> difficulty_target: array<u32, 16>; // 64 bytes (U512 target)
// Goldilocks field element represented as [limb0, limb1, limb2, limb3]
// where the value is limb0 + limb1*2^16 + limb2*2^32 + limb3*2^48
struct GoldilocksField {
limb0: u32, // Actually u16, but WGSL doesn't have native u16
limb1: u32,
limb2: u32,
limb3: u32,
}
// Field modulus P = 2^64 - 2^32 + 1 = 0xFFFFFFFF00000001
// In u16 limbs: P = [1, 0, 0xFFFF, 0xFFFF]
const P_LIMB0: u32 = 1u;
const P_LIMB1: u32 = 0u;
const P_LIMB2: u32 = 0xFFFFu;
const P_LIMB3: u32 = 0xFFFFu;
// EPSILON = 2^32 - 1 = 0x00000000FFFFFFFF
// In u16 limbs: EPSILON = [0xFFFF, 0xFFFF, 0, 0]
const EPSILON_LIMB0: u32 = 0xFFFFu;
const EPSILON_LIMB1: u32 = 0xFFFFu;
const EPSILON_LIMB2: u32 = 0u;
const EPSILON_LIMB3: u32 = 0u;
// Helper to create field elements
fn gf_from_limbs(l0: u32, l1: u32, l2: u32, l3: u32) -> GoldilocksField {
return GoldilocksField(l0 & 0xFFFFu, l1 & 0xFFFFu, l2 & 0xFFFFu, l3 & 0xFFFFu);
}
fn gf_zero() -> GoldilocksField {
return gf_from_limbs(0u, 0u, 0u, 0u);
}
fn gf_one() -> GoldilocksField {
return gf_from_limbs(1u, 0u, 0u, 0u);
}
fn gf_from_u32(val: u32) -> GoldilocksField {
return GoldilocksField(val & 0xFFFFu, (val >> 16u) & 0xFFFFu, 0u, 0u);
}
// Convert a 64-bit value (as two u32s) to GoldilocksField
fn gf_from_u64_parts(low: u32, high: u32) -> GoldilocksField {
var result = GoldilocksField(
low & 0xFFFFu, // bits 0-15
(low >> 16u) & 0xFFFFu, // bits 16-31
high & 0xFFFFu, // bits 32-47
(high >> 16u) & 0xFFFFu // bits 48-63
);
// Reduce if >= P
if (gf_compare(result, gf_from_limbs(P_LIMB0, P_LIMB1, P_LIMB2, P_LIMB3)) != 2u) {
result = gf_sub(result, gf_from_limbs(P_LIMB0, P_LIMB1, P_LIMB2, P_LIMB3));
}
return result;
}
// Addition with carry for u16 values (stored in u32)
// Returns vec2<u32>(sum, carry) where sum is masked to 16 bits
fn u16_add_with_carry(a: u32, b: u32, carry_in: u32) -> vec2<u32> {
let sum = a + b + carry_in;
return vec2<u32>(sum & 0xFFFFu, sum >> 16u);
}
// Subtraction with borrow for u16 values (stored in u32)
// Returns vec2<u32>(diff, borrow) where diff is masked to 16 bits
fn u16_sub_with_borrow(a: u32, b: u32, borrow_in: u32) -> vec2<u32> {
let temp = a + 0x10000u - b - borrow_in; // Add 2^16 to avoid underflow
return vec2<u32>(temp & 0xFFFFu, select(0u, 1u, temp < 0x10000u));
}
// Compare two GoldilocksField values
// Returns: 0 if a == b, 1 if a > b, 2 if a < b
fn gf_compare(a: GoldilocksField, b: GoldilocksField) -> u32 {
// Compare from most significant limb to least
if (a.limb3 != b.limb3) {
return select(2u, 1u, a.limb3 > b.limb3);
}
if (a.limb2 != b.limb2) {
return select(2u, 1u, a.limb2 > b.limb2);
}
if (a.limb1 != b.limb1) {
return select(2u, 1u, a.limb1 > b.limb1);
}
if (a.limb0 != b.limb0) {
return select(2u, 1u, a.limb0 > b.limb0);
}
return 0u; // Equal
}
// Goldilocks field addition
fn gf_add(a: GoldilocksField, b: GoldilocksField) -> GoldilocksField {
// Add limb by limb with carry propagation
let add0 = u16_add_with_carry(a.limb0, b.limb0, 0u);
let add1 = u16_add_with_carry(a.limb1, b.limb1, add0.y);
let add2 = u16_add_with_carry(a.limb2, b.limb2, add1.y);
let add3 = u16_add_with_carry(a.limb3, b.limb3, add2.y);
var result = GoldilocksField(add0.x, add1.x, add2.x, add3.x);
// Handle overflow: if carry out, we've computed a + b = result + 2^64
// In Goldilocks: 2^64 ≡ 2^32 - 1 (mod P)
if (add3.y != 0u) {
// Add 2^32 - 1 = 0xFFFFFFFF = [0xFFFF, 0xFFFF, 0, 0]
let eps_add0 = u16_add_with_carry(result.limb0, EPSILON_LIMB0, 0u);
let eps_add1 = u16_add_with_carry(result.limb1, EPSILON_LIMB1, eps_add0.y);
let eps_add2 = u16_add_with_carry(result.limb2, EPSILON_LIMB2, eps_add1.y);
let eps_add3 = u16_add_with_carry(result.limb3, EPSILON_LIMB3, eps_add2.y);
result = GoldilocksField(eps_add0.x, eps_add1.x, eps_add2.x, eps_add3.x);
// If adding EPSILON caused another overflow, add EPSILON again
if (eps_add3.y != 0u) {
let eps2_add0 = u16_add_with_carry(result.limb0, EPSILON_LIMB0, 0u);
let eps2_add1 = u16_add_with_carry(result.limb1, EPSILON_LIMB1, eps2_add0.y);
let eps2_add2 = u16_add_with_carry(result.limb2, EPSILON_LIMB2, eps2_add1.y);
let eps2_add3 = u16_add_with_carry(result.limb3, EPSILON_LIMB3, eps2_add2.y);
result = GoldilocksField(eps2_add0.x, eps2_add1.x, eps2_add2.x, eps2_add3.x);
}
}
// Final reduction if result >= P
let p = gf_from_limbs(P_LIMB0, P_LIMB1, P_LIMB2, P_LIMB3);
if (gf_compare(result, p) != 2u) { // if result >= P
result = gf_sub_no_underflow(result, p);
}
return result;
}
// Helper for subtraction without underflow (assumes a >= b)
fn gf_sub_no_underflow(a: GoldilocksField, b: GoldilocksField) -> GoldilocksField {
let sub0 = u16_sub_with_borrow(a.limb0, b.limb0, 0u);
let sub1 = u16_sub_with_borrow(a.limb1, b.limb1, sub0.y);
let sub2 = u16_sub_with_borrow(a.limb2, b.limb2, sub1.y);
let sub3 = u16_sub_with_borrow(a.limb3, b.limb3, sub2.y);
return GoldilocksField(sub0.x, sub1.x, sub2.x, sub3.x);
}
// Goldilocks field subtraction
fn gf_sub(a: GoldilocksField, b: GoldilocksField) -> GoldilocksField {
// If a >= b, do direct subtraction
if (gf_compare(a, b) != 2u) {
return gf_sub_no_underflow(a, b);
}
// Otherwise: a < b, so compute a - b + P
let p = gf_from_limbs(P_LIMB0, P_LIMB1, P_LIMB2, P_LIMB3);
let a_plus_p = gf_add_no_reduction(a, p);
return gf_sub_no_underflow(a_plus_p, b);
}
// Addition without final modular reduction (used internally)
fn gf_add_no_reduction(a: GoldilocksField, b: GoldilocksField) -> GoldilocksField {
let add0 = u16_add_with_carry(a.limb0, b.limb0, 0u);
let add1 = u16_add_with_carry(a.limb1, b.limb1, add0.y);
let add2 = u16_add_with_carry(a.limb2, b.limb2, add1.y);
let add3 = u16_add_with_carry(a.limb3, b.limb3, add2.y);
return GoldilocksField(add0.x, add1.x, add2.x, add3.x);
}
// Proper Goldilocks field multiplication for all values
// Multiply two u16 values to get a u32 result
fn u16_mul(a: u32, b: u32) -> u32 {
return (a & 0xFFFFu) * (b & 0xFFFFu);
}
// Simplified multiplication that handles carries more carefully
fn gf_mul_unreduced(a: GoldilocksField, b: GoldilocksField) -> array<u32, 8> {
var result: array<u32, 8>;
// Initialize all to zero
for (var i = 0u; i < 8u; i++) {
result[i] = 0u;
}
// Use double-precision arithmetic for each partial product
// and add with proper carry propagation
var temp: array<u32, 8>;
for (var i = 0u; i < 8u; i++) {
temp[i] = 0u;
}
// a.limb0 * b (multiply a.limb0 by each limb of b)
var carry = 0u;
var prod = a.limb0 * b.limb0;
temp[0] = prod & 0xFFFFu;
carry = prod >> 16u;
prod = a.limb0 * b.limb1 + carry;
temp[1] = prod & 0xFFFFu;
carry = prod >> 16u;
prod = a.limb0 * b.limb2 + carry;
temp[2] = prod & 0xFFFFu;
carry = prod >> 16u;
prod = a.limb0 * b.limb3 + carry;
temp[3] = prod & 0xFFFFu;
temp[4] = prod >> 16u;
// Add temp to result
carry = 0u;
for (var i = 0u; i < 8u; i++) {
let sum = result[i] + temp[i] + carry;
result[i] = sum & 0xFFFFu;
carry = sum >> 16u;
}
// Clear temp and do a.limb1 * b << 16
for (var i = 0u; i < 8u; i++) {
temp[i] = 0u;
}
carry = 0u;
prod = a.limb1 * b.limb0;
temp[1] = prod & 0xFFFFu;
carry = prod >> 16u;
prod = a.limb1 * b.limb1 + carry;
temp[2] = prod & 0xFFFFu;
carry = prod >> 16u;
prod = a.limb1 * b.limb2 + carry;
temp[3] = prod & 0xFFFFu;
carry = prod >> 16u;
prod = a.limb1 * b.limb3 + carry;
temp[4] = prod & 0xFFFFu;
temp[5] = prod >> 16u;
// Add temp to result
carry = 0u;
for (var i = 0u; i < 8u; i++) {
let sum = result[i] + temp[i] + carry;
result[i] = sum & 0xFFFFu;
carry = sum >> 16u;
}
// Clear temp and do a.limb2 * b << 32
for (var i = 0u; i < 8u; i++) {
temp[i] = 0u;
}
carry = 0u;
prod = a.limb2 * b.limb0;
temp[2] = prod & 0xFFFFu;
carry = prod >> 16u;
prod = a.limb2 * b.limb1 + carry;
temp[3] = prod & 0xFFFFu;
carry = prod >> 16u;
prod = a.limb2 * b.limb2 + carry;
temp[4] = prod & 0xFFFFu;
carry = prod >> 16u;
prod = a.limb2 * b.limb3 + carry;
temp[5] = prod & 0xFFFFu;
temp[6] = prod >> 16u;
// Add temp to result
carry = 0u;
for (var i = 0u; i < 8u; i++) {
let sum = result[i] + temp[i] + carry;
result[i] = sum & 0xFFFFu;
carry = sum >> 16u;
}
// Clear temp and do a.limb3 * b << 48
for (var i = 0u; i < 8u; i++) {
temp[i] = 0u;
}
carry = 0u;
prod = a.limb3 * b.limb0;
temp[3] = prod & 0xFFFFu;
carry = prod >> 16u;
prod = a.limb3 * b.limb1 + carry;
temp[4] = prod & 0xFFFFu;
carry = prod >> 16u;
prod = a.limb3 * b.limb2 + carry;
temp[5] = prod & 0xFFFFu;
carry = prod >> 16u;
prod = a.limb3 * b.limb3 + carry;
temp[6] = prod & 0xFFFFu;
temp[7] = prod >> 16u;
// Add temp to result
carry = 0u;
for (var i = 0u; i < 8u; i++) {
let sum = result[i] + temp[i] + carry;
result[i] = sum & 0xFFFFu;
carry = sum >> 16u;
}
return result;
}
// Reduce an 8-limb number modulo the Goldilocks prime
// Simplified version matching CPU algorithm exactly
fn gf_reduce_8limb(limbs: array<u32, 8>) -> GoldilocksField {
// Convert to 64-bit representation like CPU
let x_lo = gf_from_limbs(limbs[0], limbs[1], limbs[2], limbs[3]);
let x_hi = gf_from_limbs(limbs[4], limbs[5], limbs[6], limbs[7]);
// If high part is zero, just return low part
if (limbs[4] == 0u && limbs[5] == 0u && limbs[6] == 0u && limbs[7] == 0u) {
return x_lo;
}
// x_hi_hi = x_hi >> 32 (upper 32 bits of high part)
let x_hi_hi = gf_from_limbs(limbs[6], limbs[7], 0u, 0u);
// x_hi_lo = x_hi & NEG_ORDER (lower 32 bits of high part)
let x_hi_lo = gf_from_limbs(limbs[4], limbs[5], 0u, 0u);
// Step 1: t0 = x_lo - x_hi_hi (with underflow detection)
var t0: GoldilocksField;
var underflow = false;
// Perform subtraction with borrow propagation
let sub0 = u16_sub_with_borrow(x_lo.limb0, x_hi_hi.limb0, 0u);
let sub1 = u16_sub_with_borrow(x_lo.limb1, x_hi_hi.limb1, sub0.y);
let sub2 = u16_sub_with_borrow(x_lo.limb2, x_hi_hi.limb2, sub1.y);
let sub3 = u16_sub_with_borrow(x_lo.limb3, x_hi_hi.limb3, sub2.y);
t0 = GoldilocksField(sub0.x, sub1.x, sub2.x, sub3.x);
// Check for final borrow (underflow)
if (sub3.y != 0u) {
underflow = true;
}
// Step 2: if underflow { t0 -= NEG_ORDER; }
if (underflow) {
let eps_sub0 = u16_sub_with_borrow(t0.limb0, EPSILON_LIMB0, 0u);
let eps_sub1 = u16_sub_with_borrow(t0.limb1, EPSILON_LIMB1, eps_sub0.y);
let eps_sub2 = u16_sub_with_borrow(t0.limb2, EPSILON_LIMB2, eps_sub1.y);
let eps_sub3 = u16_sub_with_borrow(t0.limb3, EPSILON_LIMB3, eps_sub2.y);
t0 = GoldilocksField(eps_sub0.x, eps_sub1.x, eps_sub2.x, eps_sub3.x);
}
// Step 3: t1 = x_hi_lo * NEG_ORDER
// Since x_hi_lo fits in 32 bits and NEG_ORDER = 2^32 - 1, we can optimize:
// x_hi_lo * (2^32 - 1) = (x_hi_lo << 32) - x_hi_lo
let shifted = GoldilocksField(0u, 0u, x_hi_lo.limb0, x_hi_lo.limb1);
let t1_sub0 = u16_sub_with_borrow(shifted.limb0, x_hi_lo.limb0, 0u);
let t1_sub1 = u16_sub_with_borrow(shifted.limb1, x_hi_lo.limb1, t1_sub0.y);
let t1_sub2 = u16_sub_with_borrow(shifted.limb2, x_hi_lo.limb2, t1_sub1.y);
let t1_sub3 = u16_sub_with_borrow(shifted.limb3, x_hi_lo.limb3, t1_sub2.y);
let t1 = GoldilocksField(t1_sub0.x, t1_sub1.x, t1_sub2.x, t1_sub3.x);
// Step 4: result = t0 + t1 (with overflow handling like CPU)
let add0 = u16_add_with_carry(t0.limb0, t1.limb0, 0u);
let add1 = u16_add_with_carry(t0.limb1, t1.limb1, add0.y);
let add2 = u16_add_with_carry(t0.limb2, t1.limb2, add1.y);
let add3 = u16_add_with_carry(t0.limb3, t1.limb3, add2.y);
var result = GoldilocksField(add0.x, add1.x, add2.x, add3.x);
// If overflow, add NEG_ORDER (like CPU add_no_canonicalize_trashing_input)
if (add3.y != 0u) {
let eps_add0 = u16_add_with_carry(result.limb0, EPSILON_LIMB0, 0u);
let eps_add1 = u16_add_with_carry(result.limb1, EPSILON_LIMB1, eps_add0.y);
let eps_add2 = u16_add_with_carry(result.limb2, EPSILON_LIMB2, eps_add1.y);
let eps_add3 = u16_add_with_carry(result.limb3, EPSILON_LIMB3, eps_add2.y);
result = GoldilocksField(eps_add0.x, eps_add1.x, eps_add2.x, eps_add3.x);
}
return result;
}
// Main Goldilocks field multiplication
fn gf_mul(a: GoldilocksField, b: GoldilocksField) -> GoldilocksField {
// Handle special cases
if (a.limb0 == 0u && a.limb1 == 0u && a.limb2 == 0u && a.limb3 == 0u) { return gf_zero(); }
if (b.limb0 == 0u && b.limb1 == 0u && b.limb2 == 0u && b.limb3 == 0u) { return gf_zero(); }
if (a.limb0 == 1u && a.limb1 == 0u && a.limb2 == 0u && a.limb3 == 0u) { return b; }
if (b.limb0 == 1u && b.limb1 == 0u && b.limb2 == 0u && b.limb3 == 0u) { return a; }
// General case: multiply and reduce
let unreduced = gf_mul_unreduced(a, b);
return gf_reduce_8limb(unreduced);
}
// S-box: x^7 in Goldilocks field (efficient approach)
fn sbox(x: GoldilocksField) -> GoldilocksField {
let x2 = gf_mul(x, x);
let x4 = gf_mul(x2, x2);
let x6 = gf_mul(x4, x2);
return gf_mul(x6, x);
}
// External linear layer for width 12 using correct 4x4 MDS matrix
// Standard MDSMat4: [[2, 3, 1, 1], [1, 2, 3, 1], [1, 1, 2, 3], [3, 1, 1, 2]]
fn external_linear_layer(state: ptr<function, array<GoldilocksField, 12>>) {
// First apply the 4x4 MDS matrix to each consecutive 4 elements
for (var chunk = 0u; chunk < 3u; chunk++) {
let offset = chunk * 4u;
var chunk_state: array<GoldilocksField, 4>;
// Copy chunk
for (var i = 0u; i < 4u; i++) {
chunk_state[i] = (*state)[offset + i];
}
// Apply 4x4 MDS matrix transformation: [[2, 3, 1, 1], [1, 2, 3, 1], [1, 1, 2, 3], [3, 1, 1, 2]]
let two = gf_from_limbs(2u, 0u, 0u, 0u);
let three = gf_from_limbs(3u, 0u, 0u, 0u);
// new[0] = 2*x[0] + 3*x[1] + 1*x[2] + 1*x[3]
let new_0 = gf_add(gf_add(gf_add(
gf_mul(chunk_state[0], two),
gf_mul(chunk_state[1], three)),
chunk_state[2]),
chunk_state[3]);
// new[1] = 1*x[0] + 2*x[1] + 3*x[2] + 1*x[3]
let new_1 = gf_add(gf_add(gf_add(
chunk_state[0],
gf_mul(chunk_state[1], two)),
gf_mul(chunk_state[2], three)),
chunk_state[3]);
// new[2] = 1*x[0] + 1*x[1] + 2*x[2] + 3*x[3]
let new_2 = gf_add(gf_add(gf_add(
chunk_state[0],
chunk_state[1]),
gf_mul(chunk_state[2], two)),
gf_mul(chunk_state[3], three));
// new[3] = 3*x[0] + 1*x[1] + 1*x[2] + 2*x[3]
let new_3 = gf_add(gf_add(gf_add(
gf_mul(chunk_state[0], three),
chunk_state[1]),
chunk_state[2]),
gf_mul(chunk_state[3], two));
// Copy back
(*state)[offset + 0u] = new_0;
(*state)[offset + 1u] = new_1;
(*state)[offset + 2u] = new_2;
(*state)[offset + 3u] = new_3;
}
// Now apply the circulant matrix part
// Precompute the four sums of every four elements
var sums: array<GoldilocksField, 4>;
for (var k = 0u; k < 4u; k++) {
sums[k] = gf_zero();
for (var j = k; j < 12u; j += 4u) {
sums[k] = gf_add(sums[k], (*state)[j]);
}
}
// Add the appropriate sum to each element
for (var i = 0u; i < 12u; i++) {
(*state)[i] = gf_add((*state)[i], sums[i % 4u]);
}
}
// Internal linear layer using diagonal matrix for width 12
fn internal_linear_layer(state: ptr<function, array<GoldilocksField, 12>>) {
var result: array<GoldilocksField, 12>;
// Sum all elements
var sum = gf_zero();
for (var i = 0u; i < 12u; i++) {
sum = gf_add(sum, (*state)[i]);
}
// Apply diagonal matrix: result[i] = state[i] * diag[i] + sum
for (var i = 0u; i < 12u; i++) {
let diag_val = gf_from_u64_parts(
MDS_MATRIX_DIAG_12[i][0], // low 32 bits
MDS_MATRIX_DIAG_12[i][1] // high 32 bits
);
let scaled = gf_mul((*state)[i], diag_val);
result[i] = gf_add(scaled, sum);
}
// Copy result back to state
for (var i = 0u; i < 12u; i++) {
(*state)[i] = result[i];
}
}
// Fixed Poseidon2 permutation with proper structure
fn poseidon2_permute(state: ptr<function, array<GoldilocksField, 12>>) {
// Initial external rounds (4 rounds)
for (var round = 0u; round < 4u; round++) {
// Add round constants
for (var i = 0u; i < 12u; i++) {
(*state)[i] = gf_add((*state)[i], gf_from_const(INITIAL_EXTERNAL_CONSTANTS[round][i]));
}
// S-box on all elements
for (var i = 0u; i < 12u; i++) {
(*state)[i] = sbox((*state)[i]);
}
// External linear layer (4x4 MDS matrix)
external_linear_layer(state);
}
// Internal rounds (22 rounds)
for (var round = 0u; round < 22u; round++) {
// Add round constant to first element only
(*state)[0] = gf_add((*state)[0], gf_from_const(INTERNAL_CONSTANTS[round]));
// S-box on first element only
(*state)[0] = sbox((*state)[0]);
// Internal linear layer (diagonal matrix)
internal_linear_layer(state);
}
// Terminal external rounds (4 rounds)
for (var round = 0u; round < 4u; round++) {
// Add round constants
for (var i = 0u; i < 12u; i++) {
(*state)[i] = gf_add((*state)[i], gf_from_const(TERMINAL_EXTERNAL_CONSTANTS[round][i]));
}
// S-box on all elements
for (var i = 0u; i < 12u; i++) {
(*state)[i] = sbox((*state)[i]);
}
// External linear layer (4x4 MDS matrix)
external_linear_layer(state);
}
}
// Convert bytes to Goldilocks field elements matching reference implementation
// Reference uses 4 bytes per field element with injective padding, creating 25 field elements from 96 bytes
fn bytes_to_field_elements(input: array<u32, 24>) -> array<GoldilocksField, 25> {
var felts: array<GoldilocksField, 25>;
// Convert u32 array to bytes (96 bytes total)
var bytes: array<u32, 96>; // Using u32s to store bytes for easier processing
for (var i = 0u; i < 24u; i++) {
let val = input[i];
bytes[i * 4u + 0u] = val & 0xFFu; // byte 0
bytes[i * 4u + 1u] = (val >> 8u) & 0xFFu; // byte 1
bytes[i * 4u + 2u] = (val >> 16u) & 0xFFu; // byte 2
bytes[i * 4u + 3u] = (val >> 24u) & 0xFFu; // byte 3
}
// Apply injective padding: add 1 byte, then pad with zeros to 4-byte alignment
var padded_len = 96u + 1u; // 96 bytes + 1 marker byte = 97
let padding_needed = (4u - (padded_len % 4u)) % 4u;
padded_len = padded_len + padding_needed; // Should be 100 bytes (25 u32s worth)
// Create padded byte array
var padded_bytes: array<u32, 100>;
for (var i = 0u; i < 96u; i++) {
padded_bytes[i] = bytes[i];
}
padded_bytes[96] = 1u; // End marker
for (var i = 97u; i < 100u; i++) {
padded_bytes[i] = 0u; // Padding zeros
}
// Convert every 4 bytes to one field element (25 field elements total)
for (var i = 0u; i < 25u; i++) {
let byte_idx = i * 4u;
// Create u32 from 4 bytes in little-endian order
let val = padded_bytes[byte_idx] |
(padded_bytes[byte_idx + 1u] << 8u) |
(padded_bytes[byte_idx + 2u] << 16u) |
(padded_bytes[byte_idx + 3u] << 24u);
felts[i] = gf_from_u32(val);
}
return felts;
}
// Convert field elements back to bytes
fn field_elements_to_bytes(felts: array<GoldilocksField, 4>) -> array<u32, 8> {
var result: array<u32, 8>;
for (var i = 0u; i < 4u; i++) {
result[i * 2u] = felts[i].limb0 | (felts[i].limb1 << 16u);
result[i * 2u + 1u] = felts[i].limb2 | (felts[i].limb3 << 16u);
}
return result;
}
// Fixed Poseidon2 hash function with proper sponge construction
fn poseidon2_hash_squeeze_twice(input: array<u32, 24>) -> array<u32, 16> {
var state: array<GoldilocksField, 12>;
// Initialize state to zero
for (var i = 0u; i < 12u; i++) {
state[i] = gf_zero();
}
// Convert input to field elements (25 total)
let input_felts = bytes_to_field_elements(input);
// Sponge construction matching CPU reference exactly:
// CPU processes field elements using push_to_buf() which absorbs in chunks of RATE=4
// Process first 24 elements (6 complete chunks of 4)
for (var chunk = 0u; chunk < 6u; chunk++) {
// Absorb 4 elements for this chunk
for (var i = 0u; i < 4u; i++) {
let felt_idx = chunk * 4u + i;
state[i] = gf_add(state[i], input_felts[felt_idx]);
}
// Permute after each complete chunk
poseidon2_permute(&state);
}
// Now we have element 24 (the padding marker = 1) remaining
// This simulates CPU's finalize_twice adding ONE to buffer position 0
state[0] = gf_add(state[0], input_felts[24u]); // Add the padding marker (should be 1)
// Final permutation (CPU calls permute after completing the block)
poseidon2_permute(&state);
// First squeeze - get first 4 field elements
let first_output = field_elements_to_bytes(array<GoldilocksField, 4>(
state[0], state[1], state[2], state[3]
));
// Second squeeze
poseidon2_permute(&state);
let second_output = field_elements_to_bytes(array<GoldilocksField, 4>(
state[0], state[1], state[2], state[3]
));
// Combine both squeezes into 64-byte output
var result: array<u32, 16>;
for (var i = 0u; i < 8u; i++) {
result[i] = first_output[i];
result[i + 8u] = second_output[i];
}
return result;
}
// Double Poseidon2 hash (like Bitcoin's double SHA256)
fn double_hash(input: array<u32, 24>) -> array<u32, 16> {
let first_hash = poseidon2_hash_squeeze_twice(input);
// Convert back to input format for second hash
var second_input: array<u32, 24>;
for (var i = 0u; i < 16u; i++) {
second_input[i] = first_hash[i];
}
// Pad remaining with zeros
for (var i = 16u; i < 24u; i++) {
second_input[i] = 0u;
}
return poseidon2_hash_squeeze_twice(second_input);
}
// Check if hash < target (U512 comparison)
fn is_below_target(hash: array<u32, 16>, difficulty_tgt: array<u32, 16>) -> bool {
// Compare from most significant to least significant
for (var i = 0u; i < 16u; i++) {
if (hash[15u - i] < difficulty_tgt[15u - i]) {
return true;
} else if (hash[15u - i] > difficulty_tgt[15u - i]) {
return false;
}
}
return false; // Equal, not below
}
// No main function - individual tests will create their own entry points