From: Chris Duncan Date: Tue, 25 Aug 2026 13:13:51 +0000 (-0700) Subject: Deprecate additional async references. X-Git-Url: https://git.codecow.com/?a=commitdiff_plain;h=c705d7900d74c545135f8ac194fa532673dcdc52;p=nano25519.git Deprecate additional async references. --- diff --git a/README.md b/README.md index 4c6baac..7589b02 100644 --- a/README.md +++ b/README.md @@ -45,27 +45,21 @@ nano25519 can be used directly on a webpage with a script module: nano25519 can be imported into NodeJS projects: ```javascript -import * as nano25519 from "nano25519"; +import { derive, sign, verify } from "nano25519"; ``` -Sync and async modules can be imported separately depending on requirements. +or ```javascript -import { derive, sign, verify } from "nano25519/sync"; -import { deriveAsync, signAsync, verifyAsync } from "nano25519/async"; +import * as nano25519 from "nano25519"; ``` ## Usage -Each function has a synchronous implementation which is preferable for speed. - -If a non-blocking solution is required, asynchronous implementations are -provided which use Web Workers in the browser or Worker threads in NodeJS. - -Inputs can be passed as Uint8Array byte arrays (preferable) or strings. The +Each primitive implementation is synchronous. Inputs can be passed as Uint8Array byte arrays (preferable) or strings. The output will return the same type as the input. A preallocated output buffer can -be passed as an additional optional argument to the sync versions of `derive()` -and `sign()` into which the result bytes will be written. +be passed as an additional optional argument for `derive()` +and `sign()`, and the result bytes will be written into it. ### Derive @@ -93,14 +87,14 @@ nano25519.derive(prv, pub); prv.fill(0); ``` -### Derive (async) +### Derive (strings) ```javascript // `prv` is a 64-character hex string private key const prv = "0000000000000000000000000000000000000000000000000000000000000000"; // `pub` is a 64-character hex string public key for a Nano account -const pub = await nano25519.deriveAsync(prv); +const pub = nano25519.derive(prv); ``` ### Sign @@ -108,11 +102,13 @@ const pub = await nano25519.deriveAsync(prv); ```javascript // `msg` is a 32-byte hash of a valid Nano transaction block const msg = new Uint8Array(blockHashBuffer); -// `sk` is a 64-byte secret key joining private and public keys -const sk = new Uint8Array(joinPrivateKeyPublicKeyBuffer); +// `prv` is a 32-byte private key +const prv = new Uint8Array(privateKeyBuffer); +// `pub` is a 32-byte public key derived from `prv` +const pub = new Uint8Array(publicKeyBuffer); // `sig` is a 64-byte Uint8Array signature for the block hash -const sig = nano25519.sign(msg, sk); +const sig = nano25519.sign(msg, prv, pub); // clean up sk.fill(0); ``` @@ -122,18 +118,20 @@ sk.fill(0); ```javascript // `msg` is a 32-byte hash of a valid Nano transaction block const msg = new Uint8Array(blockHashBuffer); -// `sk` is a 64-byte secret key joining private and public keys -const sk = new Uint8Array(joinPrivateKeyPublicKeyBuffer); +// `prv` is a 32-byte private key +const prv = new Uint8Array(privateKeyBuffer); +// `pub` is a 32-byte public key derived from `prv` +const pub = new Uint8Array(publicKeyBuffer); // `sig` is an empty 64-byte Uint8Array const sig = new Uint8Array(64); -// return discarded, 64-byte signature is written to `sig` -nano25519.sign(msg, sk); +// return value is discarded, 64-byte signature is written to `sig` +nano25519.sign(msg, prv, pub); // clean up sk.fill(0); ``` -### Sign (async) +### Sign (strings) ```javascript // `msg` is a 64-char hex string hash of a valid Nano transaction block @@ -142,11 +140,9 @@ const msg = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"; const prv = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"; // `pub` is a 64-char hex string public key derived from `prv` const pub = await nano25519.deriveAsync(prv); -// `sk` is a 128-char hex string secret key joining private and public keys -const sk = prv + pub; // `sig` is a 128-char hex string signature for the block hash -const sig = await nano25519.signAsync(msg, sk); +const sig = await nano25519.signAsync(msg, prv, pub); ``` ### Verify @@ -163,7 +159,7 @@ const pub = new Uint8Array(usersPublicKeyBuffer); const v = nano25519.verify(sig, msg, pub); ``` -### Verify (async) +### Verify (strings) ```javascript // `sig` is a 128-char hex string signature diff --git a/package.json b/package.json index 44f7292..befa68c 100644 --- a/package.json +++ b/package.json @@ -51,16 +51,6 @@ "types": "./dist/index.d.ts", "node": "./dist/index.js", "import": "./dist/browser.js" - }, - "./sync": { - "types": "./dist/sync.d.ts", - "node": "./dist/sync.js", - "import": "./dist/sync.js" - }, - "./async": { - "types": "./dist/async.d.ts", - "node": "./dist/async.js", - "import": "./dist/async.js" } }, "browser": { diff --git a/test/index.html b/test/index.html index 37bfd2f..9e5c513 100644 --- a/test/index.html +++ b/test/index.html @@ -133,9 +133,6 @@ SPDX-License-Identifier: GPL-3.0-or-later const pk8 = nano25519.derive(sk8) return [...pk8].map(b => b.toString(16).padStart(2, '0')).join('') } - case 'nano25519 (async)': { - return nano25519.deriveAsync(sk) - } case 'NanocurrencyWeb': { return NanocurrencyWeb.wallet.legacyAccounts(sk)[0].publicKey } @@ -160,9 +157,6 @@ SPDX-License-Identifier: GPL-3.0-or-later const s8 = nano25519.sign(h8, sk8) return [...s8].map(b => b.toString(16).padStart(2, '0')).join('') } - case 'nano25519 (async)': { - return nano25519.signAsync(h, sk + pk) - } case 'NanocurrencyWeb': { const { privateKey } = NanocurrencyWeb.wallet.legacyAccounts(sk)[0] return NanocurrencyWeb.tools.sign(privateKey, h) @@ -188,9 +182,6 @@ SPDX-License-Identifier: GPL-3.0-or-later case 'nano25519': { return nano25519.verify(s8, h8, pk8) } - case 'nano25519 (async)': { - return nano25519.verifyAsync(s, h, pk) - } case 'NanocurrencyWeb': { return NanocurrencyWeb.tools.verify(pk, s, h) } @@ -206,7 +197,7 @@ SPDX-License-Identifier: GPL-3.0-or-later } } - async function sequenceDeriveSignVerify(api, blockHash, privateKey) { + function sequenceDeriveSignVerify(api, blockHash, privateKey) { let start = 0, end = 0, publicKey = null, signature = null, isValid = false start = performance.now() @@ -224,7 +215,7 @@ SPDX-License-Identifier: GPL-3.0-or-later return end - start } - export async function test(api, size, runs) { + export function test(api, size, runs) { if (typeof size !== 'number' || size < 1) { size = 1 }