From 0381b36ac7c4de0e286fb7d71c5ead81aee204a9 Mon Sep 17 00:00:00 2001
From: Chris Duncan <chris@zoso.dev>
Date: Fri, 27 Feb 2026 00:03:35 -0800
Subject: [PATCH] Pointers, vectors, and doubling.

Use pointers for field element constants and simplify scalarbase copy setup. Implement point doubling function. Vectorize selection logic and use built-in for swapping bits. Tweak error handling, maybe fix liftString at some point. Use immediate offsets instead of pointer arithmetic where possible. Pass pointers directly to scalarmult, add, and cswap.
---
 assembly/nano-nacl.ts | 633 ++++++++++++++++++++++++------------------
 index.ts              |   9 +-
 2 files changed, 371 insertions(+), 271 deletions(-)

diff --git a/assembly/nano-nacl.ts b/assembly/nano-nacl.ts
index 87b811a..1b816d0 100644
--- a/assembly/nano-nacl.ts
+++ b/assembly/nano-nacl.ts
@@ -189,12 +189,14 @@ const PUBLICKEY_BYTES: i32 = 32
 const SECRETKEY_BYTES: i32 = PRIVATEKEY_BYTES + PUBLICKEY_BYTES
 const SIGNATURE_BYTES: i32 = 64
 const SIGNEDBLOCKHASH_BYTES: i32 = SIGNATURE_BYTES + BLOCKHASH_BYTES
-const D: StaticArray<i32> = StaticArray.fromArray<i32>([0x78a3, 0x1359, 0x4dca, 0x75eb, 0xd8ab, 0x4141, 0x0a4d, 0x0070, 0xe898, 0x7779, 0x4079, 0x8cc7, 0xfe73, 0x2b6f, 0x6cee, 0x5203])
-const D2: StaticArray<i32> = StaticArray.fromArray<i32>([0xf159, 0x26b2, 0x9b94, 0xebd6, 0xb156, 0x8283, 0x149a, 0x00e0, 0xd130, 0xeef3, 0x80f2, 0x198e, 0xfce7, 0x56df, 0xd9dc, 0x2406])
-const X: StaticArray<i32> = StaticArray.fromArray<i32>([0xd51a, 0x8f25, 0x2d60, 0xc956, 0xa7b2, 0x9525, 0xc760, 0x692c, 0xdc5c, 0xfdd6, 0xe231, 0xc0a4, 0x53fe, 0xcd6e, 0x36d3, 0x2169])
-const Y: StaticArray<i32> = StaticArray.fromArray<i32>([0x6658, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666])
-const I: StaticArray<i32> = StaticArray.fromArray<i32>([0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, 0x2f43, 0xd7a7, 0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1, 0x2480, 0x2b83])
-const XY: StaticArray<i32> = StaticArray.fromArray<i32>([0xdd90, 0xa5b7, 0x8ab3, 0x6dde, 0x52f5, 0x7751, 0x9f80, 0x20f0, 0xe37d, 0x64ab, 0x4e8e, 0x66ea, 0x7665, 0xd78b, 0x5f0f, 0xe787])
+
+const ZERO = changetype<usize>(new StaticArray<i32>(16))
+const D = changetype<usize>(StaticArray.fromArray<i32>([0x78a3, 0x1359, 0x4dca, 0x75eb, 0xd8ab, 0x4141, 0x0a4d, 0x0070, 0xe898, 0x7779, 0x4079, 0x8cc7, 0xfe73, 0x2b6f, 0x6cee, 0x5203]))
+const D2 = changetype<usize>(StaticArray.fromArray<i32>([0xf159, 0x26b2, 0x9b94, 0xebd6, 0xb156, 0x8283, 0x149a, 0x00e0, 0xd130, 0xeef3, 0x80f2, 0x198e, 0xfce7, 0x56df, 0xd9dc, 0x2406]))
+const X = changetype<usize>(StaticArray.fromArray<i32>([0xd51a, 0x8f25, 0x2d60, 0xc956, 0xa7b2, 0x9525, 0xc760, 0x692c, 0xdc5c, 0xfdd6, 0xe231, 0xc0a4, 0x53fe, 0xcd6e, 0x36d3, 0x2169]))
+const Y = changetype<usize>(StaticArray.fromArray<i32>([0x6658, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666]))
+const I = changetype<usize>(StaticArray.fromArray<i32>([0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, 0x2f43, 0xd7a7, 0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1, 0x2480, 0x2b83]))
+const XY = changetype<usize>(StaticArray.fromArray<i32>([0xdd90, 0xa5b7, 0x8ab3, 0x6dde, 0x52f5, 0x7751, 0x9f80, 0x20f0, 0xe37d, 0x64ab, 0x4e8e, 0x66ea, 0x7665, 0xd78b, 0x5f0f, 0xe787]))
 
 // Static I/O buffers
 const INPUT_BUFFER = memory.data(128)
@@ -208,11 +210,12 @@ function vn (x: StaticArray<u8>, y: StaticArray<u8>): bool {
 	return d !== 0
 }
 
+// o, a = StaticArray<i32>[16]
 const pow_c: StaticArray<i32> = new StaticArray<i32>(16)
-function pow2523 (o: StaticArray<i32>, a: StaticArray<i32>): void {
-	const c = pow_c
+function pow2523 (o: usize, a: usize): void {
+	const c = changetype<usize>(pow_c)
 	for (let i = 0; i < 16; i++) {
-		c[i] = a[i]
+		store<i32>(c + (i << 2), load<i32>(a + (i << 2)))
 	}
 	for (let i = 0; i < 249; i++) {
 		Square(c, c)
@@ -222,7 +225,7 @@ function pow2523 (o: StaticArray<i32>, a: StaticArray<i32>): void {
 	Square(c, c)
 	Multiply(c, c, a)
 	for (let i = 0; i < 16; i++) {
-		o[i] = c[i]
+		store<i32>(o + (i << 2), load<i32>(c + (i << 2)))
 	}
 }
 
@@ -236,11 +239,12 @@ function car25519 (o: StaticArray<i32>): void {
 	o[0] += 38 * c
 }
 
+// a = StaticArray<i32>[16]
 const inv_c: StaticArray<i32> = new StaticArray<i32>(16)
-function inv25519 (o: StaticArray<i32>, a: StaticArray<i32>): void {
-	const c = inv_c
+function inv25519 (o: StaticArray<i32>, a: usize): void {
+	const c = changetype<usize>(inv_c)
 	for (let i = 0; i < 16; i++) {
-		c[i] = a[i]
+		store<i32>(c + (i << 2), load<i32>(a + (i << 2)))
 	}
 	for (let i = 0; i < 249; i++) {
 		Square(c, c)
@@ -255,10 +259,11 @@ function inv25519 (o: StaticArray<i32>, a: StaticArray<i32>): void {
 	Square(c, c)
 	Multiply(c, c, a)
 	for (let i = 0; i < 16; i++) {
-		o[i] = c[i]
+		o[i] = load<i32>(c + (i << 2))
 	}
 }
 
+// a, b = StaticArray<i32>[16]
 const neq_c = new StaticArray<u8>(32)
 const neq_d = new StaticArray<u8>(32)
 function neq25519 (a: StaticArray<i32>, b: StaticArray<i32>): bool {
@@ -293,7 +298,7 @@ function pack25519 (o: StaticArray<u8>, n: StaticArray<i32>): void {
 		m[15] = t[15] - 0x7fff - ((m[14] >> 16) & 1)
 		b = (m[15] >> 16) & 1
 		m[14] &= 0xffff
-		sel25519(t, m, 1 - b)
+		sel25519(changetype<i32>(t), changetype<i32>(m), 1 - b)
 	}
 
 	for (let i = 0; i < 16; i++) {
@@ -303,76 +308,92 @@ function pack25519 (o: StaticArray<u8>, n: StaticArray<i32>): void {
 }
 
 const par_d = new StaticArray<u8>(32)
-function par25519 (a: StaticArray<i32>): u8 {
+function par25519 (a: usize): u8 {
 	const d = par_d
-	pack25519(d, a)
+	pack25519(d, changetype<StaticArray<i32>>(a))
 	return d[0] & 1
 }
 
-function sel25519 (p: StaticArray<i32>, q: StaticArray<i32>, b: i32): void {
-	let t: i32 = 0
-	const c: i32 = ~(b - 1)
-	for (let i = 0; i < 16; i++) {
-		t = c & (p[i] ^ q[i])
-		p[i] ^= t
-		q[i] ^= t
-	}
+// p, q = StaticArray<i32>[16]
+@inline
+function sel25519 (p: usize, q: usize, b: i32): void {
+	const c = v128.splat<u64>(0 - b)
+
+	let pi = v128.load(p)
+	let qi = v128.load(q)
+	v128.store(p, v128.bitselect(qi, pi, c))
+	v128.store(q, v128.bitselect(pi, qi, c))
+
+	pi = v128.load(p, 16)
+	qi = v128.load(q, 16)
+	v128.store(p, v128.bitselect(qi, pi, c), 16)
+	v128.store(q, v128.bitselect(pi, qi, c), 16)
+
+	pi = v128.load(p, 32)
+	qi = v128.load(q, 32)
+	v128.store(p, v128.bitselect(qi, pi, c), 32)
+	v128.store(q, v128.bitselect(pi, qi, c), 32)
+
+	pi = v128.load(p, 48)
+	qi = v128.load(q, 48)
+	v128.store(p, v128.bitselect(qi, pi, c), 48)
+	v128.store(q, v128.bitselect(pi, qi, c), 48)
 }
 
-function unpack25519 (o: StaticArray<i32>, n: StaticArray<u8>): void {
+function unpack25519 (oo: usize, n: StaticArray<u8>): void {
+	const o = changetype<StaticArray<i32>>(oo)
 	for (let i = 0; i < 16; i++) {
 		o[i] = i32(n[i << 1]) + (i32(n[(i << 1) + 1]) << 8)
 	}
 	o[15] &= (1 << 15) - 1
 }
 
+// o, a, b = StaticArray<i32>[16]
 @inline
-function Add (o: StaticArray<i32>, a: StaticArray<i32>, b: StaticArray<i32>): void {
-	o[0] = a[0] + b[0]
-	o[1] = a[1] + b[1]
-	o[2] = a[2] + b[2]
-	o[3] = a[3] + b[3]
-	o[4] = a[4] + b[4]
-	o[5] = a[5] + b[5]
-	o[6] = a[6] + b[6]
-	o[7] = a[7] + b[7]
-	o[8] = a[8] + b[8]
-	o[9] = a[9] + b[9]
-	o[10] = a[10] + b[10]
-	o[11] = a[11] + b[11]
-	o[12] = a[12] + b[12]
-	o[13] = a[13] + b[13]
-	o[14] = a[14] + b[14]
-	o[15] = a[15] + b[15]
+function Add (o: usize, a: usize, b: usize): void {
+	store<i32>(o, load<i32>(a) + load<i32>(b))
+	store<i32>(o, load<i32>(a, 4) + load<i32>(b, 4), 4)
+	store<i32>(o, load<i32>(a, 8) + load<i32>(b, 8), 8)
+	store<i32>(o, load<i32>(a, 12) + load<i32>(b, 12), 12)
+	store<i32>(o, load<i32>(a, 16) + load<i32>(b, 16), 16)
+	store<i32>(o, load<i32>(a, 20) + load<i32>(b, 20), 20)
+	store<i32>(o, load<i32>(a, 24) + load<i32>(b, 24), 24)
+	store<i32>(o, load<i32>(a, 28) + load<i32>(b, 28), 28)
+	store<i32>(o, load<i32>(a, 32) + load<i32>(b, 32), 32)
+	store<i32>(o, load<i32>(a, 36) + load<i32>(b, 36), 36)
+	store<i32>(o, load<i32>(a, 40) + load<i32>(b, 40), 40)
+	store<i32>(o, load<i32>(a, 44) + load<i32>(b, 44), 44)
+	store<i32>(o, load<i32>(a, 48) + load<i32>(b, 48), 48)
+	store<i32>(o, load<i32>(a, 52) + load<i32>(b, 52), 52)
+	store<i32>(o, load<i32>(a, 56) + load<i32>(b, 56), 56)
+	store<i32>(o, load<i32>(a, 60) + load<i32>(b, 60), 60)
 }
 
+// o, a, b = StaticArray<i32>[16]
 @inline
-function Subtract (o: StaticArray<i32>, a: StaticArray<i32>, b: StaticArray<i32>): void {
-	o[0] = a[0] - b[0]
-	o[1] = a[1] - b[1]
-	o[2] = a[2] - b[2]
-	o[3] = a[3] - b[3]
-	o[4] = a[4] - b[4]
-	o[5] = a[5] - b[5]
-	o[6] = a[6] - b[6]
-	o[7] = a[7] - b[7]
-	o[8] = a[8] - b[8]
-	o[9] = a[9] - b[9]
-	o[10] = a[10] - b[10]
-	o[11] = a[11] - b[11]
-	o[12] = a[12] - b[12]
-	o[13] = a[13] - b[13]
-	o[14] = a[14] - b[14]
-	o[15] = a[15] - b[15]
+function Subtract (o: usize, a: usize, b: usize): void {
+	store<i32>(o, load<i32>(a) - load<i32>(b))
+	store<i32>(o, load<i32>(a, 4) - load<i32>(b, 4), 4)
+	store<i32>(o, load<i32>(a, 8) - load<i32>(b, 8), 8)
+	store<i32>(o, load<i32>(a, 12) - load<i32>(b, 12), 12)
+	store<i32>(o, load<i32>(a, 16) - load<i32>(b, 16), 16)
+	store<i32>(o, load<i32>(a, 20) - load<i32>(b, 20), 20)
+	store<i32>(o, load<i32>(a, 24) - load<i32>(b, 24), 24)
+	store<i32>(o, load<i32>(a, 28) - load<i32>(b, 28), 28)
+	store<i32>(o, load<i32>(a, 32) - load<i32>(b, 32), 32)
+	store<i32>(o, load<i32>(a, 36) - load<i32>(b, 36), 36)
+	store<i32>(o, load<i32>(a, 40) - load<i32>(b, 40), 40)
+	store<i32>(o, load<i32>(a, 44) - load<i32>(b, 44), 44)
+	store<i32>(o, load<i32>(a, 48) - load<i32>(b, 48), 48)
+	store<i32>(o, load<i32>(a, 52) - load<i32>(b, 52), 52)
+	store<i32>(o, load<i32>(a, 56) - load<i32>(b, 56), 56)
+	store<i32>(o, load<i32>(a, 60) - load<i32>(b, 60), 60)
 }
 
+// o, a, b = StaticArray<i32>[16]
 const multiply_t = new StaticArray<i64>(32)
-function Multiply (oo: StaticArray<i32>, aa: StaticArray<i32>, bb: StaticArray<i32>): void {
-	const a = changetype<usize>(aa)
-	const b = changetype<usize>(bb)
-	const o = changetype<usize>(oo)
+function Multiply (o: usize, a: usize, b: usize): void {
 	const t = changetype<usize>(multiply_t.fill(0))
-
 	const b0 = v128.load(b)
 	const b4 = v128.load(b + 16)
 	const b8 = v128.load(b + 32)
@@ -425,7 +446,8 @@ function Multiply (oo: StaticArray<i32>, aa: StaticArray<i32>, bb: StaticArray<i
 	Normalize(o, t)
 }
 
-function Square (o: StaticArray<i32>, a: StaticArray<i32>): void {
+// o, a = StaticArray<i32>[16]
+function Square (o: usize, a: usize): void {
 	Multiply(o, a, a)
 }
 
@@ -444,128 +466,128 @@ function Square (o: StaticArray<i32>, a: StaticArray<i32>): void {
 function Normalize (o: usize, t: usize): void {
 	// reduce
 	let x = load<i64>(t)
-	let y = load<i64>(t + 128)
+	let y = load<i64>(t, 128)
 	store<i64>(t, x + (38 * y))
 
-	x = load<i64>(t + 8)
-	y = load<i64>(t + 136)
-	store<i64>(t + 8, x + (38 * y))
+	x = load<i64>(t, 8)
+	y = load<i64>(t, 136)
+	store<i64>(t, x + (38 * y), 8)
 
-	x = load<i64>(t + 16)
-	y = load<i64>(t + 144)
-	store<i64>(t + 16, x + (38 * y))
+	x = load<i64>(t, 16)
+	y = load<i64>(t, 144)
+	store<i64>(t, x + (38 * y), 16)
 
-	x = load<i64>(t + 24)
-	y = load<i64>(t + 152)
-	store<i64>(t + 24, x + (38 * y))
+	x = load<i64>(t, 24)
+	y = load<i64>(t, 152)
+	store<i64>(t, x + (38 * y), 24)
 
-	x = load<i64>(t + 32)
-	y = load<i64>(t + 160)
-	store<i64>(t + 32, x + (38 * y))
+	x = load<i64>(t, 32)
+	y = load<i64>(t, 160)
+	store<i64>(t, x + (38 * y), 32)
 
-	x = load<i64>(t + 40)
-	y = load<i64>(t + 168)
-	store<i64>(t + 40, x + (38 * y))
+	x = load<i64>(t, 40)
+	y = load<i64>(t, 168)
+	store<i64>(t, x + (38 * y), 40)
 
-	x = load<i64>(t + 48)
-	y = load<i64>(t + 176)
-	store<i64>(t + 48, x + (38 * y))
+	x = load<i64>(t, 48)
+	y = load<i64>(t, 176)
+	store<i64>(t, x + (38 * y), 48)
 
-	x = load<i64>(t + 56)
-	y = load<i64>(t + 184)
-	store<i64>(t + 56, x + (38 * y))
+	x = load<i64>(t, 56)
+	y = load<i64>(t, 184)
+	store<i64>(t, x + (38 * y), 56)
 
-	x = load<i64>(t + 64)
-	y = load<i64>(t + 192)
-	store<i64>(t + 64, x + (38 * y))
+	x = load<i64>(t, 64)
+	y = load<i64>(t, 192)
+	store<i64>(t, x + (38 * y), 64)
 
-	x = load<i64>(t + 72)
-	y = load<i64>(t + 200)
-	store<i64>(t + 72, x + (38 * y))
+	x = load<i64>(t, 72)
+	y = load<i64>(t, 200)
+	store<i64>(t, x + (38 * y), 72)
 
-	x = load<i64>(t + 80)
-	y = load<i64>(t + 208)
-	store<i64>(t + 80, x + (38 * y))
+	x = load<i64>(t, 80)
+	y = load<i64>(t, 208)
+	store<i64>(t, x + (38 * y), 80)
 
-	x = load<i64>(t + 88)
-	y = load<i64>(t + 216)
-	store<i64>(t + 88, x + (38 * y))
+	x = load<i64>(t, 88)
+	y = load<i64>(t, 216)
+	store<i64>(t, x + (38 * y), 88)
 
-	x = load<i64>(t + 96)
-	y = load<i64>(t + 224)
-	store<i64>(t + 96, x + (38 * y))
+	x = load<i64>(t, 96)
+	y = load<i64>(t, 224)
+	store<i64>(t, x + (38 * y), 96)
 
-	x = load<i64>(t + 104)
-	y = load<i64>(t + 232)
-	store<i64>(t + 104, x + (38 * y))
+	x = load<i64>(t, 104)
+	y = load<i64>(t, 232)
+	store<i64>(t, x + (38 * y), 104)
 
-	x = load<i64>(t + 112)
-	y = load<i64>(t + 240)
-	store<i64>(t + 112, x + (38 * y))
+	x = load<i64>(t, 112)
+	y = load<i64>(t, 240)
+	store<i64>(t, x + (38 * y), 112)
 
 	// first carry
 	let c: i64 = load<i64>(t)
 	store<i64>(t, c & 0xFFFF)
 	c >>= 16
 
-	c += load<i64>(t + 8)
-	store<i64>(t + 8, c & 0xFFFF)
+	c += load<i64>(t, 8)
+	store<i64>(t, c & 0xFFFF, 8)
 	c >>= 16
 
-	c += load<i64>(t + 16)
-	store<i64>(t + 16, c & 0xFFFF)
+	c += load<i64>(t, 16)
+	store<i64>(t, c & 0xFFFF, 16)
 	c >>= 16
 
-	c += load<i64>(t + 24)
-	store<i64>(t + 24, c & 0xFFFF)
+	c += load<i64>(t, 24)
+	store<i64>(t, c & 0xFFFF, 24)
 	c >>= 16
 
-	c += load<i64>(t + 32)
-	store<i64>(t + 32, c & 0xFFFF)
+	c += load<i64>(t, 32)
+	store<i64>(t, c & 0xFFFF, 32)
 	c >>= 16
 
-	c += load<i64>(t + 40)
-	store<i64>(t + 40, c & 0xFFFF)
+	c += load<i64>(t, 40)
+	store<i64>(t, c & 0xFFFF, 40)
 	c >>= 16
 
-	c += load<i64>(t + 48)
-	store<i64>(t + 48, c & 0xFFFF)
+	c += load<i64>(t, 48)
+	store<i64>(t, c & 0xFFFF, 48)
 	c >>= 16
 
-	c += load<i64>(t + 56)
-	store<i64>(t + 56, c & 0xFFFF)
+	c += load<i64>(t, 56)
+	store<i64>(t, c & 0xFFFF, 56)
 	c >>= 16
 
-	c += load<i64>(t + 64)
-	store<i64>(t + 64, c & 0xFFFF)
+	c += load<i64>(t, 64)
+	store<i64>(t, c & 0xFFFF, 64)
 	c >>= 16
 
-	c += load<i64>(t + 72)
-	store<i64>(t + 72, c & 0xFFFF)
+	c += load<i64>(t, 72)
+	store<i64>(t, c & 0xFFFF, 72)
 	c >>= 16
 
-	c += load<i64>(t + 80)
-	store<i64>(t + 80, c & 0xFFFF)
+	c += load<i64>(t, 80)
+	store<i64>(t, c & 0xFFFF, 80)
 	c >>= 16
 
-	c += load<i64>(t + 88)
-	store<i64>(t + 88, c & 0xFFFF)
+	c += load<i64>(t, 88)
+	store<i64>(t, c & 0xFFFF, 88)
 	c >>= 16
 
-	c += load<i64>(t + 96)
-	store<i64>(t + 96, c & 0xFFFF)
+	c += load<i64>(t, 96)
+	store<i64>(t, c & 0xFFFF, 96)
 	c >>= 16
 
-	c += load<i64>(t + 104)
-	store<i64>(t + 104, c & 0xFFFF)
+	c += load<i64>(t, 104)
+	store<i64>(t, c & 0xFFFF, 104)
 	c >>= 16
 
-	c += load<i64>(t + 112)
-	store<i64>(t + 112, c & 0xFFFF)
+	c += load<i64>(t, 112)
+	store<i64>(t, c & 0xFFFF, 112)
 	c >>= 16
 
-	c += load<i64>(t + 120)
-	store<i64>(t + 120, c & 0xFFFF)
+	c += load<i64>(t, 120)
+	store<i64>(t, c & 0xFFFF, 120)
 	c >>= 16
 
 	store<i64>(t, load<i64>(t) + (38 * c))
@@ -575,146 +597,215 @@ function Normalize (o: usize, t: usize): void {
 	store<i32>(o, c & 0xFFFF)
 	c >>= 16
 
-	c += load<i64>(t + 8)
-	store<i32>(o + 4, c & 0xFFFF)
+	c += load<i64>(t, 8)
+	store<i32>(o, c & 0xFFFF, 4)
 	c >>= 16
 
-	c += load<i64>(t + 16)
-	store<i32>(o + 8, c & 0xFFFF)
+	c += load<i64>(t, 16)
+	store<i32>(o, c & 0xFFFF, 8)
 	c >>= 16
 
-	c += load<i64>(t + 24)
-	store<i32>(o + 12, c & 0xFFFF)
+	c += load<i64>(t, 24)
+	store<i32>(o, c & 0xFFFF, 12)
 	c >>= 16
 
-	c += load<i64>(t + 32)
-	store<i32>(o + 16, c & 0xFFFF)
+	c += load<i64>(t, 32)
+	store<i32>(o, c & 0xFFFF, 16)
 	c >>= 16
 
-	c += load<i64>(t + 40)
-	store<i32>(o + 20, c & 0xFFFF)
+	c += load<i64>(t, 40)
+	store<i32>(o, c & 0xFFFF, 20)
 	c >>= 16
 
-	c += load<i64>(t + 48)
-	store<i32>(o + 24, c & 0xFFFF)
+	c += load<i64>(t, 48)
+	store<i32>(o, c & 0xFFFF, 24)
 	c >>= 16
 
-	c += load<i64>(t + 56)
-	store<i32>(o + 28, c & 0xFFFF)
+	c += load<i64>(t, 56)
+	store<i32>(o, c & 0xFFFF, 28)
 	c >>= 16
 
-	c += load<i64>(t + 64)
-	store<i32>(o + 32, c & 0xFFFF)
+	c += load<i64>(t, 64)
+	store<i32>(o, c & 0xFFFF, 32)
 	c >>= 16
 
-	c += load<i64>(t + 72)
-	store<i32>(o + 36, c & 0xFFFF)
+	c += load<i64>(t, 72)
+	store<i32>(o, c & 0xFFFF, 36)
 	c >>= 16
 
-	c += load<i64>(t + 80)
-	store<i32>(o + 40, c & 0xFFFF)
+	c += load<i64>(t, 80)
+	store<i32>(o, c & 0xFFFF, 40)
 	c >>= 16
 
-	c += load<i64>(t + 88)
-	store<i32>(o + 44, c & 0xFFFF)
+	c += load<i64>(t, 88)
+	store<i32>(o, c & 0xFFFF, 44)
 	c >>= 16
 
-	c += load<i64>(t + 96)
-	store<i32>(o + 48, c & 0xFFFF)
+	c += load<i64>(t, 96)
+	store<i32>(o, c & 0xFFFF, 48)
 	c >>= 16
 
-	c += load<i64>(t + 104)
-	store<i32>(o + 52, c & 0xFFFF)
+	c += load<i64>(t, 104)
+	store<i32>(o, c & 0xFFFF, 52)
 	c >>= 16
 
-	c += load<i64>(t + 112)
-	store<i32>(o + 56, c & 0xFFFF)
+	c += load<i64>(t, 112)
+	store<i32>(o, c & 0xFFFF, 56)
 	c >>= 16
 
-	c += load<i64>(t + 120)
-	store<i32>(o + 60, c & 0xFFFF)
+	c += load<i64>(t, 120)
+	store<i32>(o, c & 0xFFFF, 60)
 	c >>= 16
 
 	store<i64>(o, load<i64>(o) + (38 * c))
 }
 
-const a: StaticArray<i32> = new StaticArray<i32>(16)
-const b: StaticArray<i32> = new StaticArray<i32>(16)
-const c: StaticArray<i32> = new StaticArray<i32>(16)
-const d: StaticArray<i32> = new StaticArray<i32>(16)
-const e: StaticArray<i32> = new StaticArray<i32>(16)
-const f: StaticArray<i32> = new StaticArray<i32>(16)
-const g: StaticArray<i32> = new StaticArray<i32>(16)
-const h: StaticArray<i32> = new StaticArray<i32>(16)
-const t: StaticArray<i32> = new StaticArray<i32>(16)
-function add (p: StaticArray<i32>[], q: StaticArray<i32>[]): void {
-	Subtract(a, p[1], p[0])
-	Subtract(t, q[1], q[0])
+// p, q = StaticArray<i32>[4][16]
+const add_a: StaticArray<i32> = new StaticArray<i32>(16)
+const add_b: StaticArray<i32> = new StaticArray<i32>(16)
+const add_c: StaticArray<i32> = new StaticArray<i32>(16)
+const add_d: StaticArray<i32> = new StaticArray<i32>(16)
+const add_e: StaticArray<i32> = new StaticArray<i32>(16)
+const add_f: StaticArray<i32> = new StaticArray<i32>(16)
+const add_g: StaticArray<i32> = new StaticArray<i32>(16)
+const add_h: StaticArray<i32> = new StaticArray<i32>(16)
+const add_t: StaticArray<i32> = new StaticArray<i32>(16)
+function add (p: usize, q: usize): void {
+	const a = changetype<usize>(add_a)
+	const b = changetype<usize>(add_b)
+	const c = changetype<usize>(add_c)
+	const d = changetype<usize>(add_d)
+	const e = changetype<usize>(add_e)
+	const f = changetype<usize>(add_f)
+	const g = changetype<usize>(add_g)
+	const h = changetype<usize>(add_h)
+	const t = changetype<usize>(add_t)
+
+	const px = p
+	const py = p + 64
+	const pz = p + 128
+	const pt = p + 192
+
+	const qx = q
+	const qy = q + 64
+	const qz = q + 128
+	const qt = q + 192
+
+	Subtract(a, py, px)
+	Subtract(t, qy, qx)
 	Multiply(a, a, t)
-	Add(b, p[0], p[1])
-	Add(t, q[0], q[1])
+	Add(b, px, py)
+	Add(t, qx, qy)
 	Multiply(b, b, t)
-	Multiply(c, p[3], q[3])
+	Multiply(c, pt, qt)
 	Multiply(c, c, D2)
-	Multiply(d, p[2], q[2])
+	Multiply(d, pz, qz)
 	Add(d, d, d)
 	Subtract(e, b, a)
 	Subtract(f, d, c)
 	Add(g, d, c)
 	Add(h, b, a)
 
-	Multiply(p[0], e, f)
-	Multiply(p[1], h, g)
-	Multiply(p[2], g, f)
-	Multiply(p[3], e, h)
+	Multiply(px, e, f)
+	Multiply(py, h, g)
+	Multiply(pz, g, f)
+	Multiply(pt, e, h)
 }
 
-function cswap (p: StaticArray<i32>[], q: StaticArray<i32>[], b: i32): void {
-	for (let i = 0; i < 4; i++) {
-		sel25519(p[i], q[i], b)
-	}
+/**
+ * A = X^2, B = Y^2, C = 2*Z^2, D = -A  (in mod p, Negate is p - A; tweetnacl typically does 0 - A)
+ * E = (X+Y)^2 - A - B
+ * G = D + B, F = G - C, H = D - B
+ * X3 = E*F, Y3 = G*H, Z3 = F*G, T3 = E*H
+ */
+function double (p: usize): void {
+	const a = changetype<usize>(add_a)
+	const b = changetype<usize>(add_b)
+	const c = changetype<usize>(add_c)
+	const d = changetype<usize>(add_d)
+	const e = changetype<usize>(add_e)
+	const f = changetype<usize>(add_f)
+	const g = changetype<usize>(add_g)
+	const h = changetype<usize>(add_h)
+
+	const px = p
+	const py = p + 64
+	const pz = p + 128
+	const pt = p + 192
+
+	Square(a, px)
+	Square(b, py)
+	Square(c, pz)
+	Add(c, c, c)
+	Subtract(d, ZERO, a)
+
+	Add(e, px, py)
+	Square(e, e)
+	Subtract(e, e, a)
+	Subtract(e, e, b)
+
+	Add(g, d, b)
+	Subtract(f, g, c)
+	Subtract(h, d, b)
+
+	Multiply(px, e, f)
+	Multiply(py, g, h)
+	Multiply(pz, f, g)
+	Multiply(pt, e, h)
 }
 
+// p, q = StaticArray<i32>[16]
+// offsets i32x16 = 64 bytes
+@inline
+function cswap (p: usize, q: usize, b: i32): void {
+	sel25519(p, q, b)
+	sel25519(p + 64, q + 64, b)
+	sel25519(p + 128, q + 128, b)
+	sel25519(p + 192, q + 192, b)
+}
+
+// p = StaticArray<i32>[4][16]
 const tx: StaticArray<i32> = new StaticArray<i32>(16)
 const ty: StaticArray<i32> = new StaticArray<i32>(16)
 const zi: StaticArray<i32> = new StaticArray<i32>(16)
-function pack (r: StaticArray<u8>, p: StaticArray<i32>[]): void {
-	inv25519(zi, p[2])
-	Multiply(tx, p[0], zi)
-	Multiply(ty, p[1], zi)
+function pack (r: StaticArray<u8>, p: usize): void {
+	inv25519(zi, p + 128)
+	Multiply(changetype<usize>(tx), p, changetype<usize>(zi))
+	Multiply(changetype<usize>(ty), p + 64, changetype<usize>(zi))
 	pack25519(r, ty)
-	r[31] ^= par25519(tx) << 7
+	r[31] ^= par25519(changetype<usize>(tx)) << 7
 }
 
-function scalarmult (p: StaticArray<i32>[], q: StaticArray<i32>[], s: StaticArray<u8>): void {
+// p, q = StaticArray<i32>[4][16]
+function scalarmult (p: usize, q: usize, s: StaticArray<u8>): void {
 	for (let i = 255; i >= 0; i--) {
 		const b: i32 = (s[i >> 3] >> u8(i & 7)) & 1
 		cswap(p, q, b)
 		add(q, p)
-		add(p, p)
+		double(p)
 		cswap(p, q, b)
 	}
 }
 
-const scalarbase_q: StaticArray<i32>[] = [new StaticArray<i32>(16), new StaticArray<i32>(16), new StaticArray<i32>(16), new StaticArray<i32>(16)]
-function scalarbase (p: StaticArray<i32>[], s: StaticArray<u8>): void {
-	const q = scalarbase_q
-	for (let i = 0; i < 16; i++) {
-		q[0][i] = X[i]
-		q[1][i] = Y[i]
-		q[2][i] = 0
-		q[3][i] = XY[i]
-	}
-	q[2][0] = 1
+// p = StaticArray<i32>[4][16]
+const scalarbase_q = new StaticArray<i32>(64)
+function scalarbase (p: usize, s: StaticArray<u8>): void {
+	const q = changetype<usize>(scalarbase_q)
+	memory.copy(q, X, 64)
+	memory.copy(q + 64, Y, 64)
+	memory.fill(q + 128, 0, 64)
+	memory.copy(q + 192, XY, 64)
+	store<i32>(q, 1, 128)
 	scalarmult(p, q, s)
 }
 
-const L: StaticArray<i32> = StaticArray.fromArray<i32>([
+// Group order of the curve ≈ 2²⁵²
+const L: usize = changetype<usize>(StaticArray.fromArray<i32>([
 	0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58,
 	0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10
-])
+]))
 
 function modL (r: StaticArray<u8>, x: StaticArray<i32>): void {
 	let c: i32
@@ -724,7 +815,7 @@ function modL (r: StaticArray<u8>, x: StaticArray<i32>): void {
 		c = 0
 		const xi = x[i]
 		for (let j = i - 32, k = i - 12; j < k; j++) {
-			t = (xi * L[j - (i - 32)]) << 4
+			t = (xi * load<i32>(L + ((j - (i - 32)) << 2))) << 4
 			v = x[j] + c - t
 			c = (v + 128) >> 8
 			x[j] = v - (c << 8)
@@ -735,12 +826,12 @@ function modL (r: StaticArray<u8>, x: StaticArray<i32>): void {
 	c = 0
 	const x31 = x[31]
 	for (let j = 0; j < 32; j++) {
-		x[j] += c - (x31 >> 4) * L[j]
+		x[j] += c - (x31 >> 4) * load<i32>(L + (j << 2))
 		c = x[j] >> 8
 		x[j] &= 255
 	}
 	for (let j = 0; j < 32; j++) {
-		x[j] -= c * L[j]
+		x[j] -= c * load<i32>(L + (j << 2))
 	}
 	for (let i = 0; i < 32; i++) {
 		x[i + 1] += x[i] >> 8
@@ -748,8 +839,9 @@ function modL (r: StaticArray<u8>, x: StaticArray<i32>): void {
 	}
 }
 
-const x = new StaticArray<i32>(64)
+const reduce_x = new StaticArray<i32>(64)
 function reduce (r: StaticArray<u8>): void {
+	const x = reduce_x
 	for (let i = 0; i < 64; i++) {
 		x[i] = i32(r[i])
 		r[i] = 0
@@ -757,22 +849,28 @@ function reduce (r: StaticArray<u8>): void {
 	modL(r, x)
 }
 
+// r = StaticArray<i32>[4][16]
+const unpack_chk: StaticArray<i32> = new StaticArray<i32>(16)
+const unpack_num: StaticArray<i32> = new StaticArray<i32>(16)
+const unpack_den: StaticArray<i32> = new StaticArray<i32>(16)
+const unpack_den2: StaticArray<i32> = new StaticArray<i32>(16)
+const unpack_den4: StaticArray<i32> = new StaticArray<i32>(16)
+const unpack_den6: StaticArray<i32> = new StaticArray<i32>(16)
 const unpack_t: StaticArray<i32> = new StaticArray<i32>(16)
-const chk: StaticArray<i32> = new StaticArray<i32>(16)
-const num: StaticArray<i32> = new StaticArray<i32>(16)
-const den: StaticArray<i32> = new StaticArray<i32>(16)
-const den2: StaticArray<i32> = new StaticArray<i32>(16)
-const den4: StaticArray<i32> = new StaticArray<i32>(16)
-const den6: StaticArray<i32> = new StaticArray<i32>(16)
-const z: StaticArray<i32> = new StaticArray<i32>(16)
-function unpackneg (r: Array<StaticArray<i32>>, p: StaticArray<u8>): i8 {
-	const t = unpack_t
-
-	unpack25519(r[1], p)
-	Square(num, r[1])
+function unpackneg (r: usize, p: StaticArray<u8>): i8 {
+	const chk = changetype<usize>(unpack_chk)
+	const num = changetype<usize>(unpack_num)
+	const den = changetype<usize>(unpack_den)
+	const den2 = changetype<usize>(unpack_den2)
+	const den4 = changetype<usize>(unpack_den4)
+	const den6 = changetype<usize>(unpack_den6)
+	const t = changetype<usize>(unpack_t)
+
+	unpack25519(r + 64, p)
+	Square(num, r + 64)
 	Multiply(den, num, D)
-	Subtract(num, num, r[2])
-	Add(den, r[2], den)
+	Subtract(num, num, r + 128)
+	Add(den, r + 128, den)
 
 	Square(den2, den)
 	Square(den4, den2)
@@ -784,37 +882,37 @@ function unpackneg (r: Array<StaticArray<i32>>, p: StaticArray<u8>): i8 {
 	Multiply(t, t, num)
 	Multiply(t, t, den)
 	Multiply(t, t, den)
-	Multiply(r[0], t, den)
+	Multiply(r, t, den)
 
-	Square(chk, r[0])
+	Square(chk, r)
 	Multiply(chk, chk, den)
-	if (neq25519(chk, num)) {
-		Multiply(r[0], r[0], I)
+	if (neq25519(changetype<StaticArray<i32>>(chk), changetype<StaticArray<i32>>(num))) {
+		Multiply(r, r, I)
 	}
 
-	Square(chk, r[0])
+	Square(chk, r)
 	Multiply(chk, chk, den)
 
-	if (neq25519(chk, num)) {
+	if (neq25519(changetype<StaticArray<i32>>(chk), changetype<StaticArray<i32>>(num))) {
 		return -1
 	}
 
-	if (par25519(r[0]) === (p[31] >> 7)) {
-		Subtract(r[0], z, r[0])
+	if (par25519(r) === (p[31] >> 7)) {
+		Subtract(r, ZERO, r)
 	}
-	Multiply(r[3], r[0], r[1])
+	Multiply(r + 192, r, r + 64)
 	return 0
 }
 
 // Validate signature scalar S is canonical (S < L)
 function canonical (S: StaticArray<u8>): boolean {
 	// If S >= 2^253 then S >= L for sure.
-	if ((S[32] & 0xE0) != 0) return false
+	if ((S[31] & 0xE0) != 0) return false
 
 	// Check S-L for underflow (c=1) which means S < L
 	let c = 0
 	for (let i = 0; i < 32; i++) {
-		const diff = S[i] - L[i] - c
+		const diff = S[i] - load<i32>(L + (i << 2)) - c
 		c = (diff >> 31) & 1
 	}
 	return c == 1
@@ -826,14 +924,14 @@ function crypto_hash (o: StaticArray<u8>, i: StaticArray<u8>): void {
 }
 
 const crypto_convert_h = new StaticArray<u8>(64)
-const crypto_convert_p = [new StaticArray<i32>(16), new StaticArray<i32>(16), new StaticArray<i32>(16), new StaticArray<i32>(16)]
+const crypto_convert_p = new StaticArray<i32>(64)
 function crypto_convert (pk: StaticArray<u8>, sk: StaticArray<u8>): void {
 	const h = crypto_convert_h
-	const p = crypto_convert_p
-	p[0].fill(0)
-	p[1].fill(0); p[1][0] = 1
-	p[2].fill(0); p[2][0] = 1
-	p[3].fill(0)
+	const p = changetype<usize>(crypto_convert_p)
+	memory.fill(p, 0, 256)
+	store<i32>(p, 1, 64)
+	store<i32>(p, 1, 128)
+
 	crypto_hash(h, sk)
 	h[0] &= 248
 	h[31] &= 127
@@ -844,7 +942,7 @@ function crypto_convert (pk: StaticArray<u8>, sk: StaticArray<u8>): void {
 
 const crypto_sign_d = new StaticArray<u8>(64)
 const crypto_sign_h = new StaticArray<u8>(64)
-const crypto_sign_p = [new StaticArray<i32>(16), new StaticArray<i32>(16), new StaticArray<i32>(16), new StaticArray<i32>(16)]
+const crypto_sign_p = new StaticArray<i32>(64)
 const crypto_sign_r = new StaticArray<u8>(64)
 const crypto_sign_x = new StaticArray<i32>(64)
 const crypto_sign_s = new StaticArray<u8>(SIGNATURE_BYTES)
@@ -852,15 +950,15 @@ const crypto_sign_prv = new StaticArray<u8>(PRIVATEKEY_BYTES)
 function crypto_sign (sm: StaticArray<u8>, m: StaticArray<u8>, sk: StaticArray<u8>): void {
 	const d = crypto_sign_d
 	const h = crypto_sign_h
-	const p = crypto_sign_p
+	const p = changetype<usize>(crypto_sign_p)
+	memory.fill(p, 0, 256)
+	store<i32>(p, 1, 64)
+	store<i32>(p, 1, 128)
+
 	const r = crypto_sign_r
 	const x = crypto_sign_x
 	const s = crypto_sign_s
 	const prv = crypto_sign_prv
-	p[0].fill(0)
-	p[1].fill(0); p[1][0] = 1
-	p[2].fill(0); p[2][0] = 1
-	p[3].fill(0)
 
 	for (let i = 0; i < PRIVATEKEY_BYTES; i++) {
 		prv[i] = sk[i]
@@ -906,8 +1004,8 @@ function crypto_sign (sm: StaticArray<u8>, m: StaticArray<u8>, sk: StaticArray<u
 }
 
 const crypto_verify_open_d = new StaticArray<u8>(64)
-const crypto_verify_open_p = [new StaticArray<i32>(16), new StaticArray<i32>(16), new StaticArray<i32>(16), new StaticArray<i32>(16)]
-const crypto_verify_open_q = [new StaticArray<i32>(16), new StaticArray<i32>(16), new StaticArray<i32>(16), new StaticArray<i32>(16)]
+const crypto_verify_open_p = new StaticArray<i32>(64)
+const crypto_verify_open_q = new StaticArray<i32>(64)
 const crypto_verify_open_t = new StaticArray<u8>(32)
 const crypto_verify_open_sm = new StaticArray<u8>(SIGNEDBLOCKHASH_BYTES)
 const crypto_verify_open_S = new StaticArray<u8>(32)
@@ -916,19 +1014,17 @@ const crypto_verify_open_S = new StaticArray<u8>(32)
 */
 function crypto_verify (h: StaticArray<u8>, s: StaticArray<u8>, k: StaticArray<u8>): bool {
 	const d = crypto_verify_open_d
-	const p = crypto_verify_open_p
-	const q = crypto_verify_open_q
+	const p = changetype<usize>(crypto_verify_open_p)
+	memory.fill(p, 0, 256)
+	store<i32>(p, 1, 64)
+	store<i32>(p, 1, 128)
+	const q = changetype<usize>(crypto_verify_open_q)
+	memory.fill(q, 0, 256)
+	store<i32>(q, 1, 128)
+
 	const t = crypto_verify_open_t
 	const sm = crypto_verify_open_sm
 	const S = crypto_verify_open_S
-	p[0].fill(0)
-	p[1].fill(0); p[1][0] = 1
-	p[2].fill(0); p[2][0] = 1
-	p[3].fill(0)
-	q[0].fill(0)
-	q[1].fill(0)
-	q[2].fill(0); q[2][0] = 1
-	q[3].fill(0)
 
 	// fail
 	if (unpackneg(q, k)) return false
@@ -950,10 +1046,9 @@ function crypto_verify (h: StaticArray<u8>, s: StaticArray<u8>, k: StaticArray<u
 	reduce(d)
 	scalarmult(p, q, d)
 
-	q[0].fill(0)
-	q[1].fill(0); q[1][0] = 1
-	q[2].fill(0); q[2][0] = 1
-	q[3].fill(0)
+	memory.fill(q, 0, 256)
+	store<i32>(q, 1, 64)
+	store<i32>(q, 1, 128)
 	scalarbase(q, S)
 	add(p, q)
 	pack(t, p)
diff --git a/index.ts b/index.ts
index 736abf8..3d8f001 100644
--- a/index.ts
+++ b/index.ts
@@ -33,8 +33,13 @@ const NanoNaCl = async (bytes: number[]): Promise<void> => {
 			instance = await WebAssembly.instantiate(module, {
 				env: {
 					abort: (msg: any, file: any, row: any, col: any) => {
-						console.error('Wasm abort:', `msg ${msg}`, `file ${file}`, `row ${row}`, `col ${col}`)
-						throw new Error(`Wasm abort: ${msg}`)
+						// ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void
+						// msg = __liftString(msg >>> 0)
+						// file = __liftString(file >>> 0)
+						row = row >>> 0
+						col = col >>> 0
+						console.error('wasm abort:', `msg ${msg}`, `file ${file}`, `row ${row}`, `col ${col}`)
+						throw new Error(msg, { cause: { file, row, col } })
 					},
 					"performance.now" () {
 						// ~lib/bindings/dom/performance.now() => f64
-- 
2.47.3