nano-pow 2.0.0 → 3.0.0

package/dist/types.d.ts

@@ -3,12 +3,29 @@
 
 import "@webgpu/types"
 
-export declare const NanoPowGlFragmentShader: string
+export declare const NanoPowGlDownsampleShader: string
+export declare const NanoPowGlDrawShader: string
 export declare const NanoPowGlVertexShader: string
 export declare const NanoPowGpuComputeShader: any
 
 declare const NanoPow: typeof NanoPowGl | typeof NanoPowGpu | null
 
+/**
+* Used to create WebGL framebuffer objects.
+*
+* @param {WebGLTexture} - Defines storage size
+* @param {WebGLFramebuffer} - Holds texture data
+* @param {size} - 2D lengths of texture
+*/
+export type FBO = {
+	texture: WebGLTexture
+	framebuffer: WebGLFramebuffer
+	size: {
+		x: number
+		y: number
+	}
+}
+
 /**
 * Used to configure NanoPow.
 *

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "nano-pow",
-	"version": "2.0.0",
+	"version": "3.0.0",
 	"description": "Proof-of-work generation and validation with WebGPU/WebGL for Nano cryptocurrency.",
 	"keywords": [
 		"nemo",
@@ -43,11 +43,11 @@
 		"build": "rm -rf types && tsc && node esbuild.mjs && cp types.d.ts dist"
 	},
 	"devDependencies": {
-		"@types/node": "^22.10.5",
-		"@webgpu/types": "^0.1.52",
-		"esbuild": "^0.24.2",
+		"@types/node": "^22.13.8",
+		"@webgpu/types": "^0.1.54",
+		"esbuild": "^0.25.0",
 		"esbuild-plugin-glsl": "^1.2.2",
-		"typescript": "^5.7.3"
+		"typescript": "^5.8.2"
 	},
 	"type": "module",
 	"exports": [

package/dist/classes/gl.d.ts

@@ -1,20 +0,0 @@
-export declare class NanoPowGl {
-    #private;
-    /** Compile */
-    static init(): Promise<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>;
-    /**
-    * 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
-    */
-    static validate(work: string, hash: string, threshold?: number): Promise<boolean>;
-}

package/dist/classes/gl.js

@@ -1,232 +0,0 @@
-// 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
-import { NanoPowGlFragmentShader, NanoPowGlVertexShader } from '#shaders';
-export class NanoPowGl {
-    /** Used to set canvas size. Must be a multiple of 256. */
-    static #WORKLOAD = 256 * Math.max(1, Math.floor(navigator.hardwareConcurrency));
-    static #hexify(arr) {
-        let out = '';
-        for (let i = arr.length - 1; i >= 0; i--) {
-            out += arr[i].toString(16).padStart(2, '0');
-        }
-        return out;
-    }
-    static #gl;
-    static #program;
-    static #vertexShader;
-    static #fragmentShader;
-    static #positionBuffer;
-    static #uvBuffer;
-    static #uboBuffer;
-    static #workBuffer;
-    static #query;
-    static #pixels;
-    /**Vertex Positions, 2 triangles */
-    static #positions = new Float32Array([
-        -1, -1, 0, -1, 1, 0, 1, 1, 0,
-        1, -1, 0, 1, 1, 0, -1, -1, 0
-    ]);
-    /** Texture Positions */
-    static #uvPosArray = new Float32Array([
-        1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1
-    ]);
-    /** Compile */
-    static async init() {
-        this.#gl = new OffscreenCanvas(this.#WORKLOAD, this.#WORKLOAD).getContext('webgl2');
-        if (this.#gl == null)
-            throw new Error('WebGL 2 is required');
-        this.#gl.clearColor(0, 0, 0, 1);
-        this.#program = this.#gl.createProgram();
-        if (this.#program == null)
-            throw new Error('Failed to create shader program');
-        this.#vertexShader = this.#gl.createShader(this.#gl.VERTEX_SHADER);
-        if (this.#vertexShader == null)
-            throw new Error('Failed to create vertex shader');
-        this.#gl.shaderSource(this.#vertexShader, NanoPowGlVertexShader);
-        this.#gl.compileShader(this.#vertexShader);
-        if (!this.#gl.getShaderParameter(this.#vertexShader, this.#gl.COMPILE_STATUS))
-            throw new Error(this.#gl.getShaderInfoLog(this.#vertexShader) ?? `Failed to compile vertex shader`);
-        this.#fragmentShader = this.#gl.createShader(this.#gl.FRAGMENT_SHADER);
-        if (this.#fragmentShader == null)
-            throw new Error('Failed to create fragment shader');
-        this.#gl.shaderSource(this.#fragmentShader, NanoPowGlFragmentShader);
-        this.#gl.compileShader(this.#fragmentShader);
-        if (!this.#gl.getShaderParameter(this.#fragmentShader, this.#gl.COMPILE_STATUS))
-            throw new Error(this.#gl.getShaderInfoLog(this.#fragmentShader) ?? `Failed to compile fragment shader`);
-        this.#gl.attachShader(this.#program, this.#vertexShader);
-        this.#gl.attachShader(this.#program, this.#fragmentShader);
-        this.#gl.linkProgram(this.#program);
-        if (!this.#gl.getProgramParameter(this.#program, this.#gl.LINK_STATUS))
-            throw new Error(this.#gl.getProgramInfoLog(this.#program) ?? `Failed to link program`);
-        /** Construct simple 2D geometry */
-        this.#gl.useProgram(this.#program);
-        const triangleArray = this.#gl.createVertexArray();
-        this.#gl.bindVertexArray(triangleArray);
-        this.#positionBuffer = this.#gl.createBuffer();
-        this.#gl.bindBuffer(this.#gl.ARRAY_BUFFER, this.#positionBuffer);
-        this.#gl.bufferData(this.#gl.ARRAY_BUFFER, this.#positions, this.#gl.STATIC_DRAW);
-        this.#gl.vertexAttribPointer(0, 3, this.#gl.FLOAT, false, 0, 0);
-        this.#gl.enableVertexAttribArray(0);
-        this.#uvBuffer = this.#gl.createBuffer();
-        this.#gl.bindBuffer(this.#gl.ARRAY_BUFFER, this.#uvBuffer);
-        this.#gl.bufferData(this.#gl.ARRAY_BUFFER, this.#uvPosArray, this.#gl.STATIC_DRAW);
-        this.#gl.vertexAttribPointer(1, 2, this.#gl.FLOAT, false, 0, 0);
-        this.#gl.enableVertexAttribArray(1);
-        this.#uboBuffer = this.#gl.createBuffer();
-        this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, this.#uboBuffer);
-        this.#gl.bufferData(this.#gl.UNIFORM_BUFFER, 144, this.#gl.DYNAMIC_DRAW);
-        this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, null);
-        this.#gl.bindBufferBase(this.#gl.UNIFORM_BUFFER, 0, this.#uboBuffer);
-        this.#gl.uniformBlockBinding(this.#program, this.#gl.getUniformBlockIndex(this.#program, 'UBO'), 0);
-        this.#workBuffer = this.#gl.createBuffer();
-        this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, this.#workBuffer);
-        this.#gl.bufferData(this.#gl.UNIFORM_BUFFER, 32, this.#gl.STREAM_DRAW);
-        this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, null);
-        this.#gl.bindBufferBase(this.#gl.UNIFORM_BUFFER, 1, this.#workBuffer);
-        this.#gl.uniformBlockBinding(this.#program, this.#gl.getUniformBlockIndex(this.#program, 'WORK'), 1);
-        this.#pixels = new Uint8Array(this.#gl.drawingBufferWidth * this.#gl.drawingBufferHeight * 4);
-        this.#query = this.#gl.createQuery();
-    }
-    static #draw(work) {
-        if (this.#gl == null || this.#query == null)
-            throw new Error('WebGL 2 is required to draw and query pixels');
-        if (this.#workBuffer == null)
-            throw new Error('Work buffer is required to draw');
-        this.#gl.clear(this.#gl.COLOR_BUFFER_BIT);
-        /** Upload work buffer */
-        this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, this.#workBuffer);
-        this.#gl.bufferSubData(this.#gl.UNIFORM_BUFFER, 0, Uint32Array.from(work));
-        this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, null);
-        this.#gl.beginQuery(this.#gl.ANY_SAMPLES_PASSED_CONSERVATIVE, this.#query);
-        this.#gl.drawArrays(this.#gl.TRIANGLES, 0, 6);
-        this.#gl.endQuery(this.#gl.ANY_SAMPLES_PASSED_CONSERVATIVE);
-    }
-    static async #checkQueryResult() {
-        if (this.#gl == null || this.#query == null)
-            throw new Error('WebGL 2 is required to check query results');
-        if (this.#gl.getQueryParameter(this.#query, this.#gl.QUERY_RESULT_AVAILABLE)) {
-            return !!(this.#gl.getQueryParameter(this.#query, this.#gl.QUERY_RESULT));
-        }
-        /** Query result not yet available, check again in the next frame */
-        return new Promise((resolve, reject) => {
-            try {
-                requestAnimationFrame(async () => {
-                    const result = await NanoPowGl.#checkQueryResult();
-                    resolve(result);
-                });
-            }
-            catch (err) {
-                reject(err);
-            }
-        });
-    }
-    /**
-    * Reads pixels into the work buffer, checks every 4th pixel for the 'found'
-    * byte, converts the subsequent 3 pixels with the nonce byte values to a hex
-    * string, and returns the result.
-    *
-    * @param work - Buffer with the original random nonce value
-    * @returns Nonce as an 8-byte (16-char) hexadecimal string
-    */
-    static #readResult(work) {
-        if (this.#gl == null)
-            throw new Error('WebGL 2 is required to read pixels');
-        this.#gl.readPixels(0, 0, this.#gl.drawingBufferWidth, this.#gl.drawingBufferHeight, this.#gl.RGBA, this.#gl.UNSIGNED_BYTE, this.#pixels);
-        for (let i = 0; i < this.#pixels.length; i += 4) {
-            if (this.#pixels[i] !== 0) {
-                /** Return the work value with the custom bits */
-                const hex = this.#hexify(work.subarray(4, 8)) + this.#hexify([
-                    this.#pixels[i + 2],
-                    this.#pixels[i + 3],
-                    work[2] ^ (this.#pixels[i] - 1),
-                    work[3] ^ (this.#pixels[i + 1] - 1)
-                ]);
-                return hex;
-            }
-        }
-        throw new Error('Query reported result but nonce value not found');
-    }
-    /**
-    * 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 async search(hash, threshold = 0xfffffff8) {
-        if (NanoPowGl.#gl == null)
-            throw new Error('WebGL 2 is required');
-        if (!/^[A-Fa-f0-9]{64}$/.test(hash))
-            throw new Error(`Invalid hash ${hash}`);
-        if (typeof threshold !== 'number')
-            throw new TypeError(`Invalid threshold ${threshold}`);
-        if (this.#gl == null)
-            throw new Error('WebGL 2 is required');
-        /** Set up uniform buffer object */
-        const uboView = new DataView(new ArrayBuffer(144));
-        for (let i = 0; i < 64; i += 8) {
-            const uint32 = hash.slice(i, i + 8);
-            uboView.setUint32(i * 2, parseInt(uint32, 16));
-        }
-        uboView.setUint32(128, threshold, true);
-        uboView.setFloat32(132, NanoPowGl.#WORKLOAD - 1, true);
-        NanoPowGl.#gl.bindBuffer(NanoPowGl.#gl.UNIFORM_BUFFER, NanoPowGl.#uboBuffer);
-        NanoPowGl.#gl.bufferSubData(NanoPowGl.#gl.UNIFORM_BUFFER, 0, uboView);
-        NanoPowGl.#gl.bindBuffer(NanoPowGl.#gl.UNIFORM_BUFFER, null);
-        /** Start drawing to calculate one nonce per pixel */
-        let nonce = null;
-        const seed = new Uint8Array(8);
-        while (nonce == null) {
-            crypto.getRandomValues(seed);
-            this.#draw(seed);
-            const found = await this.#checkQueryResult();
-            if (found) {
-                nonce = this.#readResult(seed);
-            }
-        }
-        return nonce;
-    }
-    /**
-    * 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
-    */
-    static async validate(work, hash, threshold = 0xfffffff8) {
-        if (NanoPowGl.#gl == null)
-            throw new Error('WebGL 2 is required');
-        if (!/^[A-Fa-f0-9]{16}$/.test(work))
-            throw new Error(`Invalid work ${work}`);
-        if (!/^[A-Fa-f0-9]{64}$/.test(hash))
-            throw new Error(`Invalid hash ${hash}`);
-        if (typeof threshold !== 'number')
-            throw new TypeError(`Invalid threshold ${threshold}`);
-        if (this.#gl == null)
-            throw new Error('WebGL 2 is required');
-        /** Set up uniform buffer object */
-        const uboView = new DataView(new ArrayBuffer(144));
-        for (let i = 0; i < 64; i += 8) {
-            const uint32 = hash.slice(i, i + 8);
-            uboView.setUint32(i * 2, parseInt(uint32, 16));
-        }
-        uboView.setUint32(128, threshold, true);
-        uboView.setFloat32(132, NanoPowGl.#WORKLOAD - 1, true);
-        NanoPowGl.#gl.bindBuffer(NanoPowGl.#gl.UNIFORM_BUFFER, NanoPowGl.#uboBuffer);
-        NanoPowGl.#gl.bufferSubData(NanoPowGl.#gl.UNIFORM_BUFFER, 0, uboView);
-        NanoPowGl.#gl.bindBuffer(NanoPowGl.#gl.UNIFORM_BUFFER, null);
-        /** Start drawing to calculate one nonce per pixel */
-        let nonce = null;
-        const data = new DataView(new ArrayBuffer(8));
-        data.setBigUint64(0, BigInt(`0x${work}`), true);
-        const seed = new Uint8Array(data.buffer);
-        this.#draw(seed);
-        const found = await this.#checkQueryResult();
-        if (found) {
-            nonce = this.#readResult(seed);
-        }
-        if (found && nonce !== work)
-            throw new Error(`Nonce found but does not match work`);
-        return found;
-    }
-}

package/dist/classes/gpu.d.ts

@@ -1,24 +0,0 @@
-/**
-* Nano proof-of-work using WebGPU.
-*/
-export declare class NanoPowGpu {
-    #private;
-    static init(): Promise<void>;
-    static setup(): 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>;
-    /**
-    * 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
-    */
-    static validate(work: string, hash: string, threshold?: number): Promise<boolean>;
-}

package/dist/classes/gpu.js

@@ -1,236 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
-// SPDX-License-Identifier: GPL-3.0-or-later
-/// <reference types="@webgpu/types" />
-import { NanoPowGpuComputeShader } from '#shaders';
-/**
-* Nano proof-of-work using WebGPU.
-*/
-export class NanoPowGpu {
-    // Initialize WebGPU
-    static #busy = false;
-    static #device = null;
-    static #uboBuffer;
-    static #gpuBuffer;
-    static #cpuBuffer;
-    static #bindGroupLayout;
-    static #pipeline;
-    // Initialize WebGPU
-    static async init() {
-        if (this.#busy)
-            return;
-        this.#busy = true;
-        // Request device and adapter
-        if (navigator.gpu == null)
-            throw new Error('WebGPU is not supported in this browser.');
-        try {
-            const adapter = await navigator.gpu.requestAdapter();
-            if (adapter == null)
-                throw new Error('WebGPU adapter refused by browser.');
-            const device = await adapter.requestDevice();
-            if (!(device instanceof GPUDevice))
-                throw new Error('WebGPU device failed to load.');
-            device.lost.then(this.reset);
-            this.#device = device;
-            this.setup();
-        }
-        catch (err) {
-            throw new Error(`WebGPU initialization failed. ${err}`);
-        }
-        finally {
-            this.#busy = false;
-        }
-    }
-    static setup() {
-        if (this.#device == null)
-            throw new Error(`WebGPU device failed to load.`);
-        // Create buffers for writing GPU calculations and reading from Javascript
-        this.#uboBuffer = this.#device.createBuffer({
-            size: 48,
-            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
-        });
-        this.#gpuBuffer = this.#device.createBuffer({
-            size: 16,
-            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
-        });
-        this.#cpuBuffer = this.#device.createBuffer({
-            size: 16,
-            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
-        });
-        // Create binding group data structure and use it later once UBO is known
-        this.#bindGroupLayout = this.#device.createBindGroupLayout({
-            entries: [
-                {
-                    binding: 0,
-                    visibility: GPUShaderStage.COMPUTE,
-                    buffer: { type: 'uniform' },
-                },
-                {
-                    binding: 1,
-                    visibility: GPUShaderStage.COMPUTE,
-                    buffer: { type: 'storage' },
-                }
-            ]
-        });
-        // Create pipeline to connect compute shader to binding layout
-        this.#pipeline = this.#device.createComputePipeline({
-            layout: this.#device.createPipelineLayout({
-                bindGroupLayouts: [this.#bindGroupLayout]
-            }),
-            compute: {
-                entryPoint: 'main',
-                module: this.#device.createShaderModule({
-                    code: NanoPowGpuComputeShader
-                })
-            }
-        });
-    }
-    static reset() {
-        console.warn(`GPU device lost. Reinitializing...`);
-        NanoPowGpu.#cpuBuffer?.destroy();
-        NanoPowGpu.#gpuBuffer?.destroy();
-        NanoPowGpu.#uboBuffer?.destroy();
-        NanoPowGpu.#busy = false;
-        NanoPowGpu.init();
-    }
-    static async #dispatch(seed, hash, threshold, passes) {
-        if (this.#device == null)
-            throw new Error(`WebGPU device failed to load.`);
-        // Set up uniform buffer object
-        // Note: u32 size is 4, but total alignment must be multiple of 16
-        const uboView = new DataView(new ArrayBuffer(48));
-        for (let i = 0; i < 64; i += 8) {
-            const uint32 = hash.slice(i, i + 8);
-            uboView.setUint32(i / 2, parseInt(uint32, 16));
-        }
-        uboView.setBigUint64(32, seed, true);
-        uboView.setUint32(40, threshold, true);
-        this.#device.queue.writeBuffer(this.#uboBuffer, 0, uboView);
-        // Reset `nonce` and `found` to 0u in WORK before each calculation
-        this.#device.queue.writeBuffer(this.#gpuBuffer, 0, new Uint32Array([0, 0, 0]));
-        // Bind UBO read and GPU write buffers
-        const bindGroup = this.#device.createBindGroup({
-            layout: this.#bindGroupLayout,
-            entries: [
-                {
-                    binding: 0,
-                    resource: {
-                        buffer: this.#uboBuffer
-                    },
-                },
-                {
-                    binding: 1,
-                    resource: {
-                        buffer: this.#gpuBuffer
-                    },
-                },
-            ],
-        });
-        // Create command encoder to issue commands to GPU and initiate computation
-        const commandEncoder = this.#device.createCommandEncoder();
-        const passEncoder = commandEncoder.beginComputePass();
-        // Issue commands and end compute pass structure
-        passEncoder.setPipeline(this.#pipeline);
-        passEncoder.setBindGroup(0, bindGroup);
-        passEncoder.dispatchWorkgroups(passes, passes);
-        passEncoder.end();
-        // Copy 8-byte nonce and 4-byte found flag from GPU to CPU for reading
-        commandEncoder.copyBufferToBuffer(this.#gpuBuffer, 0, this.#cpuBuffer, 0, 12);
-        // End computation by passing array of command buffers to command queue for execution
-        this.#device.queue.submit([commandEncoder.finish()]);
-        // Read results back to Javascript and then unmap buffer after reading
-        let data = null;
-        try {
-            await this.#cpuBuffer.mapAsync(GPUMapMode.READ);
-            await this.#device.queue.onSubmittedWorkDone();
-            data = new DataView(this.#cpuBuffer.getMappedRange().slice(0));
-            this.#cpuBuffer.unmap();
-        }
-        catch (err) {
-            console.warn(`Error getting data from GPU. ${err}`);
-            return this.#dispatch(seed, hash, threshold, passes);
-        }
-        if (data == null)
-            throw new Error(`Failed to get data from buffer.`);
-        return data;
-    }
-    /**
-    * 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 async search(hash, threshold = 0xfffffff8) {
-        if (this.#busy) {
-            return new Promise(resolve => {
-                setTimeout(async () => {
-                    const result = this.search(hash, threshold);
-                    resolve(result);
-                }, 100);
-            });
-        }
-        this.#busy = true;
-        if (!/^[A-Fa-f0-9]{64}$/.test(hash))
-            throw new TypeError(`Invalid hash ${hash}`);
-        if (typeof threshold !== 'number')
-            throw new TypeError(`Invalid threshold ${threshold}`);
-        // Ensure WebGPU is initialized before calculating
-        let loads = 0;
-        while (this.#device == null && loads < 20) {
-            await new Promise(resolve => {
-                setTimeout(resolve, 500);
-            });
-        }
-        if (this.#device == null)
-            throw new Error(`WebGPU device failed to load.`);
-        let nonce = 0n;
-        do {
-            const random = Math.floor(Math.random() * 0xffffffff);
-            const seed = (BigInt(random) << 32n) | BigInt(random);
-            const data = await this.#dispatch(seed, hash, threshold, 0xff);
-            nonce = data.getBigUint64(0, true);
-            this.#busy = !data.getUint32(8);
-        } while (this.#busy);
-        return nonce.toString(16).padStart(16, '0');
-    }
-    /**
-    * 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
-    */
-    static async validate(work, hash, threshold = 0xfffffff8) {
-        if (this.#busy) {
-            return new Promise(resolve => {
-                setTimeout(async () => {
-                    const result = this.validate(work, hash, threshold);
-                    resolve(result);
-                }, 100);
-            });
-        }
-        this.#busy = true;
-        if (!/^[A-Fa-f0-9]{16}$/.test(work))
-            throw new TypeError(`Invalid work ${work}`);
-        if (!/^[A-Fa-f0-9]{64}$/.test(hash))
-            throw new TypeError(`Invalid hash ${hash}`);
-        if (typeof threshold !== 'number')
-            throw new TypeError(`Invalid threshold ${threshold}`);
-        // Ensure WebGPU is initialized before calculating
-        let loads = 0;
-        while (this.#device == null && loads < 20) {
-            await new Promise(resolve => {
-                setTimeout(resolve, 500);
-            });
-        }
-        if (this.#device == null)
-            throw new Error(`WebGPU device failed to load.`);
-        const seed = BigInt(`0x${work}`);
-        const data = await this.#dispatch(seed, hash, threshold, 1);
-        const nonce = data.getBigUint64(0, true).toString(16).padStart(16, '0');
-        const found = !!data.getUint32(8);
-        this.#busy = false;
-        if (found && work !== nonce)
-            throw new Error(`Nonce found but does not match work`);
-        return found;
-    }
-}

package/dist/classes/index.d.ts

@@ -1,4 +0,0 @@
-import { NanoPowGl } from "./gl.js";
-import { NanoPowGpu } from "./gpu.js";
-declare const NanoPow: typeof NanoPowGl | null;
-export { NanoPow, NanoPowGl, NanoPowGpu };

package/dist/classes/index.js

@@ -1,23 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
-// SPDX-License-Identifier: GPL-3.0-or-later
-import { NanoPowGl } from "./gl.js";
-import { NanoPowGpu } from "./gpu.js";
-let isGlSupported, isGpuSupported = false;
-try {
-    await NanoPowGl.init();
-    isGlSupported = true;
-}
-catch (err) {
-    console.warn(`WebGL is not supported in this environment.`);
-    isGlSupported = false;
-}
-try {
-    await NanoPowGpu.init();
-    isGpuSupported = true;
-}
-catch (err) {
-    console.warn(`WebGPU is not supported in this environment.`);
-    isGpuSupported = false;
-}
-const NanoPow = isGpuSupported ? NanoPowGpu : isGlSupported ? NanoPowGl : null;
-export { NanoPow, NanoPowGl, NanoPowGpu };

package/dist/global.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/global.js

@@ -1,6 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
-// SPDX-License-Identifier: GPL-3.0-or-later
-import { NanoPow as np, NanoPowGl as gl, NanoPowGpu as gpu } from './main.js';
-globalThis.NanoPow ??= np;
-globalThis.NanoPowGl ??= gl;
-globalThis.NanoPowGpu ??= gpu;