Deprecate typed array construction wrapper.

diff --git a/src/lib/generate/webgl/index.ts b/src/lib/generate/webgl/index.ts
index ab7cbbfd8711a6642f2d97b9818b5fb58ae69d9d..7fa8192662d6df10d870583aa3a463e5c0d8bebe 100644 (file)
--- a/src/lib/generate/webgl/index.ts
+++ b/src/lib/generate/webgl/index.ts
@@ -2,7 +2,7 @@
 //! SPDX-FileContributor: Ben Green <ben@latenightsketches.com>
 //! SPDX-License-Identifier: GPL-3.0-or-later AND MIT
 
-import { bigintAsUintNArray, bigintRandom, bigintToHex, Logger } from '#utils'
+import { Bytes, Logger, bigintRandom, bigintToHex } from '#utils'
 import { WorkGenerateResponse } from 'nano-pow'
 import { downsampleSource, drawSource, quadSource } from './shaders'
 
@@ -295,7 +295,7 @@ function init (hash: Uint32Array, difficulty: bigint): void {
 
        // Set up INPUT which must be 16 bytes per 32-bit value due to array alignment
        for (let i = 0; i < 8; i++) {
-               inputHashView.setUint32(i * 16, hash[i])
+               inputHashView.setUint32(i * 16, hash[i], true)
        }
        inputDifficultyView.setBigUint64(0, difficulty, true)
        LOG: logger.log('INPUT', inputArray.buffer.slice(0))
@@ -426,7 +426,7 @@ export async function generate (hash: bigint, difficulty: bigint, effort: number
                                if (isReady === false || effort !== drawEffort || isFirstRetry) {
                                        setup(effort)
                                }
-                               init(bigintAsUintNArray(hash, 32, 8), difficulty)
+                               init(new Uint32Array(Bytes(hash, 32).buffer), difficulty)
                                LOG: logger.log('drawing frame 0')
                                draw(bigintRandom(), drawFbos[0], queries[0])
                                draw(bigintRandom(), drawFbos[1], queries[1])

diff --git a/src/lib/generate/webgpu/index.ts b/src/lib/generate/webgpu/index.ts
index fbd2a79388c6c61e360abf2c2329bbd7fadf60dd..16b7566b881a9aa32c9fff8910b0b2ceb27ab794 100644 (file)
--- a/src/lib/generate/webgpu/index.ts
+++ b/src/lib/generate/webgpu/index.ts
@@ -1,8 +1,8 @@
 //! SPDX-FileCopyrightText: 2025 Chris Duncan <chris@codecow.com>
 //! SPDX-License-Identifier: GPL-3.0-or-later
 
+import { Bytes, Logger, Queue, bigintRandom, bigintToHex } from '#utils'
 import { WorkGenerateResponse } from 'nano-pow'
-import { bigintAsUintNArray, bigintRandom, bigintToHex, Logger, Queue } from '#utils'
 import { default as NanoPowGpuComputeShader } from './shaders/compute.wgsl'
 
 type NanoPowDeviceStatus = 'Idle' | 'Starting' | 'Unsupported' | 'Ready' | 'Restoring' | 'Crashed'
@@ -177,17 +177,17 @@ async function restore (): Promise<void> {
        }
 }
 
-async function init (hash: BigUint64Array, difficulty: bigint): Promise<void> {
+async function init (hash: Uint8Array<ArrayBuffer>, difficulty: bigint): Promise<void> {
        LOG: logger.log('variables initializing')
        try {
                // Save hash data for normal usage and potential recovery efforts
-               hashData.set(hash)
+               hashData.set(new BigUint64Array(hash.buffer))
 
                // Write data that will not change per dispatch to uniform buffer object
                // Note: u64 size is 8, but total alignment must be multiple of 16
                inputData.fill(0n)
                for (let i = 0; i < 4; i++) {
-                       inputDataView.setBigUint64(i * 8, hashData[i])
+                       inputDataView.setBigUint64(i * 8, hashData[i], true)
                }
                inputDataView.setBigUint64(32, difficulty, true)
                device.queue.writeBuffer(inputBuffers[0], 0, inputDataView)
@@ -293,7 +293,7 @@ export async function generate (hash: bigint, difficulty: bigint, effort: number
                                                throw new Error('failed to start')
                                        }
                                }
-                               await q.add(init, bigintAsUintNArray(hash, 64, 4), difficulty)
+                               await q.add(init, Bytes(hash, 32), difficulty)
                                // Dispatch initial workgroups and set index
                                await dispatch(0, bigintRandom(), effort)
                                let dispatchIndex = 1

diff --git a/src/lib/index.ts b/src/lib/index.ts
index 592fb304db7f1473d31e59f4754959c332a94383..2ec72c13509e66864c2f0ea395876d5737d6b53f 100644 (file)
--- a/src/lib/index.ts
+++ b/src/lib/index.ts
@@ -4,7 +4,7 @@
 import { NanoPowConfig } from '#lib/config'
 import { NanoPowCpu, NanoPowWasm, NanoPowWebgl, NanoPowWebgpu } from '#lib/generate'
 import { NanoPowValidate } from '#lib/validate'
-import { bigintFrom, Bytes, Cache, Logger, Queue } from '#utils'
+import { Bytes, Cache, Logger, Queue, bigintFrom } from '#utils'
 import { WorkErrorResponse, WorkGenerateResponse, WorkValidateResponse } from 'nano-pow'
 
 const logger = new Logger()
@@ -32,16 +32,16 @@ export async function generate (hash: unknown, options?: unknown): Promise<WorkG
                        }
                        switch (api) {
                                case 'webgpu': {
-                                       return Cache.store(await NanoPowWebgpu(bigintFrom(hash, 'hex'), difficulty, effort, debug))
+                                       return Cache.store(await NanoPowWebgpu(bigintHash, difficulty, effort, debug))
                                }
                                case 'webgl': {
-                                       return Cache.store(await NanoPowWebgl(bigintFrom(hash, 'hex'), difficulty, effort, debug))
+                                       return Cache.store(await NanoPowWebgl(bigintHash, difficulty, effort, debug))
                                }
                                case 'wasm': {
-                                       return Cache.store(await NanoPowWasm(bigintFrom(hash, 'hex'), difficulty, effort, debug))
+                                       return Cache.store(await NanoPowWasm(bigintHash, difficulty, effort, debug))
                                }
                                default: {
-                                       return Cache.store(await NanoPowCpu(bigintFrom(hash, 'hex'), difficulty, debug))
+                                       return Cache.store(await NanoPowCpu(bigintHash, difficulty, debug))
                                }
                        }
                } catch (e: any) {
@@ -52,10 +52,8 @@ export async function generate (hash: unknown, options?: unknown): Promise<WorkG
 
 export async function validate (work: unknown, hash: unknown, options?: unknown): Promise<WorkValidateResponse | WorkErrorResponse> {
        try {
-               const hashBytes = Bytes(hash, 32)
-               const workBytes = Bytes(work, 8)
                const { debug, difficulty } = await NanoPowConfig(options)
-               const result = await NanoPowValidate(workBytes, hashBytes, difficulty, debug)
+               const result = await NanoPowValidate(Bytes(work, 8), Bytes(hash, 32), difficulty, debug)
                return result
        } catch (e: any) {
                return { error: (typeof e === 'string' ? e : (e?.message ?? '')) }

diff --git a/src/utils/bigint.ts b/src/utils/bigint.ts
index 3360b88cd77373c5106c52a20549527c5627a765..962afd384392f70707fe3711ef2277cc414d094c 100644 (file)
--- a/src/utils/bigint.ts
+++ b/src/utils/bigint.ts
@@ -1,27 +1,6 @@
 //! SPDX-FileCopyrightText: 2025 Chris Duncan <chris@codecow.com>
 //! SPDX-License-Identifier: GPL-3.0-or-later
 
-export function bigintAsUintNArray (int: bigint, bits: number, length: number = 0) {
-       const UintTypedArray: { [key: number]: any } = {
-               8: Uint8Array,
-               16: Uint16Array,
-               32: Uint32Array,
-               64: BigUint64Array
-       }
-       if (![8, 16, 32, 64].includes(bits)) throw new Error('Invalid TypedArray UintN subclass')
-       if (int < 0n) int = ~(int - 1n)
-       length = Math.max(length, Math.ceil(bigintByteLength(int) / bits))
-       const mask: bigint = (1n << BigInt(bits)) - 1n
-       const uintArray = new UintTypedArray[bits](length)
-       for (let i = length - 1; i >= 0; i--) {
-               bits === 64
-                       ? uintArray[i] = int & mask
-                       : uintArray[i] = (Number(int & mask))
-               int >>= BigInt(bits)
-       }
-       return uintArray
-}
-
 export function bigintBitLength (int: bigint): bigint {
        let bitLength = 1n
        while (int > 1n || int < -1n) {

diff --git a/src/utils/bytes.ts b/src/utils/bytes.ts
index cfc6d1cfc3df4c229ccac7d50d434fe01b004982..93a90ab628f8f129ba894589b21fda851747b9a7 100644 (file)
--- a/src/utils/bytes.ts
+++ b/src/utils/bytes.ts
@@ -33,7 +33,7 @@ export function Bytes (input: unknown, minLength: unknown = 1): Uint8Array<Array
  * Convert a byte buffer to a hex string.
  *
  * @param {ArrayBuffer} input
- * @param {number} [length]
+ * @param {number} [minLength]
  * @returns {string}
  */
 export function BytesToHex (input: ArrayBuffer, minLength?: number): string