nano-pow 1.2.3 → 2.0.0

package/dist/shaders/gl-fragment.d.ts

@@ -0,0 +1 @@
+export declare const NanoPowGlFragmentShader = "#version 300 es\n#pragma vscode_glsllint_stage: frag\nprecision highp float;\nprecision highp int;\n\nin vec2 uv_pos;\nout vec4 fragColor;\n\n// blockhash - array of precalculated block hash components\n// threshold - 0xfffffff8 for send/change blocks, 0xfffffe00 for all else\n// workload - Defines canvas size\nlayout(std140) uniform UBO {\n\tuint blockhash[8];\n\tuint threshold;\n\tfloat workload;\n};\n\n// Random work values\n// First 2 bytes will be overwritten by texture pixel position\n// Second 2 bytes will be modified if the canvas size is greater than 256x256\n// Last 4 bytes remain as generated externally\nlayout(std140) uniform WORK {\n\tuvec4 work[2];\n};\n\n// Defined separately from uint v[32] below as the original value is required\n// to calculate the second uint32 of the digest for threshold comparison\nconst uint BLAKE2B_IV32_1 = 0x6A09E667u;\n\n// Both buffers represent 16 uint64s as 32 uint32s\n// because that's what GLSL offers, just like Javascript\n\n// Compression buffer, intialized to 2 instances of the initialization vector\n// The following values have been modified from the BLAKE2B_IV:\n// OUTLEN is constant 8 bytes\n// v[0] ^= 0x01010000u ^ uint(OUTLEN);\n// INLEN is constant 40 bytes: work value (8) + block hash (32)\n// v[24] ^= uint(INLEN);\n// It's always the \"last\" compression at this INLEN\n// v[28] = ~v[28];\n// v[29] = ~v[29];\nuint v[32] = uint[32](\n\t0xF2BDC900u, 0x6A09E667u, 0x84CAA73Bu, 0xBB67AE85u,\n\t0xFE94F82Bu, 0x3C6EF372u, 0x5F1D36F1u, 0xA54FF53Au,\n\t0xADE682D1u, 0x510E527Fu, 0x2B3E6C1Fu, 0x9B05688Cu,\n\t0xFB41BD6Bu, 0x1F83D9ABu, 0x137E2179u, 0x5BE0CD19u,\n\t0xF3BCC908u, 0x6A09E667u, 0x84CAA73Bu, 0xBB67AE85u,\n\t0xFE94F82Bu, 0x3C6EF372u, 0x5F1D36F1u, 0xA54FF53Au,\n\t0xADE682F9u, 0x510E527Fu, 0x2B3E6C1Fu, 0x9B05688Cu,\n\t0x04BE4294u, 0xE07C2654u, 0x137E2179u, 0x5BE0CD19u\n);\n// Input data buffer\nuint m[32];\n\n// These are offsets into the input data buffer for each mixing step.\n// They are multiplied by 2 from the original SIGMA values in\n// the C reference implementation, which refered to uint64s.\nconst uint SIGMA82[192] = uint[192](\n\t0u,2u,4u,6u,8u,10u,12u,14u,16u,18u,20u,22u,24u,26u,28u,30u,\n\t28u,20u,8u,16u,18u,30u,26u,12u,2u,24u,0u,4u,22u,14u,10u,6u,\n\t22u,16u,24u,0u,10u,4u,30u,26u,20u,28u,6u,12u,14u,2u,18u,8u,\n\t14u,18u,6u,2u,26u,24u,22u,28u,4u,12u,10u,20u,8u,0u,30u,16u,\n\t18u,0u,10u,14u,4u,8u,20u,30u,28u,2u,22u,24u,12u,16u,6u,26u,\n\t4u,24u,12u,20u,0u,22u,16u,6u,8u,26u,14u,10u,30u,28u,2u,18u,\n\t24u,10u,2u,30u,28u,26u,8u,20u,0u,14u,12u,6u,18u,4u,16u,22u,\n\t26u,22u,14u,28u,24u,2u,6u,18u,10u,0u,30u,8u,16u,12u,4u,20u,\n\t12u,30u,28u,18u,22u,6u,0u,16u,24u,4u,26u,14u,2u,8u,20u,10u,\n\t20u,4u,16u,8u,14u,12u,2u,10u,30u,22u,18u,28u,6u,24u,26u,0u,\n\t0u,2u,4u,6u,8u,10u,12u,14u,16u,18u,20u,22u,24u,26u,28u,30u,\n\t28u,20u,8u,16u,18u,30u,26u,12u,2u,24u,0u,4u,22u,14u,10u,6u\n);\n\n// G mixing function\nvoid G (uint ix, uint iy, uint a, uint b, uint c, uint d) {\n\tbool carry;\n\tuint o0;\n\tuint o1;\n\tuint xor0;\n\tuint xor1;\n\n\t// a = a + b;\n\to0 = v[a] + v[b];\n\to1 = v[a+1u] + v[b+1u];\n\tcarry = o0 < v[a];\n\to1 = o1 + uint(mix(0.0, 1.0, float(carry)));\n\tv[a] = o0;\n\tv[a+1u] = o1;\n\n\t// a = a + m[sigma[r][2*i+0]];\n\to0 = v[a] + m[ix];\n\to1 = v[a+1u] + m[ix+1u];\n\tcarry = o0 < v[a];\n\to1 = o1 + uint(mix(0.0, 1.0, float(carry)));\n\tv[a] = o0;\n\tv[a+1u] = o1;\n\n\t// d = rotr64(d ^ a, 32);\n\txor0 = v[d] ^ v[a];\n\txor1 = v[d+1u] ^ v[a+1u];\n\tv[d] = xor1;\n\tv[d+1u] = xor0;\n\n\t// c = c + d;\n\to0 = v[c] + v[d];\n\to1 = v[c+1u] + v[d+1u];\n\tcarry = o0 < v[c];\n\to1 = o1 + uint(mix(0.0, 1.0, float(carry)));\n\tv[c] = o0;\n\tv[c+1u] = o1;\n\n\t// b = rotr64(b ^ c, 24);\n\txor0 = v[b] ^ v[c];\n\txor1 = v[b+1u] ^ v[c+1u];\n\tv[b] = (xor0 >> 24u) ^ (xor1 << 8u);\n\tv[b+1u] = (xor1 >> 24u) ^ (xor0 << 8u);\n\n\t// a = a + b;\n\to0 = v[a] + v[b];\n\to1 = v[a+1u] + v[b+1u];\n\tcarry = o0 < v[a];\n\to1 = o1 + uint(mix(0.0, 1.0, float(carry)));\n\tv[a] = o0;\n\tv[a+1u] = o1;\n\n\t// a = a + m[sigma[r][2*i+1]];\n\to0 = v[a] + m[iy];\n\to1 = v[a+1u] + m[iy+1u];\n\tcarry = o0 < v[a];\n\to1 = o1 + uint(mix(0.0, 1.0, float(carry)));\n\tv[a] = o0;\n\tv[a+1u] = o1;\n\n\t// d = rotr64(d ^ a, 16)\n\txor0 = v[d] ^ v[a];\n\txor1 = v[d+1u] ^ v[a+1u];\n\tv[d] = (xor0 >> 16u) ^ (xor1 << 16u);\n\tv[d+1u] = (xor1 >> 16u) ^ (xor0 << 16u);\n\n\t// c = c + d;\n\to0 = v[c] + v[d];\n\to1 = v[c+1u] + v[d+1u];\n\tcarry = o0 < v[c];\n\to1 = o1 + uint(mix(0.0, 1.0, float(carry)));\n\tv[c] = o0;\n\tv[c+1u] = o1;\n\n\t// b = rotr64(b ^ c, 63)\n\txor0 = v[b] ^ v[c];\n\txor1 = v[b+1u] ^ v[c+1u];\n\tv[b] = (xor1 >> 31u) ^ (xor0 << 1u);\n\tv[b+1u] = (xor0 >> 31u) ^ (xor1 << 1u);\n}\n\nvoid main() {\n\tint i;\n\tuvec4 u_work0 = work[0u];\n\tuvec4 u_work1 = work[1u];\n\tuint uv_x = uint(uv_pos.x * workload);\n\tuint uv_y = uint(uv_pos.y * workload);\n\tuint x_pos = uv_x % 256u;\n\tuint y_pos = uv_y % 256u;\n\tuint x_index = (uv_x - x_pos) / 256u;\n\tuint y_index = (uv_y - y_pos) / 256u;\n\n\t// First 2 work bytes are the x,y pos within the 256x256 area, the next\n\t// two bytes are modified from the random generated value, XOR'd with\n\t// the x,y area index of where this pixel is located\n\tm[0u] = (x_pos ^ (y_pos << 8u) ^ ((u_work0.b ^ x_index) << 16u) ^ ((u_work0.a ^ y_index) << 24u));\n\n\t// Remaining bytes are un-modified from the random generated value\n\tm[1u] = (u_work1.r ^ (u_work1.g << 8u) ^ (u_work1.b << 16u) ^ (u_work1.a << 24u));\n\n\t// Block hash\n\tfor (uint i = 0u; i < 8u; i = i + 1u) {\n\t\tm[i+2u] = blockhash[i];\n\t}\n\n\t// twelve rounds of mixing\n\tfor(uint i = 0u; i < 12u; i = i + 1u) {\n\t\tG(SIGMA82[i * 16u + 0u], SIGMA82[i * 16u + 1u], 0u, 8u, 16u, 24u);\n\t\tG(SIGMA82[i * 16u + 2u], SIGMA82[i * 16u + 3u], 2u, 10u, 18u, 26u);\n\t\tG(SIGMA82[i * 16u + 4u], SIGMA82[i * 16u + 5u], 4u, 12u, 20u, 28u);\n\t\tG(SIGMA82[i * 16u + 6u], SIGMA82[i * 16u + 7u], 6u, 14u, 22u, 30u);\n\t\tG(SIGMA82[i * 16u + 8u], SIGMA82[i * 16u + 9u], 0u, 10u, 20u, 30u);\n\t\tG(SIGMA82[i * 16u + 10u], SIGMA82[i * 16u + 11u], 2u, 12u, 22u, 24u);\n\t\tG(SIGMA82[i * 16u + 12u], SIGMA82[i * 16u + 13u], 4u, 14u, 16u, 26u);\n\t\tG(SIGMA82[i * 16u + 14u], SIGMA82[i * 16u + 15u], 6u, 8u, 18u, 28u);\n\t}\n\n\t// Pixel data is multipled by threshold test result (0 or 1)\n\t// First 4 bytes insignificant, only calculate digest of second 4 bytes\n\tif ((BLAKE2B_IV32_1 ^ v[1u] ^ v[17u]) > threshold) {\n\t\tfragColor = vec4(\n\t\t\tfloat(x_index + 1u)/255.0, // +1 to distinguish from 0 (unsuccessful) pixels\n\t\t\tfloat(y_index + 1u)/255.0, // Same as previous\n\t\t\tfloat(x_pos)/255.0, // Return the 2 custom bytes used in work value\n\t\t\tfloat(y_pos)/255.0  // Second custom byte\n\t\t);\n\t} else {\n \t\tdiscard;\n\t}\n}\n";

package/dist/shaders/gl-fragment.js

@@ -0,0 +1,206 @@
+// SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
+// SPDX-FileContributor: Ben Green <ben@latenightsketches.com>
+// SPDX-License-Identifier: GPL-3.0-or-later AND MIT
+export const NanoPowGlFragmentShader = `#version 300 es
+#pragma vscode_glsllint_stage: frag
+precision highp float;
+precision highp int;
+
+in vec2 uv_pos;
+out vec4 fragColor;
+
+// blockhash - array of precalculated block hash components
+// threshold - 0xfffffff8 for send/change blocks, 0xfffffe00 for all else
+// workload - Defines canvas size
+layout(std140) uniform UBO {
+	uint blockhash[8];
+	uint threshold;
+	float workload;
+};
+
+// Random work values
+// First 2 bytes will be overwritten by texture pixel position
+// Second 2 bytes will be modified if the canvas size is greater than 256x256
+// Last 4 bytes remain as generated externally
+layout(std140) uniform WORK {
+	uvec4 work[2];
+};
+
+// Defined separately from uint v[32] below as the original value is required
+// to calculate the second uint32 of the digest for threshold comparison
+const uint BLAKE2B_IV32_1 = 0x6A09E667u;
+
+// Both buffers represent 16 uint64s as 32 uint32s
+// because that's what GLSL offers, just like Javascript
+
+// Compression buffer, intialized to 2 instances of the initialization vector
+// The following values have been modified from the BLAKE2B_IV:
+// OUTLEN is constant 8 bytes
+// v[0] ^= 0x01010000u ^ uint(OUTLEN);
+// INLEN is constant 40 bytes: work value (8) + block hash (32)
+// v[24] ^= uint(INLEN);
+// It's always the "last" compression at this INLEN
+// v[28] = ~v[28];
+// v[29] = ~v[29];
+uint v[32] = uint[32](
+	0xF2BDC900u, 0x6A09E667u, 0x84CAA73Bu, 0xBB67AE85u,
+	0xFE94F82Bu, 0x3C6EF372u, 0x5F1D36F1u, 0xA54FF53Au,
+	0xADE682D1u, 0x510E527Fu, 0x2B3E6C1Fu, 0x9B05688Cu,
+	0xFB41BD6Bu, 0x1F83D9ABu, 0x137E2179u, 0x5BE0CD19u,
+	0xF3BCC908u, 0x6A09E667u, 0x84CAA73Bu, 0xBB67AE85u,
+	0xFE94F82Bu, 0x3C6EF372u, 0x5F1D36F1u, 0xA54FF53Au,
+	0xADE682F9u, 0x510E527Fu, 0x2B3E6C1Fu, 0x9B05688Cu,
+	0x04BE4294u, 0xE07C2654u, 0x137E2179u, 0x5BE0CD19u
+);
+// Input data buffer
+uint m[32];
+
+// These are offsets into the input data buffer for each mixing step.
+// They are multiplied by 2 from the original SIGMA values in
+// the C reference implementation, which refered to uint64s.
+const uint SIGMA82[192] = uint[192](
+	0u,2u,4u,6u,8u,10u,12u,14u,16u,18u,20u,22u,24u,26u,28u,30u,
+	28u,20u,8u,16u,18u,30u,26u,12u,2u,24u,0u,4u,22u,14u,10u,6u,
+	22u,16u,24u,0u,10u,4u,30u,26u,20u,28u,6u,12u,14u,2u,18u,8u,
+	14u,18u,6u,2u,26u,24u,22u,28u,4u,12u,10u,20u,8u,0u,30u,16u,
+	18u,0u,10u,14u,4u,8u,20u,30u,28u,2u,22u,24u,12u,16u,6u,26u,
+	4u,24u,12u,20u,0u,22u,16u,6u,8u,26u,14u,10u,30u,28u,2u,18u,
+	24u,10u,2u,30u,28u,26u,8u,20u,0u,14u,12u,6u,18u,4u,16u,22u,
+	26u,22u,14u,28u,24u,2u,6u,18u,10u,0u,30u,8u,16u,12u,4u,20u,
+	12u,30u,28u,18u,22u,6u,0u,16u,24u,4u,26u,14u,2u,8u,20u,10u,
+	20u,4u,16u,8u,14u,12u,2u,10u,30u,22u,18u,28u,6u,24u,26u,0u,
+	0u,2u,4u,6u,8u,10u,12u,14u,16u,18u,20u,22u,24u,26u,28u,30u,
+	28u,20u,8u,16u,18u,30u,26u,12u,2u,24u,0u,4u,22u,14u,10u,6u
+);
+
+// G mixing function
+void G (uint ix, uint iy, uint a, uint b, uint c, uint d) {
+	bool carry;
+	uint o0;
+	uint o1;
+	uint xor0;
+	uint xor1;
+
+	// a = a + b;
+	o0 = v[a] + v[b];
+	o1 = v[a+1u] + v[b+1u];
+	carry = o0 < v[a];
+	o1 = o1 + uint(mix(0.0, 1.0, float(carry)));
+	v[a] = o0;
+	v[a+1u] = o1;
+
+	// a = a + m[sigma[r][2*i+0]];
+	o0 = v[a] + m[ix];
+	o1 = v[a+1u] + m[ix+1u];
+	carry = o0 < v[a];
+	o1 = o1 + uint(mix(0.0, 1.0, float(carry)));
+	v[a] = o0;
+	v[a+1u] = o1;
+
+	// d = rotr64(d ^ a, 32);
+	xor0 = v[d] ^ v[a];
+	xor1 = v[d+1u] ^ v[a+1u];
+	v[d] = xor1;
+	v[d+1u] = xor0;
+
+	// c = c + d;
+	o0 = v[c] + v[d];
+	o1 = v[c+1u] + v[d+1u];
+	carry = o0 < v[c];
+	o1 = o1 + uint(mix(0.0, 1.0, float(carry)));
+	v[c] = o0;
+	v[c+1u] = o1;
+
+	// b = rotr64(b ^ c, 24);
+	xor0 = v[b] ^ v[c];
+	xor1 = v[b+1u] ^ v[c+1u];
+	v[b] = (xor0 >> 24u) ^ (xor1 << 8u);
+	v[b+1u] = (xor1 >> 24u) ^ (xor0 << 8u);
+
+	// a = a + b;
+	o0 = v[a] + v[b];
+	o1 = v[a+1u] + v[b+1u];
+	carry = o0 < v[a];
+	o1 = o1 + uint(mix(0.0, 1.0, float(carry)));
+	v[a] = o0;
+	v[a+1u] = o1;
+
+	// a = a + m[sigma[r][2*i+1]];
+	o0 = v[a] + m[iy];
+	o1 = v[a+1u] + m[iy+1u];
+	carry = o0 < v[a];
+	o1 = o1 + uint(mix(0.0, 1.0, float(carry)));
+	v[a] = o0;
+	v[a+1u] = o1;
+
+	// d = rotr64(d ^ a, 16)
+	xor0 = v[d] ^ v[a];
+	xor1 = v[d+1u] ^ v[a+1u];
+	v[d] = (xor0 >> 16u) ^ (xor1 << 16u);
+	v[d+1u] = (xor1 >> 16u) ^ (xor0 << 16u);
+
+	// c = c + d;
+	o0 = v[c] + v[d];
+	o1 = v[c+1u] + v[d+1u];
+	carry = o0 < v[c];
+	o1 = o1 + uint(mix(0.0, 1.0, float(carry)));
+	v[c] = o0;
+	v[c+1u] = o1;
+
+	// b = rotr64(b ^ c, 63)
+	xor0 = v[b] ^ v[c];
+	xor1 = v[b+1u] ^ v[c+1u];
+	v[b] = (xor1 >> 31u) ^ (xor0 << 1u);
+	v[b+1u] = (xor0 >> 31u) ^ (xor1 << 1u);
+}
+
+void main() {
+	int i;
+	uvec4 u_work0 = work[0u];
+	uvec4 u_work1 = work[1u];
+	uint uv_x = uint(uv_pos.x * workload);
+	uint uv_y = uint(uv_pos.y * workload);
+	uint x_pos = uv_x % 256u;
+	uint y_pos = uv_y % 256u;
+	uint x_index = (uv_x - x_pos) / 256u;
+	uint y_index = (uv_y - y_pos) / 256u;
+
+	// First 2 work bytes are the x,y pos within the 256x256 area, the next
+	// two bytes are modified from the random generated value, XOR'd with
+	// the x,y area index of where this pixel is located
+	m[0u] = (x_pos ^ (y_pos << 8u) ^ ((u_work0.b ^ x_index) << 16u) ^ ((u_work0.a ^ y_index) << 24u));
+
+	// Remaining bytes are un-modified from the random generated value
+	m[1u] = (u_work1.r ^ (u_work1.g << 8u) ^ (u_work1.b << 16u) ^ (u_work1.a << 24u));
+
+	// Block hash
+	for (uint i = 0u; i < 8u; i = i + 1u) {
+		m[i+2u] = blockhash[i];
+	}
+
+	// twelve rounds of mixing
+	for(uint i = 0u; i < 12u; i = i + 1u) {
+		G(SIGMA82[i * 16u + 0u], SIGMA82[i * 16u + 1u], 0u, 8u, 16u, 24u);
+		G(SIGMA82[i * 16u + 2u], SIGMA82[i * 16u + 3u], 2u, 10u, 18u, 26u);
+		G(SIGMA82[i * 16u + 4u], SIGMA82[i * 16u + 5u], 4u, 12u, 20u, 28u);
+		G(SIGMA82[i * 16u + 6u], SIGMA82[i * 16u + 7u], 6u, 14u, 22u, 30u);
+		G(SIGMA82[i * 16u + 8u], SIGMA82[i * 16u + 9u], 0u, 10u, 20u, 30u);
+		G(SIGMA82[i * 16u + 10u], SIGMA82[i * 16u + 11u], 2u, 12u, 22u, 24u);
+		G(SIGMA82[i * 16u + 12u], SIGMA82[i * 16u + 13u], 4u, 14u, 16u, 26u);
+		G(SIGMA82[i * 16u + 14u], SIGMA82[i * 16u + 15u], 6u, 8u, 18u, 28u);
+	}
+
+	// Pixel data is multipled by threshold test result (0 or 1)
+	// First 4 bytes insignificant, only calculate digest of second 4 bytes
+	if ((BLAKE2B_IV32_1 ^ v[1u] ^ v[17u]) > threshold) {
+		fragColor = vec4(
+			float(x_index + 1u)/255.0, // +1 to distinguish from 0 (unsuccessful) pixels
+			float(y_index + 1u)/255.0, // Same as previous
+			float(x_pos)/255.0, // Return the 2 custom bytes used in work value
+			float(y_pos)/255.0  // Second custom byte
+		);
+	} else {
+ 		discard;
+	}
+}
+`;

package/dist/shaders/gl-vertex.d.ts

@@ -0,0 +1 @@
+export declare const NanoPowGlVertexShader = "#version 300 es\n#pragma vscode_glsllint_stage: vert\nprecision highp float;\nlayout (location=0) in vec4 position;\nlayout (location=1) in vec2 uv;\n\nout vec2 uv_pos;\n\nvoid main() {\n\tuv_pos = uv;\n\tgl_Position = position;\n}\n";

package/dist/shaders/gl-vertex.js

@@ -0,0 +1,16 @@
+// SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
+// SPDX-FileContributor: Ben Green <ben@latenightsketches.com>
+// SPDX-License-Identifier: GPL-3.0-or-later AND MIT
+export const NanoPowGlVertexShader = `#version 300 es
+#pragma vscode_glsllint_stage: vert
+precision highp float;
+layout (location=0) in vec4 position;
+layout (location=1) in vec2 uv;
+
+out vec2 uv_pos;
+
+void main() {
+	uv_pos = uv;
+	gl_Position = position;
+}
+`;

package/dist/shaders/index.d.ts

@@ -0,0 +1,4 @@
+import { default as NanoPowGpuComputeShader } from "./compute.wgsl";
+import { NanoPowGlFragmentShader } from "./gl-fragment.js";
+import { NanoPowGlVertexShader } from "./gl-vertex.js";
+export { NanoPowGpuComputeShader, NanoPowGlFragmentShader, NanoPowGlVertexShader };

package/dist/shaders/index.js

@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
+// SPDX-License-Identifier: GPL-3.0-or-later
+import { default as NanoPowGpuComputeShader } from "./compute.wgsl";
+import { NanoPowGlFragmentShader } from "./gl-fragment.js";
+import { NanoPowGlVertexShader } from "./gl-vertex.js";
+export { NanoPowGpuComputeShader, NanoPowGlFragmentShader, NanoPowGlVertexShader };

package/dist/types.d.ts

@@ -1,18 +1,42 @@
+// SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 import "@webgpu/types"
 
+export declare const NanoPowGlFragmentShader: string
+export declare const NanoPowGlVertexShader: string
+export declare const NanoPowGpuComputeShader: any
+
 declare const NanoPow: typeof NanoPowGl | typeof NanoPowGpu | null
 
+/**
+* Used to configure NanoPow.
+*
+* @param {boolean} [debug=false] - Enables additional debug logging to the console. Default: false
+* @param {number} [effort=0x8] - Multiplier for dispatching work search. Larger values are not necessarily better since they can quickly overwhelm the GPU. Ignored when validating. Default: 0x8
+* @param {number} [threshold=0xfffffff8] - Minimum value result of `BLAKE2b(nonce||blockhash) << 0x32`. Default: 0xFFFFFFF8
+*/
+export type NanoPowOptions = {
+	debug?: boolean
+	effort?: number
+	threshold?: number
+}
+
+/**
+* Nano proof-of-work using WebGL 2.0.
+*/
 export declare class NanoPowGl {
 	#private
 	/** Compile */
 	static init (): Promise<void>
+	static reset (): void
 	/**
 	* Finds a nonce that satisfies the Nano proof-of-work requirements.
 	*
 	* @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
 	* @param {number} [threshold=0xfffffff8] - Difficulty of proof-of-work calculation
 	*/
-	static search (hash: string, threshold?: number): Promise<string>
+	static search (hash: string, options?: NanoPowOptions): Promise<string>
 	/**
 	* Validates that a nonce satisfies Nano proof-of-work requirements.
 	*
@@ -20,7 +44,7 @@ export declare class NanoPowGl {
 	* @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
 	* @param {number} [threshold=0xfffffff8] - Difficulty of proof-of-work calculation
 	*/
-	static validate (work: string, hash: string, threshold?: number): Promise<boolean>
+	static validate (work: string, hash: string, options?: NanoPowOptions): Promise<boolean>
 }
 
 /**
@@ -35,19 +59,15 @@ export declare class NanoPowGpu {
 	* Finds a nonce that satisfies the Nano proof-of-work requirements.
 	*
 	* @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
-	* @param {number} [threshold=0xfffffff8] - Difficulty of proof-of-work calculation
+	* @param {NanoPowOptions} options - Used to configure search execution
 	*/
-	static search (hash: string, threshold?: number): Promise<string>
+	static search (hash: string, options?: NanoPowOptions): Promise<string>
 	/**
 	* Validates that a nonce satisfies Nano proof-of-work requirements.
 	*
 	* @param {string} work - Hexadecimal proof-of-work value to validate
 	* @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
-	* @param {number} [threshold=0xfffffff8] - Difficulty of proof-of-work calculation
+	* @param {NanoPowOptions} options - Options used to configure search execution
 	*/
-	static validate (work: string, hash: string, threshold?: number): Promise<boolean>
+	static validate (work: string, hash: string, options?: NanoPowOptions): Promise<boolean>
 }
-
-export declare const NanoPowGlFragmentShader: string
-export declare const NanoPowGlVertexShader: string
-export declare const NanoPowGpuComputeShader: any

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "nano-pow",
-	"version": "1.2.3",
+	"version": "2.0.0",
 	"description": "Proof-of-work generation and validation with WebGPU/WebGL for Nano cryptocurrency.",
 	"keywords": [
 		"nemo",
@@ -47,7 +47,6 @@
 		"@webgpu/types": "^0.1.52",
 		"esbuild": "^0.24.2",
 		"esbuild-plugin-glsl": "^1.2.2",
-		"nano-webgl-pow": "^1.1.1",
 		"typescript": "^5.7.3"
 	},
 	"type": "module",