-->
Miro Metsänheimo <miro@metsanheimo.fi>
+Ben Green <ben@latenightsketches.com> (numtel.github.io)
Chris Duncan <chris@zoso.dev> (zoso.dev)
--- /dev/null
+// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+if (globalThis.sessionStorage == null) {
+ let _sessionStorage = {}
+ Object.defineProperty(globalThis, 'sessionStorage', {
+ value: {
+ length: Object.entries(_sessionStorage).length,
+ setItem: (key, value) => _sessionStorage[key] = value,
+ getItem: (key) => _sessionStorage[key],
+ removeItem: (key) => delete _sessionStorage[key],
+ clear: () => _sessionStorage = {}
+ },
+ configurable: true,
+ enumerable: true
+ })
+}
+
+export function average (times) {
+ let sum = 0, reciprocals = 0, product = 1, count = times.length
+ for (let i = 0; i < count; i++) {
+ sum += times[i]
+ reciprocals += 1 / times[i]
+ product *= times[i]
+ }
+ return {
+ total: sum,
+ arithmetic: sum / count,
+ harmonic: count / reciprocals,
+ geometric: Math.pow(product, 1 / count)
+ }
+}
+
+const failures = []
+const passes = []
+function fail (...args) {
+ failures.push(args)
+ console.error(`%cFAIL `, 'color:red', ...args)
+}
+function pass (...args) {
+ passes.push(args)
+ console.log(`%cPASS `, 'color:green', ...args)
+}
+
+
+/**
+* Who watches the watchers?
+*/
+await suite('TEST RUNNER CHECK', async () => {
+ console.assert(failures.length === 0)
+ console.assert(passes.length === 0)
+
+ await test('promise should pass', new Promise(resolve => { resolve('') }))
+ console.assert(failures.some(call => /.*promise should pass.*/.test(call[0])) === false, `good promise errored`)
+ console.assert(passes.some(call => /.*promise should pass.*/.test(call[0])) === true, `good promise not logged`)
+
+ await test('promise should fail', new Promise((resolve, reject) => { reject('FAILURE EXPECTED HERE') }))
+ console.assert(failures.some(call => /.*promise should fail.*/.test(call[0])) === true, `bad promise not errored`)
+ console.assert(passes.some(call => /.*promise should fail.*/.test(call[0])) === false, 'bad promise logged')
+
+ await test('async should pass', async () => {})
+ console.assert(failures.some(call => /.*async should pass.*/.test(call[0])) === false, 'good async errored')
+ console.assert(passes.some(call => /.*async should pass.*/.test(call[0])) === true, 'good async not logged')
+
+ await test('async should fail', async () => { throw new Error('FAILURE EXPECTED HERE') })
+ console.assert(failures.some(call => /.*async should fail.*/.test(call[0])) === true, 'bad async not errored')
+ console.assert(passes.some(call => /.*async should fail.*/.test(call[0])) === false, 'bad async logged')
+
+ await test('function should pass', () => {})
+ console.assert(failures.some(call => /.*function should pass.*/.test(call[0])) === false, 'good function errored')
+ console.assert(passes.some(call => /.*function should pass.*/.test(call[0])) === true, 'good function not logged')
+
+ await test('function should fail', 'FAILURE EXPECTED HERE')
+ console.assert(failures.some(call => /.*function should fail.*/.test(call[0])) === true, 'bad function not errored')
+ console.assert(passes.some(call => /.*function should fail.*/.test(call[0])) === false, 'bad function logged')
+
+ console.log(`%cTEST RUNNER CHECK DONE`, 'font-weight:bold')
+})
+
+export function skip (name, fn) {
+ return new Promise(resolve => {
+ console.log(`%cSKIP `, 'color:blue', name)
+ resolve(null)
+ })
+}
+
+export function suite (name, fn) {
+ if (fn.constructor.name === 'AsyncFunction') fn = fn()
+ if (typeof fn === 'function') fn = new Promise(resolve => resolve(fn()))
+ return new Promise(async (resolve) => {
+ console.group(`%c${name}`, 'font-weight:bold')
+ await fn
+ console.groupEnd()
+ resolve(null)
+ })
+}
+
+export function test (name, fn) {
+ if (fn instanceof Promise) {
+ try {
+ return fn
+ .then(() => pass(name))
+ .catch((err) => { fail(`${name}: ${err}`) })
+ } catch (err) {
+ fail(`${name}: ${err.message}`)
+ fail(err)
+ }
+ } else if (fn?.constructor?.name === 'AsyncFunction') {
+ try {
+ return fn()
+ .then(() => pass(name))
+ .catch((err) => fail(`${name}: ${err.message}`))
+ } catch (err) {
+ fail(`${name}: ${err.message}`)
+ fail(err)
+ }
+ } else if (typeof fn === 'function') {
+ try {
+ fn()
+ pass(name)
+ } catch (err) {
+ fail(`${name}: ${err.message}`)
+ fail(err)
+ }
+ } else {
+ fail(`${name}: test cannot execute on ${typeof fn} ${fn}`)
+ }
+}
+
+export const assert = {
+ ok: (bool) => {
+ if (typeof bool !== 'boolean') {
+ throw new Error('Invalid assertion')
+ }
+ if (!bool) {
+ throw new Error(`test result falsy`)
+ }
+ return true
+ },
+ exists: (a) => {
+ if (a == null) {
+ const type = /^[aeiou]/i.test(typeof a) ? `an ${typeof a}` : `a ${typeof a}`
+ throw new Error(`argument exists and is ${type}`)
+ }
+ return a != null
+ },
+ equals: (a, b) => {
+ if (a == null || b == null) {
+ throw new Error(`assert.equals() will not compare null or undefined`)
+ }
+ if (a !== b) {
+ throw new Error(`${a} not equal to ${b}`)
+ }
+ return a === b
+ },
+ notEqual: (a, b) => {
+ if (a == null || b == null) {
+ throw new Error(`assert.notEqual() will not compare null or undefined`)
+ }
+ if (a === b) {
+ throw new Error(`${a} equals ${b}`)
+ }
+ return a !== b
+ },
+ rejects: async (fn, msg) => {
+ if (fn instanceof Promise) {
+ try {
+ fn.then(() => { throw new Error(msg ?? 'expected async function to reject') })
+ .catch((err) => { return true })
+ } catch (err) {
+ return true
+ }
+ } else if (fn.constructor.name === 'AsyncFunction') {
+ try {
+ fn.then(() => { throw new Error(msg ?? 'expected async function to reject') })
+ .catch((err) => { return true })
+ } catch (err) {
+ return true
+ }
+ } else {
+ throw new Error(msg ?? 'expected async function')
+ }
+ },
+ resolves: async (fn, msg) => {
+ if (fn instanceof Promise) {
+ try {
+ fn.then(() => { return true })
+ .catch((err) => { throw new Error(msg ?? 'expected async function to resolve') })
+ return true
+ } catch (err) {
+ throw new Error(msg ?? 'expected async function to resolve')
+ }
+ } else if (fn.constructor.name === 'AsyncFunction') {
+ try {
+ fn().then(() => { return true })
+ .catch((err) => { throw new Error(msg ?? 'expected async function to resolve') })
+ return true
+ } catch (err) {
+ throw new Error(msg ?? 'expected async function to resolve')
+ }
+ } else {
+ throw new Error('expected async function')
+ }
+ },
+ throws: (fn, msg) => {
+ if (typeof fn !== 'function') {
+ throw new Error('expected function')
+ }
+ if (fn instanceof Promise || fn.constructor.name === 'AsyncFunction') {
+ throw new Error('expected synchronous function')
+ }
+ try {
+ fn()
+ throw new Error(msg ?? `expected function to throw an exception`)
+ } catch (err) {
+ return true
+ }
+ }
+}
--- /dev/null
+ISC License:
+
+Copyright (c) 2004-2010 by Internet Systems Consortium, Inc. ("ISC")
+Copyright (c) 1995-2003 by Internet Software Consortium
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
MIT License
Copyright (c) 2022 Miro Metsänheimo
+Copyright (c) 2018 Ben Green
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
--- /dev/null
+<!DOCTYPE html>
+
+<head>
+ <link rel="icon" href="./favicon.ico">
+ <script type="module" src="https://zoso.dev/?p=libnemo.git;a=blob_plain;f=global.min.js;hb=refs/heads/threads"></script>
+ <script type="module" src="https://cdn.jsdelivr.net/npm/nano-webgl-pow@1.1.1/nano-webgl-pow.js"></script>
+ <script type="module">
+ (async () => {
+ const times = []
+ const works = document.getElementById('works')
+ const block = new libnemo.SendBlock(
+ 'nano_1e5aqegc1jb7qe964u4adzmcezyo6o146zb8hm6dft8tkp79za3sxwjym5rx',
+ '11618869000000000000000000000000',
+ 'nano_1q3hqecaw15cjt7thbtxu3pbzr1eihtzzpzxguoc37bj1wc5ffoh7w74gi6p',
+ '0',
+ 'nano_1stofnrxuz3cai7ze75o174bpm7scwj9jn3nxsn8ntzg784jf1gzn1jjdkou',
+ '92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D'
+ )
+ for (let i = 0; i < 0x10; i++) {
+ const start = performance.now()
+ await block.pow()
+ const end = performance.now()
+ times.push(end - start)
+ works.innerHTML += `libnemo-powgl: ${block.work} (${end - start} ms)<br/>`
+ console.log(block.work)
+ }
+ let sum = 0, reciprocals = 0, product = 1, count = times.length
+ for (let i = 0; i < count; i++) {
+ sum += times[i]
+ reciprocals += 1 / times[i]
+ product *= times[i]
+ }
+ const t = document.getElementById('times')
+ t.innerHTML = `libnemo-powgl<br/>
+Total: ${sum} ms<br/>
+Average: ${sum / count} ms<br/>
+Harmonic: ${count / reciprocals} ms<br/>
+Geometric: ${Math.pow(product, 1 / count)} ms<br/>`
+ })()
+ </script>
+ <script type="module">
+ (async () => {
+ const times = []
+ const works = document.getElementById('works')
+ for (let i = 0; i < 0x10; i++) {
+ const start = performance.now()
+ const work = await new Promise(resolve => {
+ window.NanoWebglPow('92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D', resolve, undefined, '0xFFFFFFF8')
+ })
+ const end = performance.now()
+ times.push(end - start)
+ works.innerHTML += `nano-webgl-pow: ${work} (${end - start} ms)<br/>`
+ }
+ let sum = 0, reciprocals = 0, product = 1, count = times.length
+ for (let i = 0; i < count; i++) {
+ sum += times[i]
+ reciprocals += 1 / times[i]
+ product *= times[i]
+ }
+ const t = document.getElementById('times')
+ t.innerHTML += `nano-webgl-pow<br/>
+Total: ${sum} ms<br/>
+Average: ${sum / count} ms<br/>
+Harmonic: ${count / reciprocals} ms<br/>
+Geometric: ${Math.pow(product, 1 / count)} ms<br/>`
+ })()
+
+ </script>
+ <style>body{background:black;color:white;}</style>
+</head>
+
+<body>
+ <p id="times"></p>
+ <p id="works"></p>
+</body>
+
+</html>
"name": "libnemo",
"version": "0.0.21",
"license": "(GPL-3.0-or-later AND MIT)",
- "dependencies": {
- "blake2b": "^2.1.4"
- },
"devDependencies": {
- "@types/blake2b": "^2.1.3",
- "@types/node": "^22.8.6",
+ "@types/node": "^22.10.1",
"@types/w3c-web-hid": "^1.0.6",
"@types/w3c-web-usb": "^1.0.10",
"@types/web-bluetooth": "^0.0.20",
"esbuild": "^0.24.0",
+ "nano-webgl-pow": "^1.1.1",
"typescript": "^5.6.3"
},
"funding": {
"@ledgerhq/hw-transport-webusb": "^6.29.4"
}
},
- "node_modules/@esbuild/aix-ppc64": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.24.0.tgz",
- "integrity": "sha512-WtKdFM7ls47zkKHFVzMz8opM7LkcsIp9amDUBIAWirg70RM71WRSjdILPsY5Uv1D42ZpUfaPILDlfactHgsRkw==",
- "cpu": [
- "ppc64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "aix"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/android-arm": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.24.0.tgz",
- "integrity": "sha512-arAtTPo76fJ/ICkXWetLCc9EwEHKaeya4vMrReVlEIUCAUncH7M4bhMQ+M9Vf+FFOZJdTNMXNBrWwW+OXWpSew==",
- "cpu": [
- "arm"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "android"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/android-arm64": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.24.0.tgz",
- "integrity": "sha512-Vsm497xFM7tTIPYK9bNTYJyF/lsP590Qc1WxJdlB6ljCbdZKU9SY8i7+Iin4kyhV/KV5J2rOKsBQbB77Ab7L/w==",
- "cpu": [
- "arm64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "android"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/android-x64": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.24.0.tgz",
- "integrity": "sha512-t8GrvnFkiIY7pa7mMgJd7p8p8qqYIz1NYiAoKc75Zyv73L3DZW++oYMSHPRarcotTKuSs6m3hTOa5CKHaS02TQ==",
- "cpu": [
- "x64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "android"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/darwin-arm64": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.24.0.tgz",
- "integrity": "sha512-CKyDpRbK1hXwv79soeTJNHb5EiG6ct3efd/FTPdzOWdbZZfGhpbcqIpiD0+vwmpu0wTIL97ZRPZu8vUt46nBSw==",
- "cpu": [
- "arm64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "darwin"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/darwin-x64": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.24.0.tgz",
- "integrity": "sha512-rgtz6flkVkh58od4PwTRqxbKH9cOjaXCMZgWD905JOzjFKW+7EiUObfd/Kav+A6Gyud6WZk9w+xu6QLytdi2OA==",
- "cpu": [
- "x64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "darwin"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/freebsd-arm64": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.24.0.tgz",
- "integrity": "sha512-6Mtdq5nHggwfDNLAHkPlyLBpE5L6hwsuXZX8XNmHno9JuL2+bg2BX5tRkwjyfn6sKbxZTq68suOjgWqCicvPXA==",
- "cpu": [
- "arm64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "freebsd"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/freebsd-x64": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.24.0.tgz",
- "integrity": "sha512-D3H+xh3/zphoX8ck4S2RxKR6gHlHDXXzOf6f/9dbFt/NRBDIE33+cVa49Kil4WUjxMGW0ZIYBYtaGCa2+OsQwQ==",
- "cpu": [
- "x64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "freebsd"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/linux-arm": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.24.0.tgz",
- "integrity": "sha512-gJKIi2IjRo5G6Glxb8d3DzYXlxdEj2NlkixPsqePSZMhLudqPhtZ4BUrpIuTjJYXxvF9njql+vRjB2oaC9XpBw==",
- "cpu": [
- "arm"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/linux-arm64": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.24.0.tgz",
- "integrity": "sha512-TDijPXTOeE3eaMkRYpcy3LarIg13dS9wWHRdwYRnzlwlA370rNdZqbcp0WTyyV/k2zSxfko52+C7jU5F9Tfj1g==",
- "cpu": [
- "arm64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/linux-ia32": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.24.0.tgz",
- "integrity": "sha512-K40ip1LAcA0byL05TbCQ4yJ4swvnbzHscRmUilrmP9Am7//0UjPreh4lpYzvThT2Quw66MhjG//20mrufm40mA==",
- "cpu": [
- "ia32"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/linux-loong64": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.24.0.tgz",
- "integrity": "sha512-0mswrYP/9ai+CU0BzBfPMZ8RVm3RGAN/lmOMgW4aFUSOQBjA31UP8Mr6DDhWSuMwj7jaWOT0p0WoZ6jeHhrD7g==",
- "cpu": [
- "loong64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/linux-mips64el": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.24.0.tgz",
- "integrity": "sha512-hIKvXm0/3w/5+RDtCJeXqMZGkI2s4oMUGj3/jM0QzhgIASWrGO5/RlzAzm5nNh/awHE0A19h/CvHQe6FaBNrRA==",
- "cpu": [
- "mips64el"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/linux-ppc64": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.24.0.tgz",
- "integrity": "sha512-HcZh5BNq0aC52UoocJxaKORfFODWXZxtBaaZNuN3PUX3MoDsChsZqopzi5UupRhPHSEHotoiptqikjN/B77mYQ==",
- "cpu": [
- "ppc64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/linux-riscv64": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.24.0.tgz",
- "integrity": "sha512-bEh7dMn/h3QxeR2KTy1DUszQjUrIHPZKyO6aN1X4BCnhfYhuQqedHaa5MxSQA/06j3GpiIlFGSsy1c7Gf9padw==",
- "cpu": [
- "riscv64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/linux-s390x": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.24.0.tgz",
- "integrity": "sha512-ZcQ6+qRkw1UcZGPyrCiHHkmBaj9SiCD8Oqd556HldP+QlpUIe2Wgn3ehQGVoPOvZvtHm8HPx+bH20c9pvbkX3g==",
- "cpu": [
- "s390x"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "linux"
- ],
- "engines": {
- "node": ">=18"
- }
- },
"node_modules/@esbuild/linux-x64": {
"version": "0.24.0",
"resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.24.0.tgz",
"node": ">=18"
}
},
- "node_modules/@esbuild/netbsd-x64": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.24.0.tgz",
- "integrity": "sha512-hjQ0R/ulkO8fCYFsG0FZoH+pWgTTDreqpqY7UnQntnaKv95uP5iW3+dChxnx7C3trQQU40S+OgWhUVwCjVFLvg==",
- "cpu": [
- "x64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "netbsd"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/openbsd-arm64": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.24.0.tgz",
- "integrity": "sha512-MD9uzzkPQbYehwcN583yx3Tu5M8EIoTD+tUgKF982WYL9Pf5rKy9ltgD0eUgs8pvKnmizxjXZyLt0z6DC3rRXg==",
- "cpu": [
- "arm64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "openbsd"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/openbsd-x64": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.24.0.tgz",
- "integrity": "sha512-4ir0aY1NGUhIC1hdoCzr1+5b43mw99uNwVzhIq1OY3QcEwPDO3B7WNXBzaKY5Nsf1+N11i1eOfFcq+D/gOS15Q==",
- "cpu": [
- "x64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "openbsd"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/sunos-x64": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.24.0.tgz",
- "integrity": "sha512-jVzdzsbM5xrotH+W5f1s+JtUy1UWgjU0Cf4wMvffTB8m6wP5/kx0KiaLHlbJO+dMgtxKV8RQ/JvtlFcdZ1zCPA==",
- "cpu": [
- "x64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "sunos"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/win32-arm64": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.24.0.tgz",
- "integrity": "sha512-iKc8GAslzRpBytO2/aN3d2yb2z8XTVfNV0PjGlCxKo5SgWmNXx82I/Q3aG1tFfS+A2igVCY97TJ8tnYwpUWLCA==",
- "cpu": [
- "arm64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "win32"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/win32-ia32": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.24.0.tgz",
- "integrity": "sha512-vQW36KZolfIudCcTnaTpmLQ24Ha1RjygBo39/aLkM2kmjkWmZGEJ5Gn9l5/7tzXA42QGIoWbICfg6KLLkIw6yw==",
- "cpu": [
- "ia32"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "win32"
- ],
- "engines": {
- "node": ">=18"
- }
- },
- "node_modules/@esbuild/win32-x64": {
- "version": "0.24.0",
- "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.24.0.tgz",
- "integrity": "sha512-7IAFPrjSQIJrGsK6flwg7NFmwBoSTyF3rl7If0hNUFQU4ilTsEPL6GuMuU9BfIWVVGuRnuIidkSMC+c0Otu8IA==",
- "cpu": [
- "x64"
- ],
- "dev": true,
- "license": "MIT",
- "optional": true,
- "os": [
- "win32"
- ],
- "engines": {
- "node": ">=18"
- }
- },
"node_modules/@ledgerhq/devices": {
"version": "8.4.4",
"resolved": "https://registry.npmjs.org/@ledgerhq/devices/-/devices-8.4.4.tgz",
"license": "Apache-2.0",
"optional": true
},
- "node_modules/@types/blake2b": {
- "version": "2.1.3",
- "resolved": "https://registry.npmjs.org/@types/blake2b/-/blake2b-2.1.3.tgz",
- "integrity": "sha512-MFCdX0MNxFBP/xEILO5Td0kv6nI7+Q2iRWZbTL/yzH2/eDVZS5Wd1LHdsmXClvsCyzqaZfHFzZaN6BUeUCfSDA==",
- "dev": true,
- "license": "MIT"
- },
"node_modules/@types/node": {
- "version": "22.9.0",
- "resolved": "https://registry.npmjs.org/@types/node/-/node-22.9.0.tgz",
- "integrity": "sha512-vuyHg81vvWA1Z1ELfvLko2c8f34gyA0zaic0+Rllc5lbCnbSyuvb2Oxpm6TAUAC/2xZN3QGqxBNggD1nNR2AfQ==",
+ "version": "22.10.1",
+ "resolved": "https://registry.npmjs.org/@types/node/-/node-22.10.1.tgz",
+ "integrity": "sha512-qKgsUwfHZV2WCWLAnVP1JqnpE6Im6h3Y0+fYgMTasNQ7V++CBX5OT1as0g0f+OyubbFqhf6XVNIsmN4IIhEgGQ==",
"dev": true,
"license": "MIT",
"dependencies": {
- "undici-types": "~6.19.8"
+ "undici-types": "~6.20.0"
}
},
"node_modules/@types/w3c-web-hid": {
"dev": true,
"license": "MIT"
},
- "node_modules/b4a": {
- "version": "1.6.7",
- "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.6.7.tgz",
- "integrity": "sha512-OnAYlL5b7LEkALw87fUVafQw5rVR9RjwGd4KUwNQ6DrrNmaVaUCgLipfVlzrPQ4tWOR9P0IXGNOx50jYCCdSJg==",
- "license": "Apache-2.0"
- },
- "node_modules/blake2b": {
- "version": "2.1.4",
- "resolved": "https://registry.npmjs.org/blake2b/-/blake2b-2.1.4.tgz",
- "integrity": "sha512-AyBuuJNI64gIvwx13qiICz6H6hpmjvYS5DGkG6jbXMOT8Z3WUJ3V1X0FlhIoT1b/5JtHE3ki+xjtMvu1nn+t9A==",
- "license": "ISC",
- "dependencies": {
- "blake2b-wasm": "^2.4.0",
- "nanoassert": "^2.0.0"
- }
- },
- "node_modules/blake2b-wasm": {
- "version": "2.4.0",
- "resolved": "https://registry.npmjs.org/blake2b-wasm/-/blake2b-wasm-2.4.0.tgz",
- "integrity": "sha512-S1kwmW2ZhZFFFOghcx73+ZajEfKBqhP82JMssxtLVMxlaPea1p9uoLiUZ5WYyHn0KddwbLc+0vh4wR0KBNoT5w==",
- "license": "MIT",
- "dependencies": {
- "b4a": "^1.0.1",
- "nanoassert": "^2.0.0"
- }
- },
"node_modules/esbuild": {
"version": "0.24.0",
"resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.24.0.tgz",
"node": ">=0.8.x"
}
},
- "node_modules/nanoassert": {
- "version": "2.0.0",
- "resolved": "https://registry.npmjs.org/nanoassert/-/nanoassert-2.0.0.tgz",
- "integrity": "sha512-7vO7n28+aYO4J+8w96AzhmU8G+Y/xpPDJz/se19ICsqj/momRbb9mh9ZUtkoJ5X3nTnPdhEJyc0qnM6yAsHBaA==",
- "license": "ISC"
+ "node_modules/nano-webgl-pow": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/nano-webgl-pow/-/nano-webgl-pow-1.1.1.tgz",
+ "integrity": "sha512-IKAg7qx2y4n9dnT7tYYypOun/aV+35SfRxJCVnc63GboWQ5/woVIVAZcdX5VfXM1mLYBzADvXxoWZ39G3iPOFA==",
+ "dev": true,
+ "license": "MIT"
},
"node_modules/rxjs": {
"version": "7.8.1",
}
},
"node_modules/undici-types": {
- "version": "6.19.8",
- "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.19.8.tgz",
- "integrity": "sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==",
+ "version": "6.20.0",
+ "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.20.0.tgz",
+ "integrity": "sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==",
"dev": true,
"license": "MIT"
}
"url": "git+https://zoso.dev/libnemo.git"
},
"scripts": {
- "build": "rm -rf dist && tsc && esbuild main.min=dist/main.js global.min=dist/global.js --outdir=dist --target=es2022 --format=esm --platform=browser --bundle --minify --sourcemap",
- "test": "npm run build -- --platform=node && node --test --test-force-exit --env-file .env",
- "test:coverage": "npm run test -- --experimental-test-coverage",
- "test:coverage:report": "npm run test:coverage -- --test-reporter=lcov --test-reporter-destination=coverage.info && genhtml coverage.info --output-directory test/coverage && rm coverage.info && xdg-open test/coverage/index.html"
+ "build": "rm -rf dist && tsc && esbuild main.min=dist/main.js global.min=dist/global.js --outdir=dist --target=esnext --format=esm --platform=browser --bundle --sourcemap",
+ "test": "npm run build && esbuild test.min=test/main.mjs --outdir=dist --target=esnext --format=esm --platform=browser --bundle --sourcemap",
+ "test:node": "npm run build -- --platform=node && node --test --test-force-exit --env-file .env",
+ "test:coverage": "npm run test:node -- --experimental-test-coverage",
+ "test:coverage:report": "npm run test:coverage -- --test-reporter=lcov --test-reporter-destination=coverage.info && genhtml coverage.info --output-directory test/coverage && rm coverage.info && xdg-open test/coverage/index.html",
+ "test:performance": "npm run build && esbuild perf.min=perf/main.mjs --outdir=dist --target=esnext --format=esm --platform=browser --bundle --sourcemap"
},
- "dependencies": {
- "blake2b": "^2.1.4"
+ "imports": {
+ "#*": "./*"
},
"optionalDependencies": {
"@ledgerhq/hw-transport-web-ble": "^6.29.4",
"@ledgerhq/hw-transport-webusb": "^6.29.4"
},
"devDependencies": {
- "@types/blake2b": "^2.1.3",
- "@types/node": "^22.8.6",
+ "@types/node": "^22.10.1",
"@types/w3c-web-hid": "^1.0.6",
"@types/w3c-web-usb": "^1.0.10",
"@types/web-bluetooth": "^0.0.20",
"esbuild": "^0.24.0",
+ "nano-webgl-pow": "^1.1.1",
"typescript": "^5.6.3"
},
"type": "module",
--- /dev/null
+// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+'use strict'
+
+import { assert, average, skip, suite, test } from '#GLOBALS.mjs'
+import { NANO_TEST_VECTORS } from '#test/TEST_VECTORS.js'
+import { Bip44Wallet, Blake2bWallet } from '#dist/main.js'
+
+await suite('Account performance', async () => {
+ await test('Time to create 0x200 BIP-44 accounts', async () => {
+ const wallet = await Bip44Wallet.create(NANO_TEST_VECTORS.PASSWORD)
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)
+ const start = performance.now()
+ const accounts = await wallet.accounts(0, 0x1fff)
+ const end = performance.now()
+ console.log(`Total: ${end - start} ms`)
+ console.log(`Average: ${(end - start) / 0x2000} ms`)
+ assert.equals(accounts.length, 0x2000)
+ })
+
+ await test('Time to create 0x200 BLAKE2b accounts', async () => {
+ const wallet = await Blake2bWallet.create(NANO_TEST_VECTORS.PASSWORD)
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)
+ const start = performance.now()
+ const accounts = await wallet.accounts(0, 0x1fff)
+ const end = performance.now()
+ console.log(`Total: ${end - start} ms`)
+ console.log(`Average: ${(end - start) / 0x2000} ms`)
+ assert.equals(accounts.length, 0x2000)
+ })
+
+ await test('Time to create 1 BIP-44 account 0x20 times', async () => {
+ const times = []
+ const wallet = await Bip44Wallet.create(NANO_TEST_VECTORS.PASSWORD)
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)
+ for (let i = 0; i < 0x20; i++) {
+ const start = performance.now()
+ await wallet.accounts(i)
+ const end = performance.now()
+ times.push(end - start)
+ }
+ const { total, arithmetic, harmonic, geometric } = average(times)
+ console.log(`Total: ${total} ms`)
+ console.log(`Average: ${arithmetic} ms`)
+ console.log(`Harmonic: ${harmonic} ms`)
+ console.log(`Geometric: ${geometric} ms`)
+ })
+
+ await test('Average time to create 1 BLAKE2b account 0x20 times', async () => {
+ const times = []
+ const wallet = await Blake2bWallet.create(NANO_TEST_VECTORS.PASSWORD)
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)
+ for (let i = 0; i < 0x20; i++) {
+ const start = performance.now()
+ await wallet.accounts(i)
+ const end = performance.now()
+ times.push(end - start)
+ }
+ const { total, arithmetic, harmonic, geometric } = average(times)
+ console.log(`Total: ${total} ms`)
+ console.log(`Average: ${arithmetic} ms`)
+ console.log(`Harmonic: ${harmonic} ms`)
+ console.log(`Geometric: ${geometric} ms`)
+ })
+})
--- /dev/null
+// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+'use strict'
+
+import { assert, average, skip, suite, test } from '#GLOBALS.mjs'
+import { NANO_TEST_VECTORS } from '#test/TEST_VECTORS.js'
+import { SendBlock } from '#dist/main.js'
+import 'nano-webgl-pow'
+
+await suite('Block performance', async () => {
+ const COUNT = 0x10
+
+ await test(`Customized PoW: Time to calculate proof-of-work for a send block ${COUNT} times`, async () => {
+ const times = []
+ const block = new SendBlock(
+ NANO_TEST_VECTORS.SEND_BLOCK.account,
+ NANO_TEST_VECTORS.SEND_BLOCK.balance,
+ NANO_TEST_VECTORS.SEND_BLOCK.link,
+ '0',
+ NANO_TEST_VECTORS.SEND_BLOCK.representative,
+ NANO_TEST_VECTORS.SEND_BLOCK.previous
+ )
+ for (let i = 0; i < COUNT; i++) {
+ const start = performance.now()
+ await block.pow()
+ const end = performance.now()
+ times.push(end - start)
+ console.log(`${block.work} (${end - start} ms)`)
+ }
+ const { total, arithmetic, harmonic, geometric } = average(times)
+ console.log(`Total: ${total} ms`)
+ console.log(`Average: ${arithmetic} ms`)
+ console.log(`Harmonic: ${harmonic} ms`)
+ console.log(`Geometric: ${geometric} ms`)
+ })
+
+ await test(`Original PoW module: Time to calculate proof-of-work for a send block ${COUNT} times`, async () => {
+ const times = []
+ for (let i = 0; i < COUNT; i++) {
+ const start = performance.now()
+ const work = await new Promise(resolve => {
+ //@ts-expect-error
+ window.NanoWebglPow(NANO_TEST_VECTORS.SEND_BLOCK.previous, resolve, undefined, '0xFFFFFFF8')
+ })
+ const end = performance.now()
+ times.push(end - start)
+ console.log(`${work} (${end - start} ms)`)
+ }
+ const { total, arithmetic, harmonic, geometric } = average(times)
+ console.log(`Total: ${total} ms`)
+ console.log(`Average: ${arithmetic} ms`)
+ console.log(`Harmonic: ${harmonic} ms`)
+ console.log(`Geometric: ${geometric} ms`)
+ })
+})
--- /dev/null
+// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// import './wallet.perf.js'
+// import './account.perf.js'
+import './block.perf.js'
+
+console.log('%cTESTING COMPLETE', 'color:orange;font-weight:bold')
--- /dev/null
+// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+'use strict'
+
+import { assert, average, skip, suite, test } from '#GLOBALS.mjs'
+import { NANO_TEST_VECTORS } from '#test/TEST_VECTORS.js'
+import { Bip44Wallet, Blake2bWallet } from '#dist/main.js'
+
+await suite(`Wallet performance`, async () => {
+ const COUNT = 0x20
+
+ await test(`Time to create ${COUNT} BIP-44 wallets`, async () => {
+ const times = []
+ for (let i = 0; i < COUNT; i++) {
+ const start = performance.now()
+ const wallet = await Bip44Wallet.create(NANO_TEST_VECTORS.PASSWORD)
+ const end = performance.now()
+ times.push(end - start)
+ }
+ const { total, arithmetic, harmonic, geometric } = average(times)
+ console.log(`Total: ${total} ms`)
+ console.log(`Average: ${arithmetic} ms`)
+ console.log(`Harmonic: ${harmonic} ms`)
+ console.log(`Geometric: ${geometric} ms`)
+ })
+
+ await test(`Time to create ${COUNT} BLAKE2b wallets`, async () => {
+ const times = []
+ for (let i = 0; i < COUNT; i++) {
+ const start = performance.now()
+ const wallet = await Blake2bWallet.create(NANO_TEST_VECTORS.PASSWORD)
+ const end = performance.now()
+ times.push(end - start)
+ }
+ const { total, arithmetic, harmonic, geometric } = average(times)
+ console.log(`Total: ${total} ms`)
+ console.log(`Average: ${arithmetic} ms`)
+ console.log(`Harmonic: ${harmonic} ms`)
+ console.log(`Geometric: ${geometric} ms`)
+ })
+})
--- /dev/null
+<!DOCTYPE html>
+
+<head>
+ <link rel="icon" href="./favicon.ico">
+ <script type="module" src="./dist/perf.min.js"></script>
+ <style>body{background:black;}</style>
+</head>
+
+<body></body>
+
+</html>
// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>\r
// SPDX-License-Identifier: GPL-3.0-or-later\r
\r
-import blake2b from 'blake2b'\r
+import { Blake2b } from './blake2b.js'\r
import { ACCOUNT_KEY_LENGTH, ALPHABET, PREFIX, PREFIX_LEGACY } from './constants.js'\r
import { base32, bytes, hex } from './convert.js'\r
-import Ed25519 from './ed25519.js'\r
import { Rpc } from './rpc.js'\r
import { Safe } from './safe.js'\r
+import { NanoNaCl } from './workers/nano-nacl.js'\r
\r
/**\r
* Represents a single Nano address and the associated public key. To include the\r
* be fetched from the network.\r
*/\r
export class Account {\r
+ static #isInternal: boolean = false\r
#a: string\r
#pub: string\r
#prv: string | null\r
if (v?.constructor === Account) {\r
this.#rep = v\r
} else if (typeof v === 'string') {\r
- this.#rep = new Account(v)\r
+ this.#rep = Account.fromAddress(v)\r
} else {\r
throw new TypeError(`Invalid argument for account representative: ${v}`)\r
}\r
}\r
set weight (v) { this.#w = v ? BigInt(v) : undefined }\r
\r
- constructor (address: string, index?: number) {\r
- Account.validate(address)\r
+ constructor (address: string, publicKey: string, privateKey?: string, index?: number) {\r
+ if (!Account.#isInternal) {\r
+ throw new Error(`Account cannot be instantiated directly. Use factory methods instead.`)\r
+ }\r
if (index !== undefined && typeof index !== 'number') {\r
throw new TypeError(`Invalid index ${index} when creating Account ${address}`)\r
}\r
this.#a = address\r
.replace(PREFIX, '')\r
.replace(PREFIX_LEGACY, '')\r
- this.#pub = Account.#addressToKey(this.#a)\r
- this.#prv = null\r
+ this.#pub = publicKey\r
+ this.#prv = privateKey ?? null\r
this.#i = index\r
this.#s = new Safe()\r
+ Account.#isInternal = false\r
+ }\r
+\r
+ /**\r
+ * Instantiates an Account object from its Nano address.\r
+ *\r
+ * @param {string} address - Address of the account\r
+ * @param {number} [index] - Account number used when deriving the address\r
+ * @returns {Account} The instantiated Account object\r
+ */\r
+ static fromAddress (address: string, index?: number): Account {\r
+ Account.#isInternal = true\r
+ Account.validate(address)\r
+ const publicKey = Account.#addressToKey(address)\r
+ const account = new this(address, publicKey, undefined, index)\r
+ return account\r
}\r
\r
/**\r
- * Asynchronously instantiates an Account object from its public key.\r
+ * Instantiates an Account object from its public key.\r
*\r
- * @param {string} key - Public key of the account\r
+ * @param {string} publicKey - Public key of the account\r
* @param {number} [index] - Account number used when deriving the key\r
- * @returns {Promise<Account>} The instantiated Account object\r
+ * @returns {Account} The instantiated Account object\r
*/\r
- static async fromPublicKey (key: string, index?: number): Promise<Account> {\r
- Account.#validateKey(key)\r
- const address = await Account.#keyToAddress(key)\r
- const account = new this(address, index)\r
+ static fromPublicKey (publicKey: string, index?: number): Account {\r
+ Account.#isInternal = true\r
+ Account.#validateKey(publicKey)\r
+ const address = Account.#keyToAddress(publicKey)\r
+ const account = new this(address, publicKey, undefined, index)\r
return account\r
}\r
\r
/**\r
- * Asynchronously instantiates an Account object from its private key.\r
+ * Instantiates an Account object from its private key. The\r
+ * corresponding public key will automatically be derived and saved.\r
+ *\r
+ * @param {string} privateKey - Private key of the account\r
+ * @param {number} [index] - Account number used when deriving the key\r
+ * @returns {Account} A new Account object\r
+ */\r
+ static fromPrivateKey (privateKey: string, index?: number): Account {\r
+ Account.#isInternal = true\r
+ Account.#validateKey(privateKey)\r
+ const publicKey = NanoNaCl.convert(privateKey)\r
+ const account = Account.fromPublicKey(publicKey, index)\r
+ account.#prv = privateKey.toUpperCase()\r
+ return account\r
+ }\r
+\r
+ /**\r
+ * Instantiates an Account object from its public and private\r
+ * keys.\r
+ *\r
+ * WARNING: The validity of the keys is checked, but they are assumed to have\r
+ * been precalculated. Whether they are an actual matching pair is NOT checked!\r
+ * If unsure, use `Account.fromPrivateKey(key)` instead.\r
*\r
- * @param {string} key - Private key of the account\r
+ * @param {string} publicKey - Public key of the account\r
+ * @param {string} privateKey - Private key of the account\r
* @param {number} [index] - Account number used when deriving the key\r
- * @returns {Promise<Account>} A new Account object\r
+ * @returns {Account} The instantiated Account object\r
*/\r
- static async fromPrivateKey (key: string, index?: number): Promise<Account> {\r
- Account.#validateKey(key)\r
- const publicKey = Ed25519.getPublicKey(key)\r
- const account = await Account.fromPublicKey(publicKey, index)\r
- account.#prv = key.toUpperCase()\r
+ static fromKeypair (privateKey: string, publicKey: string, index?: number): Account {\r
+ Account.#isInternal = true\r
+ Account.#validateKey(privateKey)\r
+ const account = Account.fromPublicKey(publicKey, index)\r
+ account.#prv = privateKey.toUpperCase()\r
return account\r
}\r
\r
const expectedChecksum = address.slice(-8)\r
const keyBase32 = address.slice(address.indexOf('_') + 1, -8)\r
const keyBuf = base32.toBytes(keyBase32)\r
- const actualChecksumBuf = blake2b(5, undefined, undefined, undefined, true)\r
- .update(keyBuf).digest().reverse()\r
+ const actualChecksumBuf = new Blake2b(5).update(keyBuf).digest()\r
+ actualChecksumBuf.reverse()\r
const actualChecksum = bytes.toBase32(actualChecksumBuf)\r
\r
if (expectedChecksum !== actualChecksum) {\r
this.#b = BigInt(balance)\r
this.#f = frontier\r
this.#r = BigInt(receivable)\r
- this.#rep = new Account(representative)\r
+ this.#rep = Account.fromAddress(representative)\r
this.#w = BigInt(weight)\r
}\r
\r
static #addressToKey (v: string): string {\r
- const keyBytes = base32.toBytes(v.substring(0, 52))\r
- const checksumBytes = base32.toBytes(v.substring(52, 60))\r
- const blakeHash = blake2b(5, undefined, undefined, undefined, true)\r
- .update(keyBytes).digest().reverse()\r
- if (bytes.toHex(checksumBytes) !== bytes.toHex(blakeHash)) {\r
+ const publicKeyBytes = base32.toBytes(v.slice(-60, -8))\r
+ const checksumBytes = base32.toBytes(v.slice(-8))\r
+ const rechecksumBytes = new Blake2b(5).update(publicKeyBytes).digest().reverse()\r
+ if (bytes.toHex(checksumBytes) !== bytes.toHex(rechecksumBytes)) {\r
throw new Error('Checksum mismatch in address')\r
}\r
- return bytes.toHex(keyBytes)\r
+ return bytes.toHex(publicKeyBytes)\r
}\r
\r
- static async #keyToAddress (key: string): Promise<string> {\r
- const publicKeyBytes = hex.toBytes(key)\r
- const checksum = blake2b(5, undefined, undefined, undefined, true)\r
- .update(publicKeyBytes).digest().reverse()\r
- const encoded = bytes.toBase32(publicKeyBytes)\r
- const encodedChecksum = bytes.toBase32(checksum)\r
- return `${PREFIX}${encoded}${encodedChecksum}`\r
+ static #keyToAddress (publicKey: string): string {\r
+ const publicKeyBytes = hex.toBytes(publicKey)\r
+ const checksumBytes = new Blake2b(5).update(publicKeyBytes).digest().reverse()\r
+ const encodedPublicKey = bytes.toBase32(publicKeyBytes)\r
+ const encodedChecksum = bytes.toBase32(checksumBytes)\r
+ return `${PREFIX}${encodedPublicKey}${encodedChecksum}`\r
}\r
\r
static #validateKey (key: string): void {\r
+++ /dev/null
-// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>\r
-// SPDX-License-Identifier: GPL-3.0-or-later\r
-\r
-import { BIP44_COIN_NANO, BIP44_PURPOSE, HARDENED_OFFSET, SLIP10_ED25519 } from './constants.js'\r
-import { bytes, dec, hex, utf8 } from './convert.js'\r
-\r
-type ExtendedKey = {\r
- privateKey: string\r
- chainCode: string\r
-}\r
-\r
-/**\r
-* Derives a private child key following the BIP-32 and BIP-44 derivation path\r
-* registered to the Nano block lattice. Only hardened child keys are defined.\r
-*\r
-* @param {string} seed - Hexadecimal seed derived from mnemonic phrase\r
-* @param {number} index - Account number between 0 and 2^31-1\r
-* @returns Private child key for the account\r
-*/\r
-export async function nanoCKD (seed: string, index: number): Promise<string> {\r
- if (!Number.isSafeInteger(index) || index < 0 || index > 0x7fffffff) {\r
- throw new RangeError(`Invalid child key index 0x${index.toString(16)}`)\r
- }\r
- const masterKey = await slip10(SLIP10_ED25519, seed)\r
- const purposeKey = await CKDpriv(masterKey, BIP44_PURPOSE + HARDENED_OFFSET)\r
- const coinKey = await CKDpriv(purposeKey, BIP44_COIN_NANO + HARDENED_OFFSET)\r
- const accountKey = await CKDpriv(coinKey, index + HARDENED_OFFSET)\r
- return accountKey.privateKey\r
-}\r
-\r
-async function slip10 (curve: string, S: string): Promise<ExtendedKey> {\r
- const key = utf8.toBytes(curve)\r
- const data = hex.toBytes(S)\r
- const I = await hmac(key, data)\r
- const IL = I.slice(0, I.length / 2)\r
- const IR = I.slice(I.length / 2)\r
- return ({ privateKey: IL, chainCode: IR })\r
-}\r
-\r
-async function CKDpriv ({ privateKey, chainCode }: ExtendedKey, index: number): Promise<ExtendedKey> {\r
- const key = hex.toBytes(chainCode)\r
- const data = hex.toBytes(`00${bytes.toHex(ser256(privateKey))}${bytes.toHex(ser32(index))}`)\r
- const I = await hmac(key, data)\r
- const IL = I.slice(0, I.length / 2)\r
- const IR = I.slice(I.length / 2)\r
- return ({ privateKey: IL, chainCode: IR })\r
-}\r
-\r
-function ser32 (integer: number): Uint8Array {\r
- if (typeof integer !== 'number') {\r
- throw new TypeError(`Expected a number, received ${typeof integer}`)\r
- }\r
- const bits = dec.toBin(integer)\r
- if (bits.length > 32) {\r
- throw new RangeError(`Expected 32-bit integer, received ${bits.length}-bit value: ${integer}`)\r
- }\r
- return dec.toBytes(integer, 4)\r
-}\r
-\r
-function ser256 (integer: string): Uint8Array {\r
- if (typeof integer !== 'string') {\r
- throw new TypeError(`Expected string, received ${typeof integer}`)\r
- }\r
- const bits = hex.toBin(integer)\r
- if (bits.length > 256) {\r
- throw new RangeError(`Expected 256-bit integer, received ${bits.length}-bit value: ${integer}`)\r
- }\r
- return hex.toBytes(integer, 32)\r
-}\r
-\r
-async function hmac (key: Uint8Array, data: Uint8Array): Promise<string> {\r
- const { subtle } = globalThis.crypto\r
- const pk = await subtle.importKey('raw', key, { name: 'HMAC', hash: 'SHA-512' }, false, ['sign'])\r
- const signature = await subtle.sign('HMAC', pk, data)\r
- return bytes.toHex(new Uint8Array(signature))\r
-}\r
* @returns {string} Mnemonic phrase created using the BIP-39 wordlist\r
*/\r
static async fromEntropy (entropy: string): Promise<Bip39Mnemonic> {\r
- const e = new Entropy(entropy)\r
+ const e = await Entropy.import(entropy)\r
const checksum = await this.checksum(e)\r
let concatenation = `${e.bits}${checksum}`\r
- const words = []\r
+ const words: string[] = []\r
while (concatenation.length > 0) {\r
const wordBits = concatenation.substring(0, 11)\r
const wordIndex = parseInt(wordBits, 2)\r
* used to generate the mnemonic phrase.\r
*\r
* @param {Entropy} entropy - Cryptographically strong pseudorandom data of length N bits\r
- * @returns First N/32 bits of the hash as a hexadecimal string\r
+ * @returns {Promise<string>} First N/32 bits of the hash as a hexadecimal string\r
*/\r
static async checksum (entropy: Entropy): Promise<string> {\r
const hashBuffer = await subtle.digest('SHA-256', entropy.bytes)\r
return false\r
}\r
\r
- const entropy = new Entropy(bin.toBytes(entropyBits))\r
+ const entropy = await Entropy.import(bin.toBytes(entropyBits))\r
const expectedChecksum = await this.checksum(entropy)\r
\r
if (expectedChecksum !== checksumBits) {\r
--- /dev/null
+// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+/**
+* Implementation derived from blake2b@2.1.4. Copyright 2017 Emil Bay
+* <github@tixz.dk> (https://github.com/emilbayes/blake2b). See LICENSES/ISC.txt
+*
+* Modified to eliminate dependencies, port to TypeScript, and embed in web
+* workers.
+*
+* Original source commit: https://github.com/emilbayes/blake2b/blob/1f63e02e3f226642959506cdaa67c8819ff145cd/index.js
+*/
+
+export class Blake2b {
+ static BYTES_MIN: number = 1
+ static BYTES_MAX: number = 64
+ static KEYBYTES_MIN: number = 16
+ static KEYBYTES_MAX: number = 64
+ static SALTBYTES: number = 16
+ static PERSONALBYTES: number = 16
+
+ // Initialization Vector
+ static BLAKE2B_IV32: Uint32Array = new Uint32Array([
+ 0xF3BCC908, 0x6A09E667, 0x84CAA73B, 0xBB67AE85,
+ 0xFE94F82B, 0x3C6EF372, 0x5F1D36F1, 0xA54FF53A,
+ 0xADE682D1, 0x510E527F, 0x2B3E6C1F, 0x9B05688C,
+ 0xFB41BD6B, 0x1F83D9AB, 0x137E2179, 0x5BE0CD19
+ ])
+
+ static SIGMA8: number[] = [
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+ 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,
+ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,
+ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,
+ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,
+ 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11,
+ 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10,
+ 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5,
+ 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0,
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3
+ ]
+
+ /**
+ * These are offsets into a uint64 buffer.
+ * Multiply them all by 2 to make them offsets into a uint32 buffer,
+ * because this is Javascript and we don't have uint64s
+ */
+ static SIGMA82: Uint8Array = new Uint8Array(this.SIGMA8.map(x => x * 2))
+
+ // reusable parameter_block
+ static parameter_block: Uint8Array = new Uint8Array([
+ 0, 0, 0, 0, // 0: outlen, keylen, fanout, depth
+ 0, 0, 0, 0, // 4: leaf length, sequential mode
+ 0, 0, 0, 0, // 8: node offset
+ 0, 0, 0, 0, // 12: node offset
+ 0, 0, 0, 0, // 16: node depth, inner length, rfu
+ 0, 0, 0, 0, // 20: rfu
+ 0, 0, 0, 0, // 24: rfu
+ 0, 0, 0, 0, // 28: rfu
+ 0, 0, 0, 0, // 32: salt
+ 0, 0, 0, 0, // 36: salt
+ 0, 0, 0, 0, // 40: salt
+ 0, 0, 0, 0, // 44: salt
+ 0, 0, 0, 0, // 48: personal
+ 0, 0, 0, 0, // 52: personal
+ 0, 0, 0, 0, // 56: personal
+ 0, 0, 0, 0 // 60: personal
+ ])
+
+
+ static v: Uint32Array = new Uint32Array(32)
+ static m: Uint32Array = new Uint32Array(32)
+
+ /**
+ * 64-bit unsigned addition
+ * Sets v[a,a+1] += v[b,b+1]
+ * v should be a Uint32Array
+ */
+ static ADD64AA (v: Uint32Array, a: number, b: number): void {
+ var o0 = v[a] + v[b]
+ var o1 = v[a + 1] + v[b + 1]
+ if (o0 >= 0x100000000) {
+ o1++
+ }
+ v[a] = o0
+ v[a + 1] = o1
+ }
+
+ /**
+ * 64-bit unsigned addition
+ * Sets v[a,a+1] += b
+ * b0 is the low 32 bits of b, b1 represents the high 32 bits
+ */
+ static ADD64AC (v: Uint32Array, a: number, b0: number, b1: number): void {
+ var o0 = v[a] + b0
+ if (b0 < 0) {
+ o0 += 0x100000000
+ }
+ var o1 = v[a + 1] + b1
+ if (o0 >= 0x100000000) {
+ o1++
+ }
+ v[a] = o0
+ v[a + 1] = o1
+ }
+
+ // Little-endian byte access
+ static B2B_GET32 (arr: Uint8Array, i: number): number {
+ return (arr[i] ^
+ (arr[i + 1] << 8) ^
+ (arr[i + 2] << 16) ^
+ (arr[i + 3] << 24))
+ }
+
+ /**
+ * G Mixing function
+ * The ROTRs are inlined for speed
+ */
+ static B2B_G (a: number, b: number, c: number, d: number, ix: number, iy: number): void {
+ var x0 = Blake2b.m[ix]
+ var x1 = Blake2b.m[ix + 1]
+ var y0 = Blake2b.m[iy]
+ var y1 = Blake2b.m[iy + 1]
+
+ Blake2b.ADD64AA(Blake2b.v, a, b) // v[a,a+1] += v[b,b+1] ... in JS we must store a uint64 as two uint32s
+ Blake2b.ADD64AC(Blake2b.v, a, x0, x1) // v[a, a+1] += x ... x0 is the low 32 bits of x, x1 is the high 32 bits
+
+ // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated to the right by 32 bits
+ var xor0 = Blake2b.v[d] ^ Blake2b.v[a]
+ var xor1 = Blake2b.v[d + 1] ^ Blake2b.v[a + 1]
+ Blake2b.v[d] = xor1
+ Blake2b.v[d + 1] = xor0
+
+ Blake2b.ADD64AA(Blake2b.v, c, d)
+
+ // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 24 bits
+ xor0 = Blake2b.v[b] ^ Blake2b.v[c]
+ xor1 = Blake2b.v[b + 1] ^ Blake2b.v[c + 1]
+ Blake2b.v[b] = (xor0 >>> 24) ^ (xor1 << 8)
+ Blake2b.v[b + 1] = (xor1 >>> 24) ^ (xor0 << 8)
+
+ Blake2b.ADD64AA(Blake2b.v, a, b)
+ Blake2b.ADD64AC(Blake2b.v, a, y0, y1)
+
+ // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated right by 16 bits
+ xor0 = Blake2b.v[d] ^ Blake2b.v[a]
+ xor1 = Blake2b.v[d + 1] ^ Blake2b.v[a + 1]
+ Blake2b.v[d] = (xor0 >>> 16) ^ (xor1 << 16)
+ Blake2b.v[d + 1] = (xor1 >>> 16) ^ (xor0 << 16)
+
+ Blake2b.ADD64AA(Blake2b.v, c, d)
+
+ // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 63 bits
+ xor0 = Blake2b.v[b] ^ Blake2b.v[c]
+ xor1 = Blake2b.v[b + 1] ^ Blake2b.v[c + 1]
+ Blake2b.v[b] = (xor1 >>> 31) ^ (xor0 << 1)
+ Blake2b.v[b + 1] = (xor0 >>> 31) ^ (xor1 << 1)
+ }
+
+ /**
+ * Compression function. 'last' flag indicates last block.
+ * Note we're representing 16 uint64s as 32 uint32s
+ */
+ static blake2bCompress (ctx: any, last: boolean): void {
+ let i = 0
+
+ // init work variables
+ for (i = 0; i < 16; i++) {
+ Blake2b.v[i] = ctx.h[i]
+ Blake2b.v[i + 16] = Blake2b.BLAKE2B_IV32[i]
+ }
+
+ // low 64 bits of offset
+ Blake2b.v[24] = Blake2b.v[24] ^ ctx.t
+ Blake2b.v[25] = Blake2b.v[25] ^ (ctx.t / 0x100000000)
+ // high 64 bits not supported, offset may not be higher than 2**53-1
+
+ // last block flag set ?
+ if (last) {
+ Blake2b.v[28] = ~Blake2b.v[28]
+ Blake2b.v[29] = ~Blake2b.v[29]
+ }
+
+ // get little-endian words
+ for (i = 0; i < 32; i++) {
+ Blake2b.m[i] = Blake2b.B2B_GET32(ctx.b, 4 * i)
+ }
+
+ // twelve rounds of mixing
+ for (i = 0; i < 12; i++) {
+ Blake2b.B2B_G(0, 8, 16, 24, Blake2b.SIGMA82[i * 16 + 0], Blake2b.SIGMA82[i * 16 + 1])
+ Blake2b.B2B_G(2, 10, 18, 26, Blake2b.SIGMA82[i * 16 + 2], Blake2b.SIGMA82[i * 16 + 3])
+ Blake2b.B2B_G(4, 12, 20, 28, Blake2b.SIGMA82[i * 16 + 4], Blake2b.SIGMA82[i * 16 + 5])
+ Blake2b.B2B_G(6, 14, 22, 30, Blake2b.SIGMA82[i * 16 + 6], Blake2b.SIGMA82[i * 16 + 7])
+ Blake2b.B2B_G(0, 10, 20, 30, Blake2b.SIGMA82[i * 16 + 8], Blake2b.SIGMA82[i * 16 + 9])
+ Blake2b.B2B_G(2, 12, 22, 24, Blake2b.SIGMA82[i * 16 + 10], Blake2b.SIGMA82[i * 16 + 11])
+ Blake2b.B2B_G(4, 14, 16, 26, Blake2b.SIGMA82[i * 16 + 12], Blake2b.SIGMA82[i * 16 + 13])
+ Blake2b.B2B_G(6, 8, 18, 28, Blake2b.SIGMA82[i * 16 + 14], Blake2b.SIGMA82[i * 16 + 15])
+ }
+
+ for (i = 0; i < 16; i++) {
+ ctx.h[i] = ctx.h[i] ^ Blake2b.v[i] ^ Blake2b.v[i + 16]
+ }
+ }
+
+ /**
+ * Updates a BLAKE2b streaming hash
+ * Requires hash context and Uint8Array (byte array)
+ */
+ static blake2bUpdate (ctx: any, input: Uint8Array): void {
+ for (var i = 0; i < input.length; i++) {
+ if (ctx.c === 128) { // buffer full ?
+ ctx.t += ctx.c // add counters
+ Blake2b.blake2bCompress(ctx, false) // compress (not last)
+ ctx.c = 0 // counter to zero
+ }
+ ctx.b[ctx.c++] = input[i]
+ }
+ }
+
+ /**
+ * Completes a BLAKE2b streaming hash
+ * Returns a Uint8Array containing the message digest
+ */
+ static blake2bFinal (ctx: any, out: Uint8Array): Uint8Array {
+ ctx.t += ctx.c // mark last block offset
+
+ while (ctx.c < 128) { // fill up with zeros
+ ctx.b[ctx.c++] = 0
+ }
+ Blake2b.blake2bCompress(ctx, true) // final block flag = 1
+
+ for (var i = 0; i < ctx.outlen; i++) {
+ out[i] = ctx.h[i >> 2] >> (8 * (i & 3))
+ }
+ return out
+ }
+
+ static hexSlice (buf: Uint8Array): string {
+ let str = ''
+ for (let i = 0; i < buf.length; i++) str += Blake2b.toHex(buf[i])
+ return str
+ }
+
+ static toHex (n: number): string {
+ if (typeof n !== 'number')
+ throw new TypeError(`expected number to convert to hex; received ${typeof n}`)
+ if (n < 0 || n > 255)
+ throw new RangeError(`expected byte value 0-255; received ${n}`)
+ return n.toString(16).padStart(2, '0')
+ }
+
+ b: Uint8Array
+ h: Uint32Array
+ t: number
+ c: number
+ outlen: number
+
+ /**
+ * Creates a BLAKE2b hashing context
+ * Requires an output length between 1 and 64 bytes
+ * Takes an optional Uint8Array key
+ */
+ constructor (outlen: number, key?: Uint8Array, salt?: Uint8Array, personal?: Uint8Array, noAssert?: boolean) {
+ if (noAssert !== true) {
+ if (outlen < Blake2b.BYTES_MIN) throw new RangeError(`expected outlen >= ${Blake2b.BYTES_MIN}; actual ${outlen}`)
+ if (outlen > Blake2b.BYTES_MAX) throw new RangeError(`expectd outlen <= ${Blake2b.BYTES_MAX}; actual ${outlen}`)
+ if (key != null) {
+ if (!(key instanceof Uint8Array)) throw new TypeError(`key must be Uint8Array or Buffer`)
+ if (key.length < Blake2b.KEYBYTES_MIN) throw new RangeError(`expected key >= ${Blake2b.KEYBYTES_MIN}; actual ${key.length}`)
+ if (key.length > Blake2b.KEYBYTES_MAX) throw new RangeError(`expected key <= ${Blake2b.KEYBYTES_MAX}; actual ${key.length}`)
+ }
+ if (salt != null) {
+ if (!(salt instanceof Uint8Array)) throw new TypeError(`salt must be Uint8Array or Buffer`)
+ if (salt.length !== Blake2b.SALTBYTES) throw new RangeError(`expected salt ${Blake2b.SALTBYTES} bytes; actual ${salt.length} bytes`)
+ }
+ if (personal != null) {
+ if (!(personal instanceof Uint8Array)) throw new TypeError(`personal must be Uint8Array or Buffer`)
+ if (personal.length !== Blake2b.PERSONALBYTES) throw new RangeError(`expected personal ${Blake2b.PERSONALBYTES} bytes; actual ${personal.length} bytes`)
+ }
+ }
+
+ this.b = new Uint8Array(128)
+ this.h = new Uint32Array(16)
+ this.t = 0 // input count
+ this.c = 0 // pointer within buffer
+ this.outlen = outlen // output length in bytes
+
+ // zero out parameter_block before usage
+ Blake2b.parameter_block.fill(0)
+ // state, 'param block'
+
+ Blake2b.parameter_block[0] = outlen
+ if (key) Blake2b.parameter_block[1] = key.length
+ Blake2b.parameter_block[2] = 1 // fanout
+ Blake2b.parameter_block[3] = 1 // depth
+
+ if (salt) Blake2b.parameter_block.set(salt, 32)
+ if (personal) Blake2b.parameter_block.set(personal, 48)
+
+ // initialize hash state
+ for (var i = 0; i < 16; i++) {
+ this.h[i] = Blake2b.BLAKE2B_IV32[i] ^ Blake2b.B2B_GET32(Blake2b.parameter_block, i * 4)
+ }
+
+ // key the hash, if applicable
+ if (key) {
+ Blake2b.blake2bUpdate(this, key)
+ // at the end
+ this.c = 128
+ }
+ }
+
+ update (input: Uint8Array): Blake2b {
+ if (!(input instanceof Uint8Array))
+ throw new TypeError(`input must be Uint8Array or Buffer`)
+ Blake2b.blake2bUpdate(this, input)
+ return this
+ }
+
+ digest (): Uint8Array
+ digest (out: 'hex'): string
+ digest (out: 'binary' | Uint8Array): Uint8Array
+ digest (out?: 'binary' | 'hex' | Uint8Array): string | Uint8Array {
+ const buf = (!out || out === 'binary' || out === 'hex') ? new Uint8Array(this.outlen) : out
+ if (!(buf instanceof Uint8Array)) throw new TypeError(`out must be "binary", "hex", Uint8Array, or Buffer`)
+ if (buf.length < this.outlen) throw new RangeError(`out must have at least outlen bytes of space`)
+ Blake2b.blake2bFinal(this, buf)
+ if (out === 'hex') return Blake2b.hexSlice(buf) as string
+ return buf
+ }
+}
+
+export default Blake2b.toString()
// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>
// SPDX-License-Identifier: GPL-3.0-or-later
-import { BURN_ADDRESS, PREAMBLE } from './constants.js'
+import { BURN_ADDRESS, PREAMBLE, THRESHOLD_RECEIVE, THRESHOLD_SEND } from './constants.js'
import { Account } from './account.js'
-import { bytes, dec, hex } from './convert.js'
-import Ed25519 from './ed25519.js'
+import { Blake2b } from './blake2b.js'
+import { dec, hex } from './convert.js'
+import { NanoNaCl } from './workers/nano-nacl.js'
+import { Pool } from './pool.js'
import { Rpc } from './rpc.js'
-import Tools from './tools.js'
+import { Pow } from './workers.js'
/**
* Represents a block as defined by the Nano cryptocurrency protocol. The Block
* of three derived classes: SendBlock, ReceiveBlock, ChangeBlock.
*/
abstract class Block {
+ static #pool: Pool = new Pool(Pow)
account: Account
type: string = 'state'
abstract subtype: 'send' | 'receive' | 'change'
if (account.constructor === Account) {
this.account = account
} else if (typeof account === 'string') {
- this.account = new Account(account)
+ this.account = Account.fromAddress(account)
} else {
throw new TypeError('Invalid account')
}
/**
* Converts the block to JSON format as expected by the `process` RPC.
*
- * @returns JSON representation of the block
+ * @returns {string} JSON representation of the block
*/
json (): { [key: string]: string } {
return {
/**
* Hashes the block using Blake2b.
*
- * @returns {Promise<Uint8Array>} Block data hashed to a byte array
+ * @returns {Promise<string>} Block data hashed to a byte array
*/
- async hash (): Promise<Uint8Array> {
+ async hash (): Promise<string> {
const data = [
PREAMBLE,
this.account.publicKey,
dec.toHex(this.balance, 32),
this.link
]
- const hash = await Tools.hash(data, 'hex')
- return hex.toBytes(hash)
+ const hash = new Blake2b(32)
+ data.forEach(str => hash.update(hex.toBytes(str)))
+ return hash.digest('hex').toUpperCase()
}
/**
- * Sends the block to a node for calculating proof-of-work on the network.
+ * Calculates proof-of-work using a pool of WebGL workers.
*
* A successful response sets the `work` property.
- *
- * @param {Rpc|string|URL} rpc - RPC node information required to call `work_generate`
*/
- async pow (rpc: Rpc | string | URL): Promise<void> {
- if (typeof rpc === 'string' || rpc.constructor === URL) {
- rpc = new Rpc(rpc)
- }
- if (rpc.constructor !== Rpc) {
- throw new TypeError('RPC must be a valid node')
- }
+ async pow (): Promise<void> {
const data = {
- "hash": this.previous
+ "hash": this.previous,
+ "threshold": (this instanceof SendBlock || this instanceof ChangeBlock)
+ ? THRESHOLD_SEND
+ : THRESHOLD_RECEIVE
}
- const { work } = await rpc.call('work_generate', data)
+ const [{ work }] = await Block.#pool.assign([data])
this.work = work
}
this.signature = result.signature
} else {
const key = input ?? this.account.privateKey
- if (!key) {
+ if (key == null) {
throw new Error('No valid key found to sign block')
}
- const signature = Ed25519.sign(
- await this.hash(),
- hex.toBytes(key)
- )
- this.signature = bytes.toHex(signature)
+ const account = await Account.fromPrivateKey(key)
+ try {
+ const signature = NanoNaCl.detached(
+ hex.toBytes(await this.hash()),
+ hex.toBytes(`${account.privateKey}`)
+ )
+ this.signature = signature
+ } catch (err) {
+ throw new Error(`Failed to sign block with key ${key}: ${err}`)
+ }
}
}
dec.toHex(this.balance, 32),
this.link
]
- const hash = await Tools.hash(data, 'hex')
- return Ed25519.verify(
- hex.toBytes(hash),
- hex.toBytes(key),
- hex.toBytes(this.signature ?? '')
+ const hash = new Blake2b(32)
+ data.forEach(str => hash.update(hex.toBytes(str)))
+ const blockHash = hash.digest('hex').toUpperCase()
+ return NanoNaCl.verify(
+ hex.toBytes(blockHash),
+ hex.toBytes(this.signature ?? ''),
+ hex.toBytes(key)
)
}
}
constructor (sender: Account | string, balance: string, recipient: string, amount: string, representative: string, frontier: string, work?: string) {
super(sender)
this.previous = frontier
- this.representative = new Account(representative)
- this.link = new Account(recipient).publicKey
+ this.representative = Account.fromAddress(representative)
+ this.link = Account.fromAddress(recipient).publicKey
this.work = work ?? ''
const bigBalance = BigInt(balance)
constructor (recipient: string, balance: string, origin: string, amount: string, representative: string, frontier?: string, work?: string) {
super(recipient)
- this.previous = frontier ?? new Account(recipient).publicKey
- this.representative = new Account(representative)
+ this.previous = frontier ?? Account.fromAddress(recipient).publicKey
+ this.representative = Account.fromAddress(representative)
this.link = origin
this.work = work ?? ''
previous: string
representative: Account
balance: bigint
- link: string = new Account(BURN_ADDRESS).publicKey
+ link: string = Account.fromAddress(BURN_ADDRESS).publicKey
signature?: string
work?: string
constructor (account: string, balance: string, representative: string, frontier: string, work?: string) {
super(account)
this.previous = frontier
- this.representative = new Account(representative)
+ this.representative = Account.fromAddress(representative)
this.balance = BigInt(balance)
this.work = work ?? ''
export const SEED_LENGTH_BIP44 = 128
export const SEED_LENGTH_BLAKE2B = 64
export const SLIP10_ED25519 = 'ed25519 seed'
+export const THRESHOLD_RECEIVE = 0xfffffe00
+export const THRESHOLD_SEND = 0xfffffff8
export const XNO = 'Ó¾'
export const LEDGER_STATUS_CODES: { [key: number]: string } = Object.freeze({
\r
export const base32 = {\r
/**\r
- * Convert a base32 string to a Uint8Array of bytes.\r
+ * Converts a base32 string to a Uint8Array of bytes.\r
*\r
* @param {string} base32 - String to convert\r
* @returns {Uint8Array} Byte array representation of the input string\r
output = output.slice(1)\r
}\r
return output\r
+ },\r
+ /**\r
+ * Converts a base32 string to a hexadecimal string.\r
+ *\r
+ * @param {string} base32 - String to convert\r
+ * @returns {string} Hexadecimal representation of the input base32\r
+ */\r
+ toHex (base32: string): string {\r
+ return bytes.toHex(this.toBytes(base32))\r
}\r
}\r
\r
* @returns {Uint8Array} Byte array representation of the input string\r
*/\r
toBytes (bin: string): Uint8Array {\r
- const bytes = []\r
+ const bytes: number[] = []\r
while (bin.length > 0) {\r
const bits = bin.substring(0, 8)\r
bytes.push(parseInt(bits, 2))\r
return new Uint8Array(bytes)\r
},\r
/**\r
- * Convert a binary string to a hexadecimal representation\r
+ * Convert a binary string to a hexadecimal string.\r
*\r
* @param {string} bin - String to convert\r
- * @returns {string} Hexadecimal representation of the input string\r
+ * @returns {string} Hexadecimal string representation of the input binary\r
*/\r
toHex (bin: string): string {\r
return parseInt(bin, 2).toString(16)\r
toDec (bytes: Uint8Array): bigint | number {\r
const integers: bigint[] = []\r
bytes.reverse().forEach(b => integers.push(BigInt(b)))\r
- const decimal = integers.reduce((sum, byte, index) => {\r
- return sum + (byte << BigInt(index * 8))\r
- })\r
+ let decimal = 0n\r
+ for (let i = 0; i < integers.length; i++) {\r
+ decimal += integers[i] << BigInt(i * 8)\r
+ }\r
if (decimal > 9007199254740991n) {\r
return decimal\r
} else {\r
throw new TypeError('Invalid padding')\r
}\r
let integer = BigInt(decimal)\r
- const bytes = []\r
+ const bytes: number[] = []\r
while (integer > 0) {\r
const lsb = BigInt.asUintN(8, integer)\r
bytes.push(Number(lsb))\r
+++ /dev/null
-// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-import blake2b from 'blake2b'
-
-/**
-* Derived from:
-* - mipher
-* - tweetnacl
-* - ed2curve-js
-*
-* With added types etc
-*/
-export default class Curve25519 {
- gf0: Int32Array
- gf1: Int32Array
- D: Int32Array
- D2: Int32Array
- I: Int32Array
- _9: Uint8Array
- _121665: Int32Array
- _0: Uint8Array
- sigma: Uint8Array
- minusp: Uint32Array
-
- constructor () {
- this.gf0 = this.gf()
- this.gf1 = this.gf([1])
- this._9 = new Uint8Array(32)
- this._9[0] = 9
- this._121665 = this.gf([0xdb41, 1])
- this.D = this.gf([0x78a3, 0x1359, 0x4dca, 0x75eb, 0xd8ab, 0x4141, 0x0a4d, 0x0070, 0xe898, 0x7779, 0x4079, 0x8cc7, 0xfe73, 0x2b6f, 0x6cee, 0x5203])
- this.D2 = this.gf([0xf159, 0x26b2, 0x9b94, 0xebd6, 0xb156, 0x8283, 0x149a, 0x00e0, 0xd130, 0xeef3, 0x80f2, 0x198e, 0xfce7, 0x56df, 0xd9dc, 0x2406])
- this.I = this.gf([0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, 0x2f43, 0xd7a7, 0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1, 0x2480, 0x2b83])
- this._0 = new Uint8Array(16)
- this.sigma = new Uint8Array([101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107])
- this.minusp = new Uint32Array([5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 252])
- }
-
- gf (init?: number[]): Int32Array {
- const r = new Int32Array(16)
- if (init) {
- for (let i = 0; i < init.length; i++) {
- r[i] = init[i]
- }
- }
-
- return r
- }
-
- A (o: Int32Array, a: Int32Array, b: Int32Array): void {
- for (let i = 0; i < 16; i++) {
- o[i] = a[i] + b[i]
- }
- }
-
- Z (o: Int32Array, a: Int32Array, b: Int32Array): void {
- for (let i = 0; i < 16; i++) {
- o[i] = a[i] - b[i]
- }
- }
-
- // Avoid loops for better performance
- M (o: Int32Array, a: Int32Array, b: Int32Array): void {
- let v, c,
- t0 = 0, t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0, t7 = 0,
- t8 = 0, t9 = 0, t10 = 0, t11 = 0, t12 = 0, t13 = 0, t14 = 0, t15 = 0,
- t16 = 0, t17 = 0, t18 = 0, t19 = 0, t20 = 0, t21 = 0, t22 = 0, t23 = 0,
- t24 = 0, t25 = 0, t26 = 0, t27 = 0, t28 = 0, t29 = 0, t30 = 0
- const b0 = b[0],
- b1 = b[1],
- b2 = b[2],
- b3 = b[3],
- b4 = b[4],
- b5 = b[5],
- b6 = b[6],
- b7 = b[7],
- b8 = b[8],
- b9 = b[9],
- b10 = b[10],
- b11 = b[11],
- b12 = b[12],
- b13 = b[13],
- b14 = b[14],
- b15 = b[15]
-
- v = a[0]
- t0 += v * b0
- t1 += v * b1
- t2 += v * b2
- t3 += v * b3
- t4 += v * b4
- t5 += v * b5
- t6 += v * b6
- t7 += v * b7
- t8 += v * b8
- t9 += v * b9
- t10 += v * b10
- t11 += v * b11
- t12 += v * b12
- t13 += v * b13
- t14 += v * b14
- t15 += v * b15
- v = a[1]
- t1 += v * b0
- t2 += v * b1
- t3 += v * b2
- t4 += v * b3
- t5 += v * b4
- t6 += v * b5
- t7 += v * b6
- t8 += v * b7
- t9 += v * b8
- t10 += v * b9
- t11 += v * b10
- t12 += v * b11
- t13 += v * b12
- t14 += v * b13
- t15 += v * b14
- t16 += v * b15
- v = a[2]
- t2 += v * b0
- t3 += v * b1
- t4 += v * b2
- t5 += v * b3
- t6 += v * b4
- t7 += v * b5
- t8 += v * b6
- t9 += v * b7
- t10 += v * b8
- t11 += v * b9
- t12 += v * b10
- t13 += v * b11
- t14 += v * b12
- t15 += v * b13
- t16 += v * b14
- t17 += v * b15
- v = a[3]
- t3 += v * b0
- t4 += v * b1
- t5 += v * b2
- t6 += v * b3
- t7 += v * b4
- t8 += v * b5
- t9 += v * b6
- t10 += v * b7
- t11 += v * b8
- t12 += v * b9
- t13 += v * b10
- t14 += v * b11
- t15 += v * b12
- t16 += v * b13
- t17 += v * b14
- t18 += v * b15
- v = a[4]
- t4 += v * b0
- t5 += v * b1
- t6 += v * b2
- t7 += v * b3
- t8 += v * b4
- t9 += v * b5
- t10 += v * b6
- t11 += v * b7
- t12 += v * b8
- t13 += v * b9
- t14 += v * b10
- t15 += v * b11
- t16 += v * b12
- t17 += v * b13
- t18 += v * b14
- t19 += v * b15
- v = a[5]
- t5 += v * b0
- t6 += v * b1
- t7 += v * b2
- t8 += v * b3
- t9 += v * b4
- t10 += v * b5
- t11 += v * b6
- t12 += v * b7
- t13 += v * b8
- t14 += v * b9
- t15 += v * b10
- t16 += v * b11
- t17 += v * b12
- t18 += v * b13
- t19 += v * b14
- t20 += v * b15
- v = a[6]
- t6 += v * b0
- t7 += v * b1
- t8 += v * b2
- t9 += v * b3
- t10 += v * b4
- t11 += v * b5
- t12 += v * b6
- t13 += v * b7
- t14 += v * b8
- t15 += v * b9
- t16 += v * b10
- t17 += v * b11
- t18 += v * b12
- t19 += v * b13
- t20 += v * b14
- t21 += v * b15
- v = a[7]
- t7 += v * b0
- t8 += v * b1
- t9 += v * b2
- t10 += v * b3
- t11 += v * b4
- t12 += v * b5
- t13 += v * b6
- t14 += v * b7
- t15 += v * b8
- t16 += v * b9
- t17 += v * b10
- t18 += v * b11
- t19 += v * b12
- t20 += v * b13
- t21 += v * b14
- t22 += v * b15
- v = a[8]
- t8 += v * b0
- t9 += v * b1
- t10 += v * b2
- t11 += v * b3
- t12 += v * b4
- t13 += v * b5
- t14 += v * b6
- t15 += v * b7
- t16 += v * b8
- t17 += v * b9
- t18 += v * b10
- t19 += v * b11
- t20 += v * b12
- t21 += v * b13
- t22 += v * b14
- t23 += v * b15
- v = a[9]
- t9 += v * b0
- t10 += v * b1
- t11 += v * b2
- t12 += v * b3
- t13 += v * b4
- t14 += v * b5
- t15 += v * b6
- t16 += v * b7
- t17 += v * b8
- t18 += v * b9
- t19 += v * b10
- t20 += v * b11
- t21 += v * b12
- t22 += v * b13
- t23 += v * b14
- t24 += v * b15
- v = a[10]
- t10 += v * b0
- t11 += v * b1
- t12 += v * b2
- t13 += v * b3
- t14 += v * b4
- t15 += v * b5
- t16 += v * b6
- t17 += v * b7
- t18 += v * b8
- t19 += v * b9
- t20 += v * b10
- t21 += v * b11
- t22 += v * b12
- t23 += v * b13
- t24 += v * b14
- t25 += v * b15
- v = a[11]
- t11 += v * b0
- t12 += v * b1
- t13 += v * b2
- t14 += v * b3
- t15 += v * b4
- t16 += v * b5
- t17 += v * b6
- t18 += v * b7
- t19 += v * b8
- t20 += v * b9
- t21 += v * b10
- t22 += v * b11
- t23 += v * b12
- t24 += v * b13
- t25 += v * b14
- t26 += v * b15
- v = a[12]
- t12 += v * b0
- t13 += v * b1
- t14 += v * b2
- t15 += v * b3
- t16 += v * b4
- t17 += v * b5
- t18 += v * b6
- t19 += v * b7
- t20 += v * b8
- t21 += v * b9
- t22 += v * b10
- t23 += v * b11
- t24 += v * b12
- t25 += v * b13
- t26 += v * b14
- t27 += v * b15
- v = a[13]
- t13 += v * b0
- t14 += v * b1
- t15 += v * b2
- t16 += v * b3
- t17 += v * b4
- t18 += v * b5
- t19 += v * b6
- t20 += v * b7
- t21 += v * b8
- t22 += v * b9
- t23 += v * b10
- t24 += v * b11
- t25 += v * b12
- t26 += v * b13
- t27 += v * b14
- t28 += v * b15
- v = a[14]
- t14 += v * b0
- t15 += v * b1
- t16 += v * b2
- t17 += v * b3
- t18 += v * b4
- t19 += v * b5
- t20 += v * b6
- t21 += v * b7
- t22 += v * b8
- t23 += v * b9
- t24 += v * b10
- t25 += v * b11
- t26 += v * b12
- t27 += v * b13
- t28 += v * b14
- t29 += v * b15
- v = a[15]
- t15 += v * b0
- t16 += v * b1
- t17 += v * b2
- t18 += v * b3
- t19 += v * b4
- t20 += v * b5
- t21 += v * b6
- t22 += v * b7
- t23 += v * b8
- t24 += v * b9
- t25 += v * b10
- t26 += v * b11
- t27 += v * b12
- t28 += v * b13
- t29 += v * b14
- t30 += v * b15
-
- t0 += 38 * t16
- t1 += 38 * t17
- t2 += 38 * t18
- t3 += 38 * t19
- t4 += 38 * t20
- t5 += 38 * t21
- t6 += 38 * t22
- t7 += 38 * t23
- t8 += 38 * t24
- t9 += 38 * t25
- t10 += 38 * t26
- t11 += 38 * t27
- t12 += 38 * t28
- t13 += 38 * t29
- t14 += 38 * t30
-
- c = 1
- v = t0 + c + 65535; c = Math.floor(v / 65536); t0 = v - c * 65536
- v = t1 + c + 65535; c = Math.floor(v / 65536); t1 = v - c * 65536
- v = t2 + c + 65535; c = Math.floor(v / 65536); t2 = v - c * 65536
- v = t3 + c + 65535; c = Math.floor(v / 65536); t3 = v - c * 65536
- v = t4 + c + 65535; c = Math.floor(v / 65536); t4 = v - c * 65536
- v = t5 + c + 65535; c = Math.floor(v / 65536); t5 = v - c * 65536
- v = t6 + c + 65535; c = Math.floor(v / 65536); t6 = v - c * 65536
- v = t7 + c + 65535; c = Math.floor(v / 65536); t7 = v - c * 65536
- v = t8 + c + 65535; c = Math.floor(v / 65536); t8 = v - c * 65536
- v = t9 + c + 65535; c = Math.floor(v / 65536); t9 = v - c * 65536
- v = t10 + c + 65535; c = Math.floor(v / 65536); t10 = v - c * 65536
- v = t11 + c + 65535; c = Math.floor(v / 65536); t11 = v - c * 65536
- v = t12 + c + 65535; c = Math.floor(v / 65536); t12 = v - c * 65536
- v = t13 + c + 65535; c = Math.floor(v / 65536); t13 = v - c * 65536
- v = t14 + c + 65535; c = Math.floor(v / 65536); t14 = v - c * 65536
- v = t15 + c + 65535; c = Math.floor(v / 65536); t15 = v - c * 65536
- t0 += c - 1 + 37 * (c - 1)
-
- c = 1
- v = t0 + c + 65535; c = Math.floor(v / 65536); t0 = v - c * 65536
- v = t1 + c + 65535; c = Math.floor(v / 65536); t1 = v - c * 65536
- v = t2 + c + 65535; c = Math.floor(v / 65536); t2 = v - c * 65536
- v = t3 + c + 65535; c = Math.floor(v / 65536); t3 = v - c * 65536
- v = t4 + c + 65535; c = Math.floor(v / 65536); t4 = v - c * 65536
- v = t5 + c + 65535; c = Math.floor(v / 65536); t5 = v - c * 65536
- v = t6 + c + 65535; c = Math.floor(v / 65536); t6 = v - c * 65536
- v = t7 + c + 65535; c = Math.floor(v / 65536); t7 = v - c * 65536
- v = t8 + c + 65535; c = Math.floor(v / 65536); t8 = v - c * 65536
- v = t9 + c + 65535; c = Math.floor(v / 65536); t9 = v - c * 65536
- v = t10 + c + 65535; c = Math.floor(v / 65536); t10 = v - c * 65536
- v = t11 + c + 65535; c = Math.floor(v / 65536); t11 = v - c * 65536
- v = t12 + c + 65535; c = Math.floor(v / 65536); t12 = v - c * 65536
- v = t13 + c + 65535; c = Math.floor(v / 65536); t13 = v - c * 65536
- v = t14 + c + 65535; c = Math.floor(v / 65536); t14 = v - c * 65536
- v = t15 + c + 65535; c = Math.floor(v / 65536); t15 = v - c * 65536
- t0 += c - 1 + 37 * (c - 1)
-
- o[0] = t0
- o[1] = t1
- o[2] = t2
- o[3] = t3
- o[4] = t4
- o[5] = t5
- o[6] = t6
- o[7] = t7
- o[8] = t8
- o[9] = t9
- o[10] = t10
- o[11] = t11
- o[12] = t12
- o[13] = t13
- o[14] = t14
- o[15] = t15
- }
-
- S (o: Int32Array, a: Int32Array): void {
- this.M(o, a, a)
- }
-
- add (p: Int32Array[], q: Int32Array[]): void {
- const a = this.gf(), b = this.gf(), c = this.gf(),
- d = this.gf(), e = this.gf(), f = this.gf(),
- g = this.gf(), h = this.gf(), t = this.gf()
-
- this.Z(a, p[1], p[0])
- this.Z(t, q[1], q[0])
- this.M(a, a, t)
- this.A(b, p[0], p[1])
- this.A(t, q[0], q[1])
- this.M(b, b, t)
- this.M(c, p[3], q[3])
- this.M(c, c, this.D2)
- this.M(d, p[2], q[2])
- this.A(d, d, d)
- this.Z(e, b, a)
- this.Z(f, d, c)
- this.A(g, d, c)
- this.A(h, b, a)
- this.M(p[0], e, f)
- this.M(p[1], h, g)
- this.M(p[2], g, f)
- this.M(p[3], e, h)
- }
-
- set25519 (r: Int32Array, a: Int32Array): void {
- for (let i = 0; i < 16; i++) {
- r[i] = a[i]
- }
- }
-
- car25519 (o: Int32Array): void {
- let i, v, c = 1
- for (i = 0; i < 16; i++) {
- v = o[i] + c + 65535
- c = Math.floor(v / 65536)
- o[i] = v - c * 65536
- }
-
- o[0] += c - 1 + 37 * (c - 1)
- }
-
- // b is 0 or 1
- sel25519 (p: Int32Array, q: Int32Array, b: number): void {
- let i, t
- const c = ~(b - 1)
- for (i = 0; i < 16; i++) {
- t = c & (p[i] ^ q[i])
- p[i] ^= t
- q[i] ^= t
- }
- }
-
- inv25519 (o: Int32Array, i: Int32Array): void {
- let a
- const c = this.gf()
- for (a = 0; a < 16; a++) {
- c[a] = i[a]
- }
-
- for (a = 253; a >= 0; a--) {
- this.S(c, c)
- if (a !== 2 && a !== 4) {
- this.M(c, c, i)
- }
- }
-
- for (a = 0; a < 16; a++) {
- o[a] = c[a]
- }
- }
-
- neq25519 (a: Int32Array, b: Int32Array): boolean {
- const c = new Uint8Array(32), d = new Uint8Array(32)
- this.pack25519(c, a)
- this.pack25519(d, b)
- if (c.length !== d.length) return true
- for (let i = 0; i < c.length; i++) {
- if (c[i] !== d[i]) return true
- }
- return false
- }
-
- par25519 (a: Int32Array): number {
- const d = new Uint8Array(32)
- this.pack25519(d, a)
- return d[0] & 1
- }
-
- pow2523 (o: Int32Array, i: Int32Array): void {
- let a
- const c = this.gf()
- for (a = 0; a < 16; a++) {
- c[a] = i[a]
- }
-
- for (a = 250; a >= 0; a--) {
- this.S(c, c)
- if (a !== 1) this.M(c, c, i)
- }
-
- for (a = 0; a < 16; a++) {
- o[a] = c[a]
- }
- }
-
- cswap (p: Int32Array[], q: Int32Array[], b: number): void {
- for (let i = 0; i < 4; i++) {
- this.sel25519(p[i], q[i], b)
- }
- }
-
- pack25519 (o: Uint8Array, n: Int32Array): void {
- let i
- const m = this.gf()
- const t = this.gf()
- for (i = 0; i < 16; i++) {
- t[i] = n[i]
- }
-
- this.car25519(t)
- this.car25519(t)
- this.car25519(t)
- for (let j = 0; j < 2; j++) {
- m[0] = t[0] - 0xffed
- for (i = 1; i < 15; i++) {
- m[i] = t[i] - 0xffff - ((m[i - 1] >>> 16) & 1)
- m[i - 1] &= 0xffff
- }
-
- m[15] = t[15] - 0x7fff - ((m[14] >>> 16) & 1)
- const b = (m[15] >>> 16) & 1
- m[14] &= 0xffff
- this.sel25519(t, m, 1 - b)
- }
-
- for (i = 0; i < 16; i++) {
- o[2 * i] = t[i] & 0xff
- o[2 * i + 1] = t[i] >>> 8
- }
- }
-
- unpack25519 (o: Int32Array, n: Uint8Array): void {
- for (let i = 0; i < 16; i++) {
- o[i] = n[2 * i] + (n[2 * i + 1] << 8)
- }
-
- o[15] &= 0x7fff
- }
-
- unpackNeg (r: Int32Array[], p: Uint8Array): number {
- const t = this.gf(),
- chk = this.gf(),
- num = this.gf(),
- den = this.gf(),
- den2 = this.gf(),
- den4 = this.gf(),
- den6 = this.gf()
-
- this.set25519(r[2], this.gf1)
- this.unpack25519(r[1], p)
- this.S(num, r[1])
- this.M(den, num, this.D)
- this.Z(num, num, r[2])
- this.A(den, r[2], den)
-
- this.S(den2, den)
- this.S(den4, den2)
- this.M(den6, den4, den2)
- this.M(t, den6, num)
- this.M(t, t, den)
-
- this.pow2523(t, t)
- this.M(t, t, num)
- this.M(t, t, den)
- this.M(t, t, den)
- this.M(r[0], t, den)
-
- this.S(chk, r[0])
- this.M(chk, chk, den)
- if (this.neq25519(chk, num)) {
- this.M(r[0], r[0], this.I)
- }
-
- this.S(chk, r[0])
- this.M(chk, chk, den)
- if (this.neq25519(chk, num)) {
- return -1
- }
-
- if (this.par25519(r[0]) === (p[31] >>> 7)) {
- this.Z(r[0], this.gf0, r[0])
- }
-
- this.M(r[3], r[0], r[1])
-
- return 0
- }
-
- /**
- * Converts a ed25519 public key to Curve25519 to be used in
- * Diffie-Hellman key exchange
- */
- convertEd25519PublicKeyToCurve25519 (pk: Uint8Array) {
- const z = new Uint8Array(32)
- const q = [this.gf(), this.gf(), this.gf(), this.gf()]
- const a = this.gf()
- const b = this.gf()
-
- if (this.unpackNeg(q, pk)) {
- return null
- }
-
- const y = q[1]
-
- this.A(a, this.gf1, y)
- this.Z(b, this.gf1, y)
- this.inv25519(b, b)
- this.M(a, a, b)
-
- this.pack25519(z, a)
-
- return z
- }
-
- /**
- * Converts a ed25519 private key to Curve25519 to be used in
- * Diffie-Hellman key exchange
- */
- convertEd25519PrivateKeyToCurve25519 (sk: Uint8Array) {
- const d = new Uint8Array(64)
- const o = new Uint8Array(32)
- let i
-
- this.cryptoHash(d, sk, 32)
- d[0] &= 248
- d[31] &= 127
- d[31] |= 64
-
- for (i = 0; i < 32; i++) {
- o[i] = d[i]
- }
- for (i = 0; i < 64; i++) {
- d[i] = 0
- }
- return o
- }
-
- cryptoHash (out: Uint8Array, m: Uint8Array, n: number): number {
- const input = new Uint8Array(n)
- for (let i = 0; i < n; ++i) {
- input[i] = m[i]
- }
- const hash = blake2b(64).update(input).digest()
- for (let i = 0; i < 64; ++i) {
- out[i] = hash[i]
- }
- return 0
- }
-}
+++ /dev/null
-// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>\r
-// SPDX-License-Identifier: GPL-3.0-or-later\r
-\r
-import blake2b from 'blake2b'\r
-import { bytes, hex } from './convert.js'\r
-import Curve25519 from './curve25519.js'\r
-\r
-type KeyPair = {\r
- privateKey: string\r
- publicKey: string\r
-}\r
-\r
-const curve = new Curve25519()\r
-const X: Int32Array = curve.gf([0xd51a, 0x8f25, 0x2d60, 0xc956, 0xa7b2, 0x9525, 0xc760, 0x692c, 0xdc5c, 0xfdd6, 0xe231, 0xc0a4, 0x53fe, 0xcd6e, 0x36d3, 0x2169])\r
-const Y: Int32Array = curve.gf([0x6658, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666])\r
-const L: Uint8Array = new Uint8Array([0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x10])\r
-\r
-/**\r
-* Generate a public key from a private key using the Ed25519 algorithm. The key\r
-* should be a cryptographically strong random value.\r
-*\r
-* @param {string} privateKey - 32-byte hexadecimal private key\r
-* @returns {string} 32-byte hexadecimal public key\r
-*/\r
-function getPublicKey (privateKey: string): string {\r
- const pk = new Uint8Array(32)\r
- const p = [curve.gf(), curve.gf(), curve.gf(), curve.gf()]\r
- const h = blake2b(64).update(hex.toBytes(privateKey)).digest().slice(0, 32)\r
-\r
- h[0] &= 0xf8\r
- h[31] &= 0x7f\r
- h[31] |= 0x40\r
-\r
- scalarbase(p, h)\r
- pack(pk, p)\r
-\r
- return bytes.toHex(pk)\r
-}\r
-\r
-/**\r
-* Convert Ed25519 keypair to Curve25519 keypair suitable for Diffie-Hellman key exchange\r
-*\r
-* @param {KeyPair} keyPair - Ed25519 keypair\r
-* @returns {KeyPair} Curve25519 keypair\r
-*/\r
-function convertKeys (keyPair: KeyPair): KeyPair {\r
- const pubKeyBuf = hex.toBytes(keyPair.publicKey)\r
- const ab: (Uint8Array | null) = curve.convertEd25519PublicKeyToCurve25519(pubKeyBuf)\r
- if (ab == null) {\r
- throw new Error('Invalid key pair')\r
- }\r
- const publicKey = bytes.toHex(ab) ?? ''\r
- if (publicKey === '') {\r
- throw new Error('Invalid key pair')\r
- }\r
- const privKeyBuf = hex.toBytes(keyPair.privateKey)\r
- const privateKey = bytes.toHex(curve.convertEd25519PrivateKeyToCurve25519(privKeyBuf))\r
- return {\r
- publicKey,\r
- privateKey,\r
- }\r
-}\r
-\r
-/**\r
-* Generate a message signature\r
-* @param {Uint8Array} msg - Message to be signed\r
-* @param {Uint8Array} privateKey - Private key to use for signing\r
-* @returns {Uint8Array} 64-byte signature\r
-*/\r
-function sign (msg: Uint8Array, privateKey: Uint8Array): Uint8Array {\r
- return naclSign(msg, privateKey).slice(0, 64)\r
-}\r
-\r
-/**\r
-* Verify a message signature\r
-* @param {Uint8Array} msg - Message to be signed as byte array\r
-* @param {Uint8Array} publicKey - Public key as byte array\r
-* @param {Uint8Array} signature - Signature as byte array\r
-* @returns {boolean} True if `msg` was signed by `publicKey`, else false\r
-*/\r
-function verify (msg: Uint8Array, publicKey: Uint8Array, signature: Uint8Array): boolean {\r
- const CURVE = curve\r
- const p = [CURVE.gf(), CURVE.gf(), CURVE.gf(), CURVE.gf()]\r
- const q = [CURVE.gf(), CURVE.gf(), CURVE.gf(), CURVE.gf()]\r
-\r
- if (signature.length !== 64) {\r
- return false\r
- }\r
- if (publicKey.length !== 32) {\r
- return false\r
- }\r
- if (CURVE.unpackNeg(q, publicKey)) {\r
- return false\r
- }\r
-\r
- const k = blake2b(64)\r
- .update(signature.subarray(0, 32))\r
- .update(publicKey)\r
- .update(msg)\r
- .digest()\r
- reduce(k)\r
- scalarmult(p, q, k)\r
-\r
- let t = new Uint8Array(32)\r
- scalarbase(q, signature.subarray(32))\r
- CURVE.add(p, q)\r
- pack(t, p)\r
-\r
- if (signature.subarray(0, 32).length !== t.length) return false\r
- for (let i = 0; i < t.length; i++) {\r
- if (signature.subarray(0, 32)[i] !== t[i]) return false\r
- }\r
- return true\r
-}\r
-\r
-function pack (r: Uint8Array, p: Int32Array[]): void {\r
- const CURVE = curve\r
- const tx = CURVE.gf(),\r
- ty = CURVE.gf(),\r
- zi = CURVE.gf()\r
- CURVE.inv25519(zi, p[2])\r
- CURVE.M(tx, p[0], zi)\r
- CURVE.M(ty, p[1], zi)\r
- CURVE.pack25519(r, ty)\r
- r[31] ^= CURVE.par25519(tx) << 7\r
-}\r
-\r
-function modL (r: Uint8Array, x: Uint32Array | Float64Array): void {\r
- let carry, i, j, k\r
- for (i = 63; i >= 32; --i) {\r
- carry = 0\r
- for (j = i - 32, k = i - 12; j < k; ++j) {\r
- x[j] += carry - 16 * x[i] * L[j - (i - 32)]\r
- carry = (x[j] + 128) >> 8\r
- x[j] -= carry * 256\r
- }\r
- x[j] += carry\r
- x[i] = 0\r
- }\r
-\r
- carry = 0\r
- for (j = 0; j < 32; j++) {\r
- x[j] += carry - (x[31] >> 4) * L[j]\r
- carry = x[j] >> 8\r
- x[j] &= 255\r
- }\r
- for (j = 0; j < 32; j++) {\r
- x[j] -= carry * L[j]\r
- }\r
- for (i = 0; i < 32; i++) {\r
- x[i + 1] += x[i] >>> 8\r
- r[i] = x[i] & 0xff\r
- }\r
-}\r
-\r
-function reduce (r: Uint8Array): void {\r
- const x = new Uint32Array(64)\r
- for (let i = 0; i < 64; i++) {\r
- x[i] = r[i]\r
- }\r
- modL(r, x)\r
-}\r
-\r
-function scalarmult (p: Int32Array[], q: Int32Array[], s: Uint8Array): void {\r
- const CURVE = curve\r
- CURVE.set25519(p[0], CURVE.gf0)\r
- CURVE.set25519(p[1], CURVE.gf1)\r
- CURVE.set25519(p[2], CURVE.gf1)\r
- CURVE.set25519(p[3], CURVE.gf0)\r
- for (let i = 255; i >= 0; --i) {\r
- const b = (s[(i / 8) | 0] >>> (i & 7)) & 1\r
- CURVE.cswap(p, q, b)\r
- CURVE.add(q, p)\r
- CURVE.add(p, p)\r
- CURVE.cswap(p, q, b)\r
- }\r
-}\r
-\r
-function scalarbase (p: Int32Array[], s: Uint8Array): void {\r
- const CURVE = curve\r
- const q = [CURVE.gf(), CURVE.gf(), CURVE.gf(), CURVE.gf()]\r
- CURVE.set25519(q[0], X)\r
- CURVE.set25519(q[1], Y)\r
- CURVE.set25519(q[2], CURVE.gf1)\r
- CURVE.M(q[3], X, Y)\r
- scalarmult(p, q, s)\r
-}\r
-\r
-function naclSign (msg: Uint8Array, privateKey: Uint8Array): Uint8Array {\r
- if (privateKey.length !== 32) {\r
- throw new Error('bad private key size')\r
- }\r
- const signedMsg = new Uint8Array(64 + msg.length)\r
- cryptoSign(signedMsg, msg, msg.length, privateKey)\r
- return signedMsg\r
-}\r
-\r
-function cryptoSign (sm: Uint8Array, m: Uint8Array, n: number, sk: Uint8Array): number {\r
- const CURVE = curve\r
- const d = new Uint8Array(64)\r
- const h = new Uint8Array(64)\r
- const r = new Uint8Array(64)\r
- const x = new Float64Array(64)\r
- const p = [CURVE.gf(), CURVE.gf(), CURVE.gf(), CURVE.gf()]\r
-\r
- let i\r
- let j\r
-\r
- const pubKey = getPublicKey(bytes.toHex(sk))\r
- const pk = hex.toBytes(pubKey)\r
-\r
- curve.cryptoHash(d, sk, 32)\r
- d[0] &= 248\r
- d[31] &= 127\r
- d[31] |= 64\r
-\r
- const smlen = n + 64\r
- for (i = 0; i < n; i++) {\r
- sm[64 + i] = m[i]\r
- }\r
- for (i = 0; i < 32; i++) {\r
- sm[32 + i] = d[32 + i]\r
- }\r
-\r
- curve.cryptoHash(r, sm.subarray(32), n + 32)\r
- reduce(r)\r
- scalarbase(p, r)\r
- pack(sm, p)\r
-\r
- for (i = 32; i < 64; i++) {\r
- sm[i] = pk[i - 32]\r
- }\r
-\r
- curve.cryptoHash(h, sm, n + 64)\r
- reduce(h)\r
-\r
- for (i = 0; i < 64; i++) {\r
- x[i] = 0\r
- }\r
- for (i = 0; i < 32; i++) {\r
- x[i] = r[i]\r
- }\r
- for (i = 0; i < 32; i++) {\r
- for (j = 0; j < 32; j++) {\r
- x[i + j] += h[i] * d[j]\r
- }\r
- }\r
-\r
- modL(sm.subarray(32), x)\r
-\r
- return smlen\r
-}\r
-\r
-export default { convertKeys, getPublicKey, sign, verify }\r
* brand new source of entropy will be generated at the maximum size of 256 bits.
*/
export class Entropy {
- #bits: string
- #buffer: ArrayBuffer
+ static #isInternal: boolean = false
#bytes: Uint8Array
- #hex: string
- get bits () { return this.#bits }
- get buffer () { return this.#buffer }
- get bytes () { return this.#bytes }
- get hex () { return this.#hex }
+ get bits (): string { return bytes.toBin(this.#bytes) }
+ get buffer (): ArrayBuffer { return this.#bytes.buffer }
+ get bytes (): Uint8Array { return this.#bytes }
+ get hex (): string { return bytes.toHex(this.#bytes) }
+
+ constructor (bytes: Uint8Array) {
+ if (!Entropy.#isInternal) {
+ throw new Error(`Entropy cannot be instantiated directly. Use 'await Entropy.create()' instead.`)
+ }
+ Entropy.#isInternal = false
+ this.#bytes = bytes
+ }
/**
* Generate 256 bits of entropy.
*/
- constructor ()
+ static async create (): Promise<Entropy>
/**
* Generate between 16-32 bytes of entropy.
- * @param {number} size - Number of bytes to generate
+ * @param {number} size - Number of bytes to generate in multiples of 4
*/
- constructor (size: number)
+ static async create (size: number): Promise<Entropy>
+ static async create (size?: number): Promise<Entropy> {
+ return new Promise(resolve => {
+ if (size != null) {
+ if (typeof size !== 'number') {
+ throw new TypeError(`Entropy cannot use ${typeof size} as a size`)
+ }
+ if (size < MIN || size > MAX) {
+ throw new RangeError(`Entropy must be ${MIN}-${MAX} bytes`)
+ }
+ if (size % MOD !== 0) {
+ throw new RangeError(`Entropy must be a multiple of ${MOD} bytes`)
+ }
+ }
+ Entropy.#isInternal = true
+ resolve(new this(crypto.getRandomValues(new Uint8Array(size ?? MAX))))
+ })
+ }
+
/**
* Import existing entropy and validate it.
* @param {string} hex - Hexadecimal string
*/
- constructor (hex: string)
+ static async import (hex: string): Promise<Entropy>
/**
* Import existing entropy and validate it.
* @param {ArrayBuffer} buffer - Byte buffer
*/
- constructor (buffer: ArrayBuffer)
+ static async import (buffer: ArrayBuffer): Promise<Entropy>
/**
* Import existing entropy and validate it.
* @param {Uint8Array} bytes - Byte array
*/
- constructor (bytes: Uint8Array)
- constructor (input?: number | string | ArrayBuffer | Uint8Array) {
- if (typeof input === 'number' && input > 0) {
- if (input < MIN || input > MAX) {
- throw new RangeError(`Entropy must be ${MIN}-${MAX} bytes`)
- }
- if (input % MOD !== 0) {
- throw new RangeError(`Entropy must be a multiple of ${MOD} bytes`)
+ static async import (bytes: Uint8Array): Promise<Entropy>
+ static async import (input: string | ArrayBuffer | Uint8Array): Promise<Entropy> {
+ return new Promise((resolve, reject) => {
+ if (typeof input === 'string') {
+ if (input.length < MIN * 2 || input.length > MAX * 2) {
+ throw new RangeError(`Entropy must be ${MIN * 2}-${MAX * 2} characters`)
+ }
+ if (input.length % MOD * 2 !== 0) {
+ throw new RangeError(`Entropy must be a multiple of ${MOD * 2} characters`)
+ }
+ if (!/^[0-9a-fA-F]+$/i.test(input)) {
+ throw new RangeError('Entropy contains invalid hexadecimal characters')
+ }
+ Entropy.#isInternal = true
+ resolve(new this(hex.toBytes(input)))
}
- this.#bytes = crypto.getRandomValues(new Uint8Array(input))
- this.#hex = bytes.toHex(this.#bytes)
- this.#bits = hex.toBin(this.#hex)
- this.#buffer = this.#bytes.buffer
- return
- }
- if (typeof input === 'string' && input.length > 0) {
- if (input.length < MIN * 2 || input.length > MAX * 2) {
- throw new RangeError(`Entropy must be ${MIN * 2}-${MAX * 2} characters`)
- }
- if (input.length % MOD * 2 !== 0) {
- throw new RangeError(`Entropy must be a multiple of ${MOD * 2} characters`)
- }
- this.#hex = input
- if (!/^[0-9a-fA-F]+$/i.test(this.#hex)) {
- throw new RangeError('Entropy contains invalid hexadecimal characters')
+ if (input instanceof ArrayBuffer) {
+ if (input.byteLength < MIN || input.byteLength > MAX) {
+ throw new Error(`Entropy must be ${MIN}-${MAX} bytes`)
+ }
+ if (input.byteLength % MOD !== 0) {
+ throw new RangeError(`Entropy must be a multiple of ${MOD} bytes`)
+ }
+ Entropy.#isInternal = true
+ resolve(new this(new Uint8Array(input)))
}
- this.#bytes = hex.toBytes(this.#hex)
- this.#bits = hex.toBin(this.#hex)
- this.#buffer = this.#bytes.buffer
- return
- }
- if (input instanceof ArrayBuffer && input.byteLength > 0) {
- if (input.byteLength < MIN || input.byteLength > MAX) {
- throw new Error(`Entropy must be ${MIN}-${MAX} bytes`)
- }
- if (input.byteLength % MOD !== 0) {
- throw new RangeError(`Entropy must be a multiple of ${MOD} bytes`)
+ if (input instanceof Uint8Array) {
+ if (input.length < MIN || input.length > MAX) {
+ throw new Error(`Entropy must be ${MIN}-${MAX} bytes`)
+ }
+ if (input.length % MOD !== 0) {
+ throw new RangeError(`Entropy must be a multiple of ${MOD} bytes`)
+ }
+ Entropy.#isInternal = true
+ resolve(new this(input))
}
- this.#buffer = input
- this.#bytes = new Uint8Array(this.#buffer)
- this.#bits = bytes.toBin(this.#bytes)
- this.#hex = bytes.toHex(this.#bytes)
- return
- }
- if (input instanceof Uint8Array && input.length > 0) {
- if (input.length < MIN || input.length > MAX) {
- throw new Error(`Entropy must be ${MIN}-${MAX} bytes`)
- }
- if (input.length % MOD !== 0) {
- throw new RangeError(`Entropy must be a multiple of ${MOD} bytes`)
- }
- this.#bytes = input
- this.#bits = bytes.toBin(this.#bytes)
- this.#buffer = this.#bytes.buffer
- this.#hex = bytes.toHex(this.#bytes)
- return
- }
+ reject(new TypeError(`Entropy cannot import ${typeof input}`))
+ })
+ }
- this.#bytes = crypto.getRandomValues(new Uint8Array(MAX))
- this.#hex = bytes.toHex(this.#bytes)
- this.#bits = hex.toBin(this.#hex)
- this.#buffer = this.#bytes.buffer
+ /**
+ * Randomizes the bytes, rendering the original values generally inaccessible.
+ */
+ destroy (): boolean {
+ try {
+ crypto.getRandomValues(this.#bytes)
+ return true
+ } catch (err) {
+ return false
+ }
}
}
--- /dev/null
+// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+type Job = {
+ id: number
+ reject: (value: any) => void
+ resolve: (value: any) => void
+ data: any
+ results: any[]
+}
+
+type Thread = {
+ worker: Worker
+ job: Job | null
+}
+
+/**
+* Processes an array of tasks using Web Workers.
+*/
+export class Pool {
+ static #cores: number = Math.max(1, navigator.hardwareConcurrency - 1)
+ #queue: Job[] = []
+ #threads: Thread[] = []
+ #url: string
+
+ get threadsBusy (): number {
+ let n = 0
+ for (const thread of this.#threads) {
+ n += +(thread.job != null)
+ }
+ return n
+ }
+ get threadsIdle (): number {
+ let n = 0
+ for (const thread of this.#threads) {
+ n += +(thread.job == null)
+ }
+ return n
+ }
+
+ async assign (data: any): Promise<any> {
+ if (!(data instanceof ArrayBuffer || Array.isArray(data))) data = [data]
+ return new Promise((resolve, reject) => {
+ const job: Job = {
+ id: performance.now(),
+ results: [],
+ data,
+ resolve,
+ reject
+ }
+ if (this.#queue.length > 0) {
+ this.#queue.push(job)
+ } else {
+ for (const thread of this.#threads) this.#assign(thread, job)
+ }
+ })
+ }
+
+ /**
+ *
+ * @param {string} worker - Stringified worker class
+ * @param {number} [count=1] - Integer between 1 and CPU thread count shared among all Pools
+ */
+ constructor (worker: string, count: number = 1) {
+ count = Math.min(Pool.#cores, Math.max(1, Math.floor(Math.abs(count))))
+ this.#url = URL.createObjectURL(new Blob([worker], { type: 'text/javascript' }))
+ for (let i = 0; i < count; i++) {
+ const thread = {
+ worker: new Worker(this.#url, { type: 'module' }),
+ job: null
+ }
+ thread.worker.addEventListener('message', message => {
+ let result = JSON.parse(new TextDecoder().decode(message.data) || "[]")
+ if (!Array.isArray(result)) result = [result]
+ this.#report(thread, result)
+ })
+ this.#threads.push(thread)
+ Pool.#cores = Math.max(1, Pool.#cores - this.#threads.length)
+ }
+ }
+
+ #assign (thread: Thread, job: Job): void {
+ if (job.data instanceof ArrayBuffer) {
+ if (job.data.byteLength > 0) {
+ thread.job = job
+ thread.worker.postMessage({ buffer: job.data }, [job.data])
+ }
+ } else {
+ const chunk: number = 1 + (job.data.length / this.threadsIdle)
+ const next = job.data.slice(0, chunk)
+ job.data = job.data.slice(chunk)
+ if (job.data.length === 0) this.#queue.shift()
+ if (next?.length > 0) {
+ const buffer = new TextEncoder().encode(JSON.stringify(next)).buffer
+ thread.job = job
+ thread.worker.postMessage({ buffer }, [buffer])
+ }
+ }
+ }
+
+ #isJobDone (jobId: number): boolean {
+ for (const thread of this.#threads) {
+ if (thread.job?.id === jobId) return false
+ }
+ return true
+ }
+
+ #report (thread: Thread, results: any[]): void {
+ if (thread.job == null) {
+ throw new Error('Thread returned results but had nowhere to report it.')
+ }
+ const job = thread.job
+ if (this.#queue.length > 0) {
+ this.#assign(thread, this.#queue[0])
+ } else {
+ thread.job = null
+ }
+ if (results.length > 0) {
+ job.results.push(...results)
+ }
+ if (this.#isJobDone(job.id)) {
+ job.resolve(job.results)
+ }
+ }
+}
+
+/**
+* Provides basic worker event messaging to extending classes.
+*
+* In order to be properly bundled in a format that can be used to create an
+* inline Web Worker, the extending classes must export WorkerInterface and
+* themselves as a string:
+*```
+* export default `
+* const WorkerInterface = ${WorkerInterface}
+* const Pow = ${Pow}
+* `
+* ```
+* They must also initialize the event listener by calling their inherited
+* `listen()` function. Finally, they must override the implementation of the
+* `work()` function. See the documentation of those functions for details.
+*/
+export class WorkerInterface {
+ /**
+ * Processes data through a worker.
+ *
+ * Extending classes must override this template by implementing the same
+ * function signature and providing their own processing call in the try-catch
+ * block.
+ *
+ * @param {any[]} data - Array of data to process
+ * @returns Promise for that data after being processed
+ */
+ static async work (data: any[]): Promise<any[]> {
+ return new Promise(async (resolve, reject): Promise<void> => {
+ for (let d of data) {
+ try {
+ d = await d
+ } catch (err) {
+ reject(err)
+ }
+ }
+ resolve(data)
+ })
+ }
+
+ /**
+ * Encodes worker results as an ArrayBuffer so it can be transferred back to
+ * the main thread.
+ *
+ * @param {any[]} results - Array of processed data
+ */
+ static report (results: any[]): void {
+ const buffer = new TextEncoder().encode(JSON.stringify(results)).buffer
+ //@ts-expect-error
+ postMessage(buffer, [buffer])
+ }
+
+ /**
+ * Listens for messages from the main thread.
+ *
+ * Extending classes must call this in a static initialization block:
+ * ```
+ * static {
+ * Pow.listen()
+ * }
+ * ```
+ */
+ static listen (): void {
+ addEventListener('message', (message: any): void => {
+ const { name, buffer } = message.data
+ if (name === 'STOP') {
+ close()
+ const buffer = new ArrayBuffer(0)
+ //@ts-expect-error
+ postMessage(buffer, [buffer])
+ } else {
+ const data = JSON.parse(new TextDecoder().decode(buffer))
+ this.work(data).then(this.report)
+ }
+ })
+ }
+}
.replaceAll('<', '\\u003c')
.replaceAll('>', '\\u003d')
.replaceAll('\\', '\\u005c')
- const account = new Account(address)
+ const account = Account.fromAddress(address)
const nameResult = this.#entries.find(e => e.name === name)
const accountResult = this.#entries.find(e => e.account.address === address)
if (!accountResult) {
* @param {string} name - Alias to look up
* @param {string} signature - Signature to use for verification
* @param {...string} data - Signed data to verify
- * @returns {boolean} True if the signature was used to sign the data, else false
+ * @returns {Promise<boolean>} True if the signature was used to sign the data, else false
*/
async verify (name: string, signature: string, ...data: string[]): Promise<boolean> {
- const Tools = await import('./tools.js')
+ const { Tools } = await import('./tools.js')
const entries = this.#entries.filter(e => e.name === name)
for (const entry of entries) {
const key = entry.account.publicKey
*
* @param {string} action - Nano protocol RPC call to execute
* @param {object} [data] - JSON to send to the node as defined by the action
- * @returns JSON-formatted RPC results from the node
+ * @returns {Promise<any>} JSON-formatted RPC results from the node
*/
async call (action: string, data?: { [key: string]: any }): Promise<any> {
+ var process: any = process || null
this.#validate(action)
const headers: { [key: string]: string } = {}
headers['Content-Type'] = 'application/json'
- if (this.#n && process.env.LIBNEMO_RPC_API_KEY) {
+ if (this.#n && process?.env?.LIBNEMO_RPC_API_KEY) {
headers[this.#n] = process.env.LIBNEMO_RPC_API_KEY
}
throw new Error(ERR_MSG)
}
- const iv = new Entropy()
+ const iv = await Entropy.create()
if (typeof passkey === 'string') {
try {
passkey = await subtle.importKey('raw', utf8.toBytes(passkey), 'PBKDF2', false, ['deriveBits', 'deriveKey'])
}
const record = JSON.parse(item)
const encrypted = hex.toBytes(record.encrypted)
- const iv = new Entropy(record.iv)
+ const iv = await Entropy.import(record.iv)
try {
if (typeof passkey === 'string') {
// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>
// SPDX-License-Identifier: GPL-3.0-or-later
-import blake2b from 'blake2b'
import { Account } from './account.js'
+import { Blake2b } from './blake2b.js'
import { UNITS } from './constants.js'
-import { bytes, hex } from './convert.js'
-import Ed25519 from './ed25519.js'
+import { hex } from './convert.js'
import { Rpc } from './rpc.js'
import { Bip44Wallet, Blake2bWallet, LedgerWallet } from './wallet.js'
import { SendBlock } from './block.js'
+import { NanoNaCl } from './workers/nano-nacl.js'
+
+function hash (data: string | string[], encoding?: 'hex'): string {
+ if (!Array.isArray(data)) data = [data]
+ const hash = new Blake2b(32)
+ if (encoding === 'hex') {
+ data.forEach(str => hash.update(hex.toBytes(str)))
+ } else {
+ const enc = new TextEncoder()
+ data.forEach(str => hash.update(enc.encode(str)))
+ }
+ return hash.digest('hex').toUpperCase()
+}
/**
* Converts a decimal amount of nano from one unit divider to another.
return `${i}${f ? '.' : ''}${f}`
}
-/**
-* Converts one or more strings to hexadecimal and hashes them with BLAKE2b.
-*
-* @param {string|string[]} data - Input to hash
-* @returns {Promise<string>} 64-character hexadecimal hash of the input
-*/
-export async function hash (data: string | string[], encoding?: 'hex'): Promise<string> {
- if (!Array.isArray(data)) data = [data]
- const hash = blake2b(32)
- if (encoding === 'hex') {
- data.forEach(str => hash.update(hex.toBytes(str)))
- } else {
- const enc = new TextEncoder()
- data.forEach(str => hash.update(enc.encode(str)))
- }
- return hash.digest('hex').toUpperCase()
-}
-
/**
* Signs arbitrary strings with a private key using the Ed25519 signature scheme.
*
* @returns {Promise<string>} Hexadecimal-formatted signature
*/
export async function sign (key: string, ...input: string[]): Promise<string> {
- const data = await hash(input)
- const signature = Ed25519.sign(
+ const account = await Account.fromPrivateKey(key)
+ const data = hash(input)
+ const signature = NanoNaCl.detached(
hex.toBytes(data),
- hex.toBytes(key))
- return bytes.toHex(signature)
+ hex.toBytes(`${account.privateKey}`))
+ return signature
}
/**
* Collects the funds from a specified range of accounts in a wallet and sends
-* them all to a single recipient address.
+* them all to a single recipient address. Hardware wallets are unsupported.
*
* @param {Rpc|string|URL} rpc - RPC node information required to refresh accounts, calculate PoW, and process blocks
* @param {Blake2bWallet|Bip44Wallet|LedgerWallet} wallet - Wallet from which to sweep funds
if (rpc.constructor !== Rpc) {
throw new TypeError('RPC must be a valid node')
}
- const blockQueue = []
+ const blockQueue: Promise<void>[] = []
const results: { status: 'success' | 'error', address: string, message: string }[] = []
- const recipientAccount = new Account(recipient)
+ const recipientAccount = Account.fromAddress(recipient)
const accounts = await wallet.refresh(rpc, from, to)
for (const account of accounts) {
if (account.representative?.address && account.frontier) {
account.representative.address,
account.frontier
)
- const blockRequest = new Promise(async (resolve) => {
+ const blockRequest: Promise<void> = new Promise(async (resolve) => {
try {
- await block.pow(rpc)
- await block.sign(account.index)
+ await block.pow()
+ await block.sign()
const hash = await block.process(rpc)
results.push({ status: 'success', address: block.account.address, message: hash })
} catch (err: any) {
results.push({ status: 'error', address: block.account.address, message: err.message })
} finally {
- resolve(null)
+ resolve()
}
})
blockQueue.push(blockRequest)
* @param {string} key - Hexadecimal-formatted public key to use for verification
* @param {string} signature - Hexadcimal-formatted signature
* @param {...string} input - Data to be verified
-* @returns {boolean} True if the data was signed by the public key's matching private key
+* @returns {Promise<boolean>} True if the data was signed by the public key's matching private key
*/
export async function verify (key: string, signature: string, ...input: string[]): Promise<boolean> {
- const data = await hash(input)
- return Ed25519.verify(
- hex.toBytes(data),
- hex.toBytes(key),
- hex.toBytes(signature))
+ const data = hash(input)
+ try {
+ return await NanoNaCl.verify(
+ hex.toBytes(data),
+ hex.toBytes(signature),
+ hex.toBytes(key))
+ } catch (err) {
+ console.error(err)
+ return false
+ }
}
-export default { convert, hash, sign, sweep, verify }
+export const Tools = { convert, sign, sweep, verify }
// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>\r
// SPDX-License-Identifier: GPL-3.0-or-later\r
\r
-import blake2b from 'blake2b'\r
import { Account } from './account.js'\r
-import { nanoCKD } from './bip32-key-derivation.js'\r
+import { Blake2b } from './blake2b.js'\r
import { Bip39Mnemonic } from './bip39-mnemonic.js'\r
import { ADDRESS_GAP, SEED_LENGTH_BIP44, SEED_LENGTH_BLAKE2B } from './constants.js'\r
-import { dec, hex } from './convert.js'\r
import { Entropy } from './entropy.js'\r
+import { Pool } from './pool.js'\r
import { Rpc } from './rpc.js'\r
import { Safe } from './safe.js'\r
+import { Bip44Ckd, NanoNaCl } from './workers.js'\r
import type { Ledger } from './ledger.js'\r
\r
+type KeyPair = {\r
+ publicKey?: string,\r
+ privateKey?: string,\r
+ index?: number\r
+}\r
/**\r
* Represents a wallet containing numerous Nano accounts derived from a single\r
* source, the form of which can vary based on the type of wallet. The Wallet\r
#id: Entropy\r
#locked: boolean = true\r
#mnemonic: Bip39Mnemonic | null\r
+ #poolNanoNacl: Pool\r
#safe: Safe\r
#seed: string | null\r
get id () { return this.#id.hex }\r
return ''\r
}\r
\r
- abstract ckd (index: number): Promise<Account>\r
+ abstract ckd (index: number[]): Promise<KeyPair[]>\r
\r
- constructor (seed?: string, mnemonic?: Bip39Mnemonic, id?: string) {\r
+ constructor (id: Entropy, seed?: string, mnemonic?: Bip39Mnemonic) {\r
if (this.constructor === Wallet) {\r
throw new Error('Wallet is an abstract class and cannot be instantiated directly.')\r
}\r
this.#accounts = []\r
this.#id = id\r
- ? new Entropy(id)\r
- : new Entropy(16)\r
this.#mnemonic = mnemonic ?? null\r
+ this.#poolNanoNacl = new Pool(NanoNaCl)\r
this.#safe = new Safe()\r
this.#seed = seed ?? null\r
}\r
from = to\r
to = swap\r
}\r
+ const indexes: number[] = []\r
for (let i = from; i <= to; i++) {\r
if (this.#accounts[i] == null) {\r
- this.#accounts[i] = await this.ckd(i)\r
+ indexes.push(i)\r
+ }\r
+ }\r
+ if (indexes.length > 0) {\r
+ let results = await this.ckd(indexes)\r
+ const data: any = []\r
+ results.forEach(r => data.push({ privateKey: r.privateKey, index: r.index }))\r
+ const keypairs: KeyPair[] = await this.#poolNanoNacl.assign(data)\r
+ for (const keypair of keypairs) {\r
+ if (keypair.privateKey == null) throw new RangeError('Account private key missing')\r
+ if (keypair.publicKey == null) throw new RangeError('Account public key missing')\r
+ if (keypair.index == null) throw new RangeError('Account keys derived but index missing')\r
+ const { privateKey, publicKey, index } = keypair\r
+ this.#accounts[keypair.index] = Account.fromKeypair(privateKey, publicKey, index)\r
}\r
}\r
return this.#accounts.slice(from, to + 1)\r
for (const key of Object.keys(errors ?? {})) {\r
const value = errors[key]\r
if (value === 'Account not found') {\r
- return new Account(key)\r
+ return Account.fromAddress(key)\r
}\r
}\r
return await this.getNextNewAccount(rpc, batchSize, from + batchSize)\r
*/\r
export class Bip44Wallet extends Wallet {\r
static #isInternal: boolean = false\r
+ static #poolBip44Ckd: Pool = new Pool(Bip44Ckd)\r
\r
- constructor (seed: string, mnemonic?: Bip39Mnemonic, id?: string) {\r
+ constructor (id: Entropy, seed: string, mnemonic?: Bip39Mnemonic) {\r
if (!Bip44Wallet.#isInternal) {\r
throw new Error(`Bip44Wallet cannot be instantiated directly. Use 'await Bip44Wallet.create()' instead.`)\r
}\r
- super(seed, mnemonic, id)\r
Bip44Wallet.#isInternal = false\r
+ super(id, seed, mnemonic)\r
}\r
\r
/**\r
*/\r
static async create (key: CryptoKey, salt?: string): Promise<Bip44Wallet>\r
static async create (passkey: string | CryptoKey, salt: string = ''): Promise<Bip44Wallet> {\r
- Bip44Wallet.#isInternal = true\r
try {\r
- const e = new Entropy()\r
+ const e = await Entropy.create()\r
return await Bip44Wallet.fromEntropy(passkey as string, e.hex, salt)\r
} catch (err) {\r
throw new Error(`Error creating new Bip44Wallet: ${err}`)\r
*/\r
static async fromEntropy (key: CryptoKey, entropy: string, salt?: string): Promise<Bip44Wallet>\r
static async fromEntropy (passkey: string | CryptoKey, entropy: string, salt: string = ''): Promise<Bip44Wallet> {\r
- Bip44Wallet.#isInternal = true\r
try {\r
- const e = new Entropy(entropy)\r
+ const id = await Entropy.create(16)\r
+ const e = await Entropy.import(entropy)\r
const m = await Bip39Mnemonic.fromEntropy(e.hex)\r
const s = await m.toBip39Seed(salt)\r
- const wallet = new this(s, m)\r
+ Bip44Wallet.#isInternal = true\r
+ const wallet = new this(id, s, m)\r
await wallet.lock(passkey as string)\r
return wallet\r
} catch (err) {\r
*/\r
static async fromMnemonic (key: CryptoKey, mnemonic: string, salt?: string): Promise<Bip44Wallet>\r
static async fromMnemonic (passkey: string | CryptoKey, mnemonic: string, salt: string = ''): Promise<Bip44Wallet> {\r
- Bip44Wallet.#isInternal = true\r
try {\r
+ const id = await Entropy.create(16)\r
const m = await Bip39Mnemonic.fromPhrase(mnemonic)\r
const s = await m.toBip39Seed(salt)\r
- const wallet = new this(s, m)\r
+ Bip44Wallet.#isInternal = true\r
+ const wallet = new this(id, s, m)\r
await wallet.lock(passkey as string)\r
return wallet\r
} catch (err) {\r
*/\r
static async fromSeed (key: CryptoKey, seed: string): Promise<Bip44Wallet>\r
static async fromSeed (passkey: string | CryptoKey, seed: string): Promise<Bip44Wallet> {\r
- Bip44Wallet.#isInternal = true\r
if (seed.length !== SEED_LENGTH_BIP44) {\r
throw new Error(`Expected a ${SEED_LENGTH_BIP44}-character seed, but received ${seed.length}-character string.`)\r
}\r
if (!/^[0-9a-fA-F]+$/i.test(seed)) {\r
throw new Error('Seed contains invalid hexadecimal characters.')\r
}\r
- const wallet = new this(seed)\r
+ const id = await Entropy.create(16)\r
+ Bip44Wallet.#isInternal = true\r
+ const wallet = new this(id, seed)\r
await wallet.lock(passkey as string)\r
return wallet\r
}\r
* @returns {Bip44Wallet} Restored locked Bip44Wallet\r
*/\r
static async restore (id: string): Promise<Bip44Wallet> {\r
- Bip44Wallet.#isInternal = true\r
if (typeof id !== 'string' || id === '') {\r
throw new TypeError('Wallet ID is required to restore')\r
}\r
- const wallet = new this('', undefined, id)\r
- return wallet\r
+ Bip44Wallet.#isInternal = true\r
+ return new this(await Entropy.import(id), '')\r
}\r
\r
/**\r
* Derives BIP-44 Nano account private keys.\r
*\r
- * @param {number} index - Index of the account\r
+ * @param {number[]} indexes - Indexes of the accounts\r
* @returns {Promise<Account>}\r
*/\r
- async ckd (index: number): Promise<Account> {\r
- const key = await nanoCKD(this.seed, index)\r
- if (typeof key !== 'string') {\r
- throw new TypeError('BIP-44 child key derivation returned invalid data')\r
- }\r
- return Account.fromPrivateKey(key, index)\r
+ async ckd (indexes: number[]): Promise<KeyPair[]> {\r
+ const data: any = []\r
+ indexes.forEach(i => data.push({ seed: this.seed, index: i }))\r
+ const privateKeys: KeyPair[] = await Bip44Wallet.#poolBip44Ckd.assign(data)\r
+ return privateKeys\r
}\r
}\r
\r
export class Blake2bWallet extends Wallet {\r
static #isInternal: boolean = false\r
\r
- constructor (seed: string, mnemonic?: Bip39Mnemonic, id?: string) {\r
+ constructor (id: Entropy, seed: string, mnemonic?: Bip39Mnemonic) {\r
if (!Blake2bWallet.#isInternal) {\r
throw new Error(`Blake2bWallet cannot be instantiated directly. Use 'await Blake2bWallet.create()' instead.`)\r
}\r
- super(seed, mnemonic, id)\r
Blake2bWallet.#isInternal = false\r
+ super(id, seed, mnemonic)\r
}\r
\r
/**\r
*/\r
static async create (key: CryptoKey): Promise<Blake2bWallet>\r
static async create (passkey: string | CryptoKey): Promise<Blake2bWallet> {\r
- Blake2bWallet.#isInternal = true\r
try {\r
- const seed = new Entropy()\r
+ const seed = await Entropy.create()\r
return await Blake2bWallet.fromSeed(passkey as string, seed.hex)\r
} catch (err) {\r
throw new Error(`Error creating new Blake2bWallet: ${err}`)\r
*/\r
static async fromSeed (key: CryptoKey, seed: string): Promise<Blake2bWallet>\r
static async fromSeed (passkey: string | CryptoKey, seed: string): Promise<Blake2bWallet> {\r
- Blake2bWallet.#isInternal = true\r
if (seed.length !== SEED_LENGTH_BLAKE2B) {\r
throw new Error(`Expected a ${SEED_LENGTH_BLAKE2B}-character seed, but received ${seed.length}-character string.`)\r
}\r
if (!/^[0-9a-fA-F]+$/i.test(seed)) {\r
throw new Error('Seed contains invalid hexadecimal characters.')\r
}\r
+ const id = await Entropy.create(16)\r
const s = seed\r
const m = await Bip39Mnemonic.fromEntropy(seed)\r
- const wallet = new this(s, m)\r
+ Blake2bWallet.#isInternal = true\r
+ const wallet = new this(id, s, m)\r
await wallet.lock(passkey as string)\r
return wallet\r
}\r
*/\r
static async fromMnemonic (key: CryptoKey, mnemonic: string): Promise<Blake2bWallet>\r
static async fromMnemonic (passkey: string | CryptoKey, mnemonic: string): Promise<Blake2bWallet> {\r
- Blake2bWallet.#isInternal = true\r
try {\r
+ const id = await Entropy.create(16)\r
const m = await Bip39Mnemonic.fromPhrase(mnemonic)\r
const s = await m.toBlake2bSeed()\r
- const wallet = new this(s, m)\r
+ Blake2bWallet.#isInternal = true\r
+ const wallet = new this(id, s, m)\r
await wallet.lock(passkey as string)\r
return wallet\r
} catch (err) {\r
* @returns {Blake2bWallet} Restored locked Blake2bWallet\r
*/\r
static async restore (id: string): Promise<Blake2bWallet> {\r
- Blake2bWallet.#isInternal = true\r
if (typeof id !== 'string' || id === '') {\r
throw new TypeError('Wallet ID is required to restore')\r
}\r
- const wallet = new this('', undefined, id)\r
- return wallet\r
+ Blake2bWallet.#isInternal = true\r
+ return new this(await Entropy.import(id), '')\r
}\r
\r
/**\r
* Derives BLAKE2b account private keys.\r
*\r
- * @param {number} index - Index of the account\r
+ * @param {number[]} indexes - Indexes of the accounts\r
* @returns {Promise<Account>}\r
*/\r
- async ckd (index: number): Promise<Account> {\r
- const input = `${this.seed}${dec.toHex(index, 8)}`\r
- const key = blake2b(32).update(hex.toBytes(input)).digest('hex')\r
- if (typeof key !== 'string') {\r
- throw new TypeError('BLAKE2b child key derivation returned invalid data')\r
- }\r
- return Account.fromPrivateKey(key, index)\r
+ async ckd (indexes: number[]): Promise<KeyPair[]> {\r
+ const results = indexes.map(index => {\r
+ const indexHex = index.toString(16).padStart(8, '0').toUpperCase()\r
+ const inputHex = `${this.seed}${indexHex}`.padStart(72, '0')\r
+ const inputArray = (inputHex.match(/.{1,2}/g) ?? []).map(h => parseInt(h, 16))\r
+ const inputBytes = Uint8Array.from(inputArray)\r
+ const privateKey: string = new Blake2b(32).update(inputBytes).digest('hex')\r
+ return { privateKey, index }\r
+ })\r
+ return results\r
}\r
}\r
\r
\r
get ledger () { return this.#ledger }\r
\r
- constructor (ledger: Ledger, id?: string) {\r
+ constructor (id: Entropy, ledger: Ledger) {\r
if (!LedgerWallet.#isInternal) {\r
throw new Error(`LedgerWallet cannot be instantiated directly. Use 'await LedgerWallet.create()' instead.`)\r
}\r
- super(undefined, undefined, id)\r
- this.#ledger = ledger\r
LedgerWallet.#isInternal = false\r
+ super(id)\r
+ this.#ledger = ledger\r
}\r
\r
/**\r
* @returns {LedgerWallet} A wallet containing accounts and a Ledger device communication object\r
*/\r
static async create (): Promise<LedgerWallet> {\r
- LedgerWallet.#isInternal = true\r
const { Ledger } = await import('./ledger.js')\r
const l = await Ledger.init()\r
- return new this(l)\r
+ const id = await Entropy.create(16)\r
+ LedgerWallet.#isInternal = true\r
+ return new this(id, l)\r
}\r
\r
/**\r
* @returns {LedgerWallet} Restored LedgerWallet\r
*/\r
static async restore (id: string): Promise<LedgerWallet> {\r
- LedgerWallet.#isInternal = true\r
if (typeof id !== 'string' || id === '') {\r
throw new TypeError('Wallet ID is required to restore')\r
}\r
const { Ledger } = await import('./ledger.js')\r
const l = await Ledger.init()\r
- return new this(l, id)\r
+ LedgerWallet.#isInternal = true\r
+ return new this(await Entropy.import(id), l)\r
}\r
\r
/**\r
* Gets the public key for an account from the Ledger device.\r
*\r
- * @param {number} index - Index of the account\r
+ * @param {number[]} indexes - Indexes of the accounts\r
* @returns {Promise<Account>}\r
*/\r
- async ckd (index: number): Promise<Account> {\r
- const { status, publicKey } = await this.ledger.account(index)\r
- if (status === 'OK' && publicKey != null) {\r
- return await Account.fromPublicKey(publicKey, index)\r
+ async ckd (indexes: number[]): Promise<KeyPair[]> {\r
+ const results: KeyPair[] = []\r
+ for (const index of indexes) {\r
+ const { status, publicKey } = await this.ledger.account(index)\r
+ if (status === 'OK' && publicKey != null) {\r
+ results.push({ publicKey, index })\r
+ } else {\r
+ throw new Error(`Error getting Ledger account: ${status}`)\r
+ }\r
}\r
- throw new Error(`Error getting Ledger account: ${status}`)\r
+ return results\r
}\r
\r
/**\r
--- /dev/null
+// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>
+// SPDX-License-Identifier: GPL-3.0-or-later
+import { default as Bip44Ckd } from './workers/bip44-ckd.js'
+import { default as NanoNaCl } from './workers/nano-nacl.js'
+import { default as Pow } from './workers/powgl.js'
+
+export { Bip44Ckd, NanoNaCl, Pow }
--- /dev/null
+// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>
+// SPDX-License-Identifier: GPL-3.0-or-later
+import { WorkerInterface } from '../pool.js'
+
+type ExtendedKey = {
+ privateKey: DataView
+ chainCode: DataView
+}
+
+export class Bip44Ckd extends WorkerInterface {
+ static BIP44_COIN_NANO = 165
+ static BIP44_PURPOSE = 44
+ static HARDENED_OFFSET = 0x80000000
+ static SLIP10_ED25519 = 'ed25519 seed'
+
+ static {
+ Bip44Ckd.listen()
+ }
+
+ static async work (data: any[]): Promise<any[]> {
+ for (const d of data) {
+ if (d.coin != null && d.coin !== this.BIP44_PURPOSE) {
+ d.privateKey = await this.ckd(d.seed, d.coin, d.index)
+ } else {
+ d.privateKey = await this.nanoCKD(d.seed, d.index)
+ }
+ }
+ return data
+ }
+
+ /**
+ * Derives a private child key following the BIP-32 and BIP-44 derivation path
+ * registered to the Nano block lattice. Only hardened child keys are defined.
+ *
+ * @param {string} seed - Hexadecimal seed derived from mnemonic phrase
+ * @param {number} index - Account number between 0 and 2^31-1
+ * @returns {Promise<string>} Private child key for the account
+ */
+ static async nanoCKD (seed: string, index: number): Promise<string> {
+ if (!Number.isSafeInteger(index) || index < 0 || index > 0x7fffffff) {
+ throw new RangeError(`Invalid child key index 0x${index.toString(16)}`)
+ }
+ return await this.ckd(seed, this.BIP44_COIN_NANO, index)
+ }
+
+ /**
+ * Derives a private child key for a coin by following the specified BIP-32 and
+ * BIP-44 derivation path. Purpose is always 44'. Only hardened child keys are
+ * defined.
+ *
+ * @param {string} seed - Hexadecimal seed derived from mnemonic phrase
+ * @param {number} coin - Number registered to a specific coin in SLIP-044
+ * @param {number} index - Account number between 0 and 2^31-1
+ * @returns {Promise<string>} Private child key for the account
+ */
+ static async ckd (seed: string, coin: number, index: number): Promise<string> {
+ if (seed.length < 32 || seed.length > 128) {
+ throw new RangeError(`Invalid seed length`)
+ }
+ if (!Number.isSafeInteger(index) || index < 0 || index > 0x7fffffff) {
+ throw new RangeError(`Invalid child key index 0x${index.toString(16)}`)
+ }
+ const masterKey = await this.slip10(this.SLIP10_ED25519, seed)
+ const purposeKey = await this.CKDpriv(masterKey, this.BIP44_PURPOSE + this.HARDENED_OFFSET)
+ const coinKey = await this.CKDpriv(purposeKey, coin + this.HARDENED_OFFSET)
+ const accountKey = await this.CKDpriv(coinKey, index + this.HARDENED_OFFSET)
+ const privateKey = new Uint8Array(accountKey.privateKey.buffer)
+ let hex = ''
+ for (let i = 0; i < privateKey.length; i++) {
+ hex += privateKey[i].toString(16).padStart(2, '0')
+ }
+ return hex
+ }
+
+ static async slip10 (curve: string, S: string): Promise<ExtendedKey> {
+ const key = new TextEncoder().encode(curve)
+ const data = new Uint8Array(64)
+ data.set(S.match(/.{1,2}/g)!.map(byte => parseInt(byte, 16)))
+ const I = await this.hmac(key, data)
+ const IL = new DataView(I.buffer.slice(0, I.length / 2))
+ const IR = new DataView(I.buffer.slice(I.length / 2))
+ return ({ privateKey: IL, chainCode: IR })
+ }
+
+ static async CKDpriv ({ privateKey, chainCode }: ExtendedKey, index: number): Promise<ExtendedKey> {
+ const key = new Uint8Array(chainCode.buffer)
+ const data = new Uint8Array(37)
+ data.set([0])
+ data.set(this.ser256(privateKey), 1)
+ data.set(this.ser32(index), 33)
+ const I = await this.hmac(key, data)
+ const IL = new DataView(I.buffer.slice(0, I.length / 2))
+ const IR = new DataView(I.buffer.slice(I.length / 2))
+ return ({ privateKey: IL, chainCode: IR })
+ }
+
+ static ser32 (integer: number): Uint8Array {
+ if (typeof integer !== 'number') {
+ throw new TypeError(`Expected a number, received ${typeof integer}`)
+ }
+ if (integer > 0xffffffff) {
+ throw new RangeError(`Expected 32-bit integer, received ${integer.toString(2).length}-bit value: ${integer}`)
+ }
+ const view = new DataView(new ArrayBuffer(4))
+ view.setUint32(0, integer, false)
+ return new Uint8Array(view.buffer)
+ }
+
+ static ser256 (integer: DataView): Uint8Array {
+ if (integer.constructor !== DataView) {
+ throw new TypeError(`Expected DataView, received ${typeof integer}`)
+ }
+ if (integer.byteLength > 32) {
+ throw new RangeError(`Expected 32-byte integer, received ${integer.byteLength}-byte value: ${integer}`)
+ }
+ return new Uint8Array(integer.buffer)
+ }
+
+ static async hmac (key: Uint8Array, data: Uint8Array): Promise<Uint8Array> {
+ const { subtle } = globalThis.crypto
+ const pk = await subtle.importKey('raw', key, { name: 'HMAC', hash: 'SHA-512' }, false, ['sign'])
+ const signature = await subtle.sign('HMAC', pk, data)
+ return new Uint8Array(signature)
+ }
+}
+
+export default `
+ const WorkerInterface = ${WorkerInterface}
+ const Bip44Ckd = ${Bip44Ckd}
+`
--- /dev/null
+// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>\r
+// SPDX-License-Identifier: GPL-3.0-or-later\r
+\r
+'use strict'\r
+\r
+import { Blake2b } from '../blake2b.js'\r
+import { WorkerInterface } from '../pool.js'\r
+\r
+// Ported in 2014 by Dmitry Chestnykh and Devi Mandiri.\r
+// Public domain.\r
+//\r
+// Implementation derived from TweetNaCl version 20140427.\r
+// See for details: http://tweetnacl.cr.yp.to/\r
+//\r
+// Modified in 2024 by Chris Duncan to hash secret key to public key using\r
+// BLAKE2b instead of SHA-512 as specified in the documentation for Nano\r
+// cryptocurrency.\r
+// See for details: https://docs.nano.org/integration-guides/the-basics/\r
+// Original source commit: https://github.com/dchest/tweetnacl-js/blob/71df1d6a1d78236ca3e9f6c788786e21f5a651a6/nacl-fast.js\r
+\r
+export class NanoNaCl extends WorkerInterface {\r
+ static {\r
+ NanoNaCl.listen()\r
+ }\r
+\r
+ static async work (data: any[]): Promise<any[]> {\r
+ return new Promise(async (resolve, reject): Promise<void> => {\r
+ for (let d of data) {\r
+ try {\r
+ d.publicKey = await this.convert(d.privateKey)\r
+ } catch (err) {\r
+ reject(err)\r
+ }\r
+ }\r
+ resolve(data)\r
+ })\r
+ }\r
+\r
+ static gf = function (init?: number[]): Float64Array {\r
+ const r = new Float64Array(16)\r
+ if (init) for (let i = 0; i < init.length; i++) r[i] = init[i]\r
+ return r\r
+ }\r
+\r
+ static gf0: Float64Array = this.gf()\r
+ static gf1: Float64Array = this.gf([1])\r
+ static D: Float64Array = this.gf([0x78a3, 0x1359, 0x4dca, 0x75eb, 0xd8ab, 0x4141, 0x0a4d, 0x0070, 0xe898, 0x7779, 0x4079, 0x8cc7, 0xfe73, 0x2b6f, 0x6cee, 0x5203])\r
+ static D2: Float64Array = this.gf([0xf159, 0x26b2, 0x9b94, 0xebd6, 0xb156, 0x8283, 0x149a, 0x00e0, 0xd130, 0xeef3, 0x80f2, 0x198e, 0xfce7, 0x56df, 0xd9dc, 0x2406])\r
+ static X: Float64Array = this.gf([0xd51a, 0x8f25, 0x2d60, 0xc956, 0xa7b2, 0x9525, 0xc760, 0x692c, 0xdc5c, 0xfdd6, 0xe231, 0xc0a4, 0x53fe, 0xcd6e, 0x36d3, 0x2169])\r
+ static Y: Float64Array = this.gf([0x6658, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666])\r
+ static I: Float64Array = this.gf([0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, 0x2f43, 0xd7a7, 0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1, 0x2480, 0x2b83])\r
+\r
+ static vn (x: Uint8Array, xi: number, y: Uint8Array, yi: number, n: number): number {\r
+ let d = 0\r
+ for (let i = 0; i < n; i++) d |= x[xi + i] ^ y[yi + i]\r
+ return (1 & ((d - 1) >>> 8)) - 1\r
+ }\r
+\r
+ static crypto_verify_32 (x: Uint8Array, xi: number, y: Uint8Array, yi: number): number {\r
+ return this.vn(x, xi, y, yi, 32)\r
+ }\r
+\r
+ static set25519 (r: Float64Array, a: Float64Array): void {\r
+ for (let i = 0; i < 16; i++) r[i] = a[i] | 0\r
+ }\r
+\r
+ static car25519 (o: Float64Array): void {\r
+ let v, c = 1\r
+ for (let i = 0; i < 16; i++) {\r
+ v = o[i] + c + 65535\r
+ c = Math.floor(v / 65536)\r
+ o[i] = v - c * 65536\r
+ }\r
+ o[0] += c - 1 + 37 * (c - 1)\r
+ }\r
+\r
+ static sel25519 (p: Float64Array, q: Float64Array, b: number): void {\r
+ let t\r
+ const c = ~(b - 1)\r
+ for (let i = 0; i < 16; i++) {\r
+ t = c & (p[i] ^ q[i])\r
+ p[i] ^= t\r
+ q[i] ^= t\r
+ }\r
+ }\r
+\r
+ static pack25519 (o: Uint8Array, n: Float64Array): void {\r
+ let b: number\r
+ const m: Float64Array = this.gf()\r
+ const t: Float64Array = this.gf()\r
+ for (let i = 0; i < 16; i++) t[i] = n[i]\r
+ this.car25519(t)\r
+ this.car25519(t)\r
+ this.car25519(t)\r
+ for (let j = 0; j < 2; j++) {\r
+ m[0] = t[0] - 0xffed\r
+ for (let i = 1; i < 15; i++) {\r
+ m[i] = t[i] - 0xffff - ((m[i - 1] >> 16) & 1)\r
+ m[i - 1] &= 0xffff\r
+ }\r
+ m[15] = t[15] - 0x7fff - ((m[14] >> 16) & 1)\r
+ b = (m[15] >> 16) & 1\r
+ m[14] &= 0xffff\r
+ this.sel25519(t, m, 1 - b)\r
+ }\r
+ for (let i = 0; i < 16; i++) {\r
+ o[2 * i] = t[i] & 0xff\r
+ o[2 * i + 1] = t[i] >> 8\r
+ }\r
+ }\r
+\r
+ static neq25519 (a: Float64Array, b: Float64Array): number {\r
+ const c = new Uint8Array(32)\r
+ const d = new Uint8Array(32)\r
+ this.pack25519(c, a)\r
+ this.pack25519(d, b)\r
+ return this.crypto_verify_32(c, 0, d, 0)\r
+ }\r
+\r
+ static par25519 (a: Float64Array): number {\r
+ var d = new Uint8Array(32)\r
+ this.pack25519(d, a)\r
+ return d[0] & 1\r
+ }\r
+\r
+ static unpack25519 (o: Float64Array, n: Uint8Array): void {\r
+ for (let i = 0; i < 16; i++) o[i] = n[2 * i] + (n[2 * i + 1] << 8)\r
+ o[15] &= 0x7fff\r
+ }\r
+\r
+ static A (o: Float64Array, a: Float64Array, b: Float64Array): void {\r
+ for (let i = 0; i < 16; i++) o[i] = a[i] + b[i]\r
+ }\r
+\r
+ static Z (o: Float64Array, a: Float64Array, b: Float64Array): void {\r
+ for (let i = 0; i < 16; i++) o[i] = a[i] - b[i]\r
+ }\r
+\r
+ static M (o: Float64Array, a: Float64Array, b: Float64Array): void {\r
+ let v, c,\r
+ t0 = 0, t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0, t7 = 0,\r
+ t8 = 0, t9 = 0, t10 = 0, t11 = 0, t12 = 0, t13 = 0, t14 = 0, t15 = 0,\r
+ t16 = 0, t17 = 0, t18 = 0, t19 = 0, t20 = 0, t21 = 0, t22 = 0, t23 = 0,\r
+ t24 = 0, t25 = 0, t26 = 0, t27 = 0, t28 = 0, t29 = 0, t30 = 0,\r
+ b0 = b[0],\r
+ b1 = b[1],\r
+ b2 = b[2],\r
+ b3 = b[3],\r
+ b4 = b[4],\r
+ b5 = b[5],\r
+ b6 = b[6],\r
+ b7 = b[7],\r
+ b8 = b[8],\r
+ b9 = b[9],\r
+ b10 = b[10],\r
+ b11 = b[11],\r
+ b12 = b[12],\r
+ b13 = b[13],\r
+ b14 = b[14],\r
+ b15 = b[15]\r
+\r
+ v = a[0]\r
+ t0 += v * b0\r
+ t1 += v * b1\r
+ t2 += v * b2\r
+ t3 += v * b3\r
+ t4 += v * b4\r
+ t5 += v * b5\r
+ t6 += v * b6\r
+ t7 += v * b7\r
+ t8 += v * b8\r
+ t9 += v * b9\r
+ t10 += v * b10\r
+ t11 += v * b11\r
+ t12 += v * b12\r
+ t13 += v * b13\r
+ t14 += v * b14\r
+ t15 += v * b15\r
+ v = a[1]\r
+ t1 += v * b0\r
+ t2 += v * b1\r
+ t3 += v * b2\r
+ t4 += v * b3\r
+ t5 += v * b4\r
+ t6 += v * b5\r
+ t7 += v * b6\r
+ t8 += v * b7\r
+ t9 += v * b8\r
+ t10 += v * b9\r
+ t11 += v * b10\r
+ t12 += v * b11\r
+ t13 += v * b12\r
+ t14 += v * b13\r
+ t15 += v * b14\r
+ t16 += v * b15\r
+ v = a[2]\r
+ t2 += v * b0\r
+ t3 += v * b1\r
+ t4 += v * b2\r
+ t5 += v * b3\r
+ t6 += v * b4\r
+ t7 += v * b5\r
+ t8 += v * b6\r
+ t9 += v * b7\r
+ t10 += v * b8\r
+ t11 += v * b9\r
+ t12 += v * b10\r
+ t13 += v * b11\r
+ t14 += v * b12\r
+ t15 += v * b13\r
+ t16 += v * b14\r
+ t17 += v * b15\r
+ v = a[3]\r
+ t3 += v * b0\r
+ t4 += v * b1\r
+ t5 += v * b2\r
+ t6 += v * b3\r
+ t7 += v * b4\r
+ t8 += v * b5\r
+ t9 += v * b6\r
+ t10 += v * b7\r
+ t11 += v * b8\r
+ t12 += v * b9\r
+ t13 += v * b10\r
+ t14 += v * b11\r
+ t15 += v * b12\r
+ t16 += v * b13\r
+ t17 += v * b14\r
+ t18 += v * b15\r
+ v = a[4]\r
+ t4 += v * b0\r
+ t5 += v * b1\r
+ t6 += v * b2\r
+ t7 += v * b3\r
+ t8 += v * b4\r
+ t9 += v * b5\r
+ t10 += v * b6\r
+ t11 += v * b7\r
+ t12 += v * b8\r
+ t13 += v * b9\r
+ t14 += v * b10\r
+ t15 += v * b11\r
+ t16 += v * b12\r
+ t17 += v * b13\r
+ t18 += v * b14\r
+ t19 += v * b15\r
+ v = a[5]\r
+ t5 += v * b0\r
+ t6 += v * b1\r
+ t7 += v * b2\r
+ t8 += v * b3\r
+ t9 += v * b4\r
+ t10 += v * b5\r
+ t11 += v * b6\r
+ t12 += v * b7\r
+ t13 += v * b8\r
+ t14 += v * b9\r
+ t15 += v * b10\r
+ t16 += v * b11\r
+ t17 += v * b12\r
+ t18 += v * b13\r
+ t19 += v * b14\r
+ t20 += v * b15\r
+ v = a[6]\r
+ t6 += v * b0\r
+ t7 += v * b1\r
+ t8 += v * b2\r
+ t9 += v * b3\r
+ t10 += v * b4\r
+ t11 += v * b5\r
+ t12 += v * b6\r
+ t13 += v * b7\r
+ t14 += v * b8\r
+ t15 += v * b9\r
+ t16 += v * b10\r
+ t17 += v * b11\r
+ t18 += v * b12\r
+ t19 += v * b13\r
+ t20 += v * b14\r
+ t21 += v * b15\r
+ v = a[7]\r
+ t7 += v * b0\r
+ t8 += v * b1\r
+ t9 += v * b2\r
+ t10 += v * b3\r
+ t11 += v * b4\r
+ t12 += v * b5\r
+ t13 += v * b6\r
+ t14 += v * b7\r
+ t15 += v * b8\r
+ t16 += v * b9\r
+ t17 += v * b10\r
+ t18 += v * b11\r
+ t19 += v * b12\r
+ t20 += v * b13\r
+ t21 += v * b14\r
+ t22 += v * b15\r
+ v = a[8]\r
+ t8 += v * b0\r
+ t9 += v * b1\r
+ t10 += v * b2\r
+ t11 += v * b3\r
+ t12 += v * b4\r
+ t13 += v * b5\r
+ t14 += v * b6\r
+ t15 += v * b7\r
+ t16 += v * b8\r
+ t17 += v * b9\r
+ t18 += v * b10\r
+ t19 += v * b11\r
+ t20 += v * b12\r
+ t21 += v * b13\r
+ t22 += v * b14\r
+ t23 += v * b15\r
+ v = a[9]\r
+ t9 += v * b0\r
+ t10 += v * b1\r
+ t11 += v * b2\r
+ t12 += v * b3\r
+ t13 += v * b4\r
+ t14 += v * b5\r
+ t15 += v * b6\r
+ t16 += v * b7\r
+ t17 += v * b8\r
+ t18 += v * b9\r
+ t19 += v * b10\r
+ t20 += v * b11\r
+ t21 += v * b12\r
+ t22 += v * b13\r
+ t23 += v * b14\r
+ t24 += v * b15\r
+ v = a[10]\r
+ t10 += v * b0\r
+ t11 += v * b1\r
+ t12 += v * b2\r
+ t13 += v * b3\r
+ t14 += v * b4\r
+ t15 += v * b5\r
+ t16 += v * b6\r
+ t17 += v * b7\r
+ t18 += v * b8\r
+ t19 += v * b9\r
+ t20 += v * b10\r
+ t21 += v * b11\r
+ t22 += v * b12\r
+ t23 += v * b13\r
+ t24 += v * b14\r
+ t25 += v * b15\r
+ v = a[11]\r
+ t11 += v * b0\r
+ t12 += v * b1\r
+ t13 += v * b2\r
+ t14 += v * b3\r
+ t15 += v * b4\r
+ t16 += v * b5\r
+ t17 += v * b6\r
+ t18 += v * b7\r
+ t19 += v * b8\r
+ t20 += v * b9\r
+ t21 += v * b10\r
+ t22 += v * b11\r
+ t23 += v * b12\r
+ t24 += v * b13\r
+ t25 += v * b14\r
+ t26 += v * b15\r
+ v = a[12]\r
+ t12 += v * b0\r
+ t13 += v * b1\r
+ t14 += v * b2\r
+ t15 += v * b3\r
+ t16 += v * b4\r
+ t17 += v * b5\r
+ t18 += v * b6\r
+ t19 += v * b7\r
+ t20 += v * b8\r
+ t21 += v * b9\r
+ t22 += v * b10\r
+ t23 += v * b11\r
+ t24 += v * b12\r
+ t25 += v * b13\r
+ t26 += v * b14\r
+ t27 += v * b15\r
+ v = a[13]\r
+ t13 += v * b0\r
+ t14 += v * b1\r
+ t15 += v * b2\r
+ t16 += v * b3\r
+ t17 += v * b4\r
+ t18 += v * b5\r
+ t19 += v * b6\r
+ t20 += v * b7\r
+ t21 += v * b8\r
+ t22 += v * b9\r
+ t23 += v * b10\r
+ t24 += v * b11\r
+ t25 += v * b12\r
+ t26 += v * b13\r
+ t27 += v * b14\r
+ t28 += v * b15\r
+ v = a[14]\r
+ t14 += v * b0\r
+ t15 += v * b1\r
+ t16 += v * b2\r
+ t17 += v * b3\r
+ t18 += v * b4\r
+ t19 += v * b5\r
+ t20 += v * b6\r
+ t21 += v * b7\r
+ t22 += v * b8\r
+ t23 += v * b9\r
+ t24 += v * b10\r
+ t25 += v * b11\r
+ t26 += v * b12\r
+ t27 += v * b13\r
+ t28 += v * b14\r
+ t29 += v * b15\r
+ v = a[15]\r
+ t15 += v * b0\r
+ t16 += v * b1\r
+ t17 += v * b2\r
+ t18 += v * b3\r
+ t19 += v * b4\r
+ t20 += v * b5\r
+ t21 += v * b6\r
+ t22 += v * b7\r
+ t23 += v * b8\r
+ t24 += v * b9\r
+ t25 += v * b10\r
+ t26 += v * b11\r
+ t27 += v * b12\r
+ t28 += v * b13\r
+ t29 += v * b14\r
+ t30 += v * b15\r
+\r
+ t0 += 38 * t16\r
+ t1 += 38 * t17\r
+ t2 += 38 * t18\r
+ t3 += 38 * t19\r
+ t4 += 38 * t20\r
+ t5 += 38 * t21\r
+ t6 += 38 * t22\r
+ t7 += 38 * t23\r
+ t8 += 38 * t24\r
+ t9 += 38 * t25\r
+ t10 += 38 * t26\r
+ t11 += 38 * t27\r
+ t12 += 38 * t28\r
+ t13 += 38 * t29\r
+ t14 += 38 * t30\r
+ // t15 left as is\r
+\r
+ // first car\r
+ c = 1\r
+ v = t0 + c + 65535; c = Math.floor(v / 65536); t0 = v - c * 65536\r
+ v = t1 + c + 65535; c = Math.floor(v / 65536); t1 = v - c * 65536\r
+ v = t2 + c + 65535; c = Math.floor(v / 65536); t2 = v - c * 65536\r
+ v = t3 + c + 65535; c = Math.floor(v / 65536); t3 = v - c * 65536\r
+ v = t4 + c + 65535; c = Math.floor(v / 65536); t4 = v - c * 65536\r
+ v = t5 + c + 65535; c = Math.floor(v / 65536); t5 = v - c * 65536\r
+ v = t6 + c + 65535; c = Math.floor(v / 65536); t6 = v - c * 65536\r
+ v = t7 + c + 65535; c = Math.floor(v / 65536); t7 = v - c * 65536\r
+ v = t8 + c + 65535; c = Math.floor(v / 65536); t8 = v - c * 65536\r
+ v = t9 + c + 65535; c = Math.floor(v / 65536); t9 = v - c * 65536\r
+ v = t10 + c + 65535; c = Math.floor(v / 65536); t10 = v - c * 65536\r
+ v = t11 + c + 65535; c = Math.floor(v / 65536); t11 = v - c * 65536\r
+ v = t12 + c + 65535; c = Math.floor(v / 65536); t12 = v - c * 65536\r
+ v = t13 + c + 65535; c = Math.floor(v / 65536); t13 = v - c * 65536\r
+ v = t14 + c + 65535; c = Math.floor(v / 65536); t14 = v - c * 65536\r
+ v = t15 + c + 65535; c = Math.floor(v / 65536); t15 = v - c * 65536\r
+ t0 += c - 1 + 37 * (c - 1)\r
+\r
+ // second car\r
+ c = 1\r
+ v = t0 + c + 65535; c = Math.floor(v / 65536); t0 = v - c * 65536\r
+ v = t1 + c + 65535; c = Math.floor(v / 65536); t1 = v - c * 65536\r
+ v = t2 + c + 65535; c = Math.floor(v / 65536); t2 = v - c * 65536\r
+ v = t3 + c + 65535; c = Math.floor(v / 65536); t3 = v - c * 65536\r
+ v = t4 + c + 65535; c = Math.floor(v / 65536); t4 = v - c * 65536\r
+ v = t5 + c + 65535; c = Math.floor(v / 65536); t5 = v - c * 65536\r
+ v = t6 + c + 65535; c = Math.floor(v / 65536); t6 = v - c * 65536\r
+ v = t7 + c + 65535; c = Math.floor(v / 65536); t7 = v - c * 65536\r
+ v = t8 + c + 65535; c = Math.floor(v / 65536); t8 = v - c * 65536\r
+ v = t9 + c + 65535; c = Math.floor(v / 65536); t9 = v - c * 65536\r
+ v = t10 + c + 65535; c = Math.floor(v / 65536); t10 = v - c * 65536\r
+ v = t11 + c + 65535; c = Math.floor(v / 65536); t11 = v - c * 65536\r
+ v = t12 + c + 65535; c = Math.floor(v / 65536); t12 = v - c * 65536\r
+ v = t13 + c + 65535; c = Math.floor(v / 65536); t13 = v - c * 65536\r
+ v = t14 + c + 65535; c = Math.floor(v / 65536); t14 = v - c * 65536\r
+ v = t15 + c + 65535; c = Math.floor(v / 65536); t15 = v - c * 65536\r
+ t0 += c - 1 + 37 * (c - 1)\r
+\r
+ o[0] = t0\r
+ o[1] = t1\r
+ o[2] = t2\r
+ o[3] = t3\r
+ o[4] = t4\r
+ o[5] = t5\r
+ o[6] = t6\r
+ o[7] = t7\r
+ o[8] = t8\r
+ o[9] = t9\r
+ o[10] = t10\r
+ o[11] = t11\r
+ o[12] = t12\r
+ o[13] = t13\r
+ o[14] = t14\r
+ o[15] = t15\r
+ }\r
+\r
+ static S (o: Float64Array, a: Float64Array): void {\r
+ this.M(o, a, a)\r
+ }\r
+\r
+ static inv25519 (o: Float64Array, i: Float64Array): void {\r
+ const c: Float64Array = this.gf()\r
+ for (let a = 0; a < 16; a++) c[a] = i[a]\r
+ for (let a = 253; a >= 0; a--) {\r
+ this.S(c, c)\r
+ if (a !== 2 && a !== 4) this.M(c, c, i)\r
+ }\r
+ for (let a = 0; a < 16; a++) o[a] = c[a]\r
+ }\r
+\r
+ static pow2523 (o: Float64Array, i: Float64Array): void {\r
+ const c: Float64Array = this.gf()\r
+ for (let a = 0; a < 16; a++) c[a] = i[a]\r
+ for (let a = 250; a >= 0; a--) {\r
+ this.S(c, c)\r
+ if (a !== 1) this.M(c, c, i)\r
+ }\r
+ for (let a = 0; a < 16; a++) o[a] = c[a]\r
+ }\r
+\r
+ // Note: difference from TweetNaCl - BLAKE2b used to hash instead of SHA-512.\r
+ static crypto_hash (out: Uint8Array, m: Uint8Array, n: number): number {\r
+ const input = new Uint8Array(n)\r
+ for (let i = 0; i < n; ++i) input[i] = m[i]\r
+ const hash = new Blake2b(64).update(m).digest()\r
+ for (let i = 0; i < 64; ++i) out[i] = hash[i]\r
+ return 0\r
+ }\r
+\r
+ static add (p: Float64Array[], q: Float64Array[]): void {\r
+ const a: Float64Array = this.gf()\r
+ const b: Float64Array = this.gf()\r
+ const c: Float64Array = this.gf()\r
+ const d: Float64Array = this.gf()\r
+ const e: Float64Array = this.gf()\r
+ const f: Float64Array = this.gf()\r
+ const g: Float64Array = this.gf()\r
+ const h: Float64Array = this.gf()\r
+ const t: Float64Array = this.gf()\r
+\r
+ this.Z(a, p[1], p[0])\r
+ this.Z(t, q[1], q[0])\r
+ this.M(a, a, t)\r
+ this.A(b, p[0], p[1])\r
+ this.A(t, q[0], q[1])\r
+ this.M(b, b, t)\r
+ this.M(c, p[3], q[3])\r
+ this.M(c, c, this.D2)\r
+ this.M(d, p[2], q[2])\r
+ this.A(d, d, d)\r
+ this.Z(e, b, a)\r
+ this.Z(f, d, c)\r
+ this.A(g, d, c)\r
+ this.A(h, b, a)\r
+\r
+ this.M(p[0], e, f)\r
+ this.M(p[1], h, g)\r
+ this.M(p[2], g, f)\r
+ this.M(p[3], e, h)\r
+ }\r
+\r
+ static cswap (p: Float64Array[], q: Float64Array[], b: number): void {\r
+ for (let i = 0; i < 4; i++) {\r
+ this.sel25519(p[i], q[i], b)\r
+ }\r
+ }\r
+\r
+ static pack (r: Uint8Array, p: Float64Array[]): void {\r
+ const tx: Float64Array = this.gf()\r
+ const ty: Float64Array = this.gf()\r
+ const zi: Float64Array = this.gf()\r
+ this.inv25519(zi, p[2])\r
+ this.M(tx, p[0], zi)\r
+ this.M(ty, p[1], zi)\r
+ this.pack25519(r, ty)\r
+ r[31] ^= this.par25519(tx) << 7\r
+ }\r
+\r
+ static scalarmult (p: Float64Array[], q: Float64Array[], s: Uint8Array): void {\r
+ this.set25519(p[0], this.gf0)\r
+ this.set25519(p[1], this.gf1)\r
+ this.set25519(p[2], this.gf1)\r
+ this.set25519(p[3], this.gf0)\r
+ for (let i = 255; i >= 0; --i) {\r
+ const b = (s[(i / 8) | 0] >> (i & 7)) & 1\r
+ this.cswap(p, q, b)\r
+ this.add(q, p)\r
+ this.add(p, p)\r
+ this.cswap(p, q, b)\r
+ }\r
+ }\r
+\r
+ static scalarbase (p: Float64Array[], s: Uint8Array): void {\r
+ const q: Float64Array[] = [this.gf(), this.gf(), this.gf(), this.gf()]\r
+ this.set25519(q[0], this.X)\r
+ this.set25519(q[1], this.Y)\r
+ this.set25519(q[2], this.gf1)\r
+ this.M(q[3], this.X, this.Y)\r
+ this.scalarmult(p, q, s)\r
+ }\r
+\r
+ static L = new Float64Array([\r
+ 0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58,\r
+ 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14,\r
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10\r
+ ])\r
+\r
+ static modL (r: Uint8Array, x: Float64Array): void {\r
+ let carry, i, j, k\r
+ for (i = 63; i >= 32; --i) {\r
+ carry = 0\r
+ for (j = i - 32, k = i - 12; j < k; ++j) {\r
+ x[j] += carry - 16 * x[i] * this.L[j - (i - 32)]\r
+ carry = Math.floor((x[j] + 128) / 256)\r
+ x[j] -= carry * 256\r
+ }\r
+ x[j] += carry\r
+ x[i] = 0\r
+ }\r
+ carry = 0\r
+ for (j = 0; j < 32; j++) {\r
+ x[j] += carry - (x[31] >> 4) * this.L[j]\r
+ carry = x[j] >> 8\r
+ x[j] &= 255\r
+ }\r
+ for (j = 0; j < 32; j++) x[j] -= carry * this.L[j]\r
+ for (i = 0; i < 32; i++) {\r
+ x[i + 1] += x[i] >> 8\r
+ r[i] = x[i] & 255\r
+ }\r
+ }\r
+\r
+ static reduce (r: Uint8Array): void {\r
+ let x = new Float64Array(64)\r
+ for (let i = 0; i < 64; i++) x[i] = r[i]\r
+ for (let i = 0; i < 64; i++) r[i] = 0\r
+ this.modL(r, x)\r
+ }\r
+\r
+ // Note: difference from C - smlen returned, not passed as argument.\r
+ static crypto_sign (sm: Uint8Array, m: Uint8Array, n: number, sk: Uint8Array, pk: Uint8Array): number {\r
+ const d = new Uint8Array(64)\r
+ const h = new Uint8Array(64)\r
+ const r = new Uint8Array(64)\r
+ const x = new Float64Array(64)\r
+ const p: Float64Array[] = [this.gf(), this.gf(), this.gf(), this.gf()]\r
+\r
+ this.crypto_hash(d, sk, 32)\r
+ d[0] &= 248\r
+ d[31] &= 127\r
+ d[31] |= 64\r
+\r
+ const smlen = n + 64\r
+ for (let i = 0; i < n; i++) sm[64 + i] = m[i]\r
+ for (let i = 0; i < 32; i++) sm[32 + i] = d[32 + i]\r
+\r
+ this.crypto_hash(r, sm.subarray(32), n + 32)\r
+ this.reduce(r)\r
+ this.scalarbase(p, r)\r
+ this.pack(sm, p)\r
+\r
+ for (let i = 0; i < 32; i++) sm[i + 32] = pk[i]\r
+ this.crypto_hash(h, sm, n + 64)\r
+ this.reduce(h)\r
+\r
+ for (let i = 0; i < 64; i++) x[i] = 0\r
+ for (let i = 0; i < 32; i++) x[i] = r[i]\r
+ for (let i = 0; i < 32; i++) {\r
+ for (let j = 0; j < 32; j++) {\r
+ x[i + j] += h[i] * d[j]\r
+ }\r
+ }\r
+\r
+ this.modL(sm.subarray(32), x)\r
+ return smlen\r
+ }\r
+\r
+ static unpackneg (r: Float64Array[], p: Uint8Array): -1 | 0 {\r
+ const t: Float64Array = this.gf()\r
+ const chk: Float64Array = this.gf()\r
+ const num: Float64Array = this.gf()\r
+ const den: Float64Array = this.gf()\r
+ const den2: Float64Array = this.gf()\r
+ const den4: Float64Array = this.gf()\r
+ const den6: Float64Array = this.gf()\r
+\r
+ this.set25519(r[2], this.gf1)\r
+ this.unpack25519(r[1], p)\r
+ this.S(num, r[1])\r
+ this.M(den, num, this.D)\r
+ this.Z(num, num, r[2])\r
+ this.A(den, r[2], den)\r
+\r
+ this.S(den2, den)\r
+ this.S(den4, den2)\r
+ this.M(den6, den4, den2)\r
+ this.M(t, den6, num)\r
+ this.M(t, t, den)\r
+\r
+ this.pow2523(t, t)\r
+ this.M(t, t, num)\r
+ this.M(t, t, den)\r
+ this.M(t, t, den)\r
+ this.M(r[0], t, den)\r
+\r
+ this.S(chk, r[0])\r
+ this.M(chk, chk, den)\r
+ if (this.neq25519(chk, num)) this.M(r[0], r[0], this.I)\r
+\r
+ this.S(chk, r[0])\r
+ this.M(chk, chk, den)\r
+\r
+ if (this.neq25519(chk, num)) return -1\r
+\r
+ if (this.par25519(r[0]) === (p[31] >> 7)) this.Z(r[0], this.gf0, r[0])\r
+ this.M(r[3], r[0], r[1])\r
+ return 0\r
+ }\r
+\r
+ static crypto_sign_open (m: Uint8Array, sm: Uint8Array, n: number, pk: Uint8Array): number {\r
+ const t = new Uint8Array(32)\r
+ const h = new Uint8Array(64)\r
+ const p: Float64Array[] = [this.gf(), this.gf(), this.gf(), this.gf()]\r
+ const q: Float64Array[] = [this.gf(), this.gf(), this.gf(), this.gf()]\r
+\r
+ if (n < 64) return -1\r
+\r
+ if (this.unpackneg(q, pk)) return -1\r
+\r
+ for (let i = 0; i < n; i++) m[i] = sm[i]\r
+ for (let i = 0; i < 32; i++) m[i + 32] = pk[i]\r
+ this.crypto_hash(h, m, n)\r
+ this.reduce(h)\r
+ this.scalarmult(p, q, h)\r
+\r
+ this.scalarbase(q, sm.subarray(32))\r
+ this.add(p, q)\r
+ this.pack(t, p)\r
+\r
+ n -= 64\r
+ if (this.crypto_verify_32(sm, 0, t, 0)) {\r
+ for (let i = 0; i < n; i++) m[i] = 0\r
+ return -1\r
+ }\r
+\r
+ for (let i = 0; i < n; i++) m[i] = sm[i + 64]\r
+ return n\r
+ }\r
+\r
+ static crypto_sign_BYTES = 64\r
+ static crypto_sign_PUBLICKEYBYTES = 32\r
+ static crypto_sign_SECRETKEYBYTES = 32\r
+ static crypto_sign_SEEDBYTES = 32\r
+\r
+ /* High-level API */\r
+\r
+ static checkArrayTypes (...args: Uint8Array[]): void {\r
+ for (let i = 0; i < args.length; i++) {\r
+ if (!(args[i] instanceof Uint8Array))\r
+ throw new TypeError(`expected Uint8Array; received ${args[i].constructor?.name ?? typeof args[i]}`)\r
+ }\r
+ }\r
+\r
+ static parseHex (hex: string): Uint8Array {\r
+ if (hex.length % 2 === 1) hex = `0${hex}`\r
+ const arr = hex.match(/.{1,2}/g)?.map(byte => parseInt(byte, 16))\r
+ return Uint8Array.from(arr ?? [])\r
+ }\r
+\r
+ static hexify (buf: Uint8Array): string {\r
+ let str = ''\r
+ for (let i = 0; i < buf.length; i++) {\r
+ if (typeof buf[i] !== 'number')\r
+ throw new TypeError(`expected number to convert to hex; received ${typeof buf[i]}`)\r
+ if (buf[i] < 0 || buf[i] > 255)\r
+ throw new RangeError(`expected byte value 0-255; received ${buf[i]}`)\r
+ str += buf[i].toString(16).padStart(2, '0')\r
+ }\r
+ return str\r
+ }\r
+\r
+ static sign (msg: Uint8Array, secretKey: Uint8Array): Uint8Array {\r
+ this.checkArrayTypes(msg, secretKey)\r
+ if (secretKey.length !== this.crypto_sign_SECRETKEYBYTES)\r
+ throw new Error('bad secret key size')\r
+ var signedMsg = new Uint8Array(this.crypto_sign_BYTES + msg.length)\r
+ const publicKey = this.parseHex(this.convert(secretKey))\r
+ this.crypto_sign(signedMsg, msg, msg.length, secretKey, publicKey)\r
+ return signedMsg\r
+ }\r
+\r
+ static open (signedMsg: Uint8Array, publicKey: Uint8Array): Uint8Array {\r
+ this.checkArrayTypes(signedMsg, publicKey)\r
+ if (publicKey.length !== this.crypto_sign_PUBLICKEYBYTES)\r
+ throw new Error('bad public key size')\r
+ const tmp = new Uint8Array(signedMsg.length)\r
+ var mlen = this.crypto_sign_open(tmp, signedMsg, signedMsg.length, publicKey)\r
+\r
+ if (mlen < 0) return new Uint8Array(0)\r
+\r
+ var m = new Uint8Array(mlen)\r
+ for (var i = 0; i < m.length; i++) m[i] = tmp[i]\r
+ return m\r
+ }\r
+\r
+ static detached (msg: Uint8Array, secretKey: Uint8Array): string {\r
+ var signedMsg = this.sign(msg, secretKey)\r
+ var sig = new Uint8Array(this.crypto_sign_BYTES)\r
+ for (var i = 0; i < sig.length; i++) sig[i] = signedMsg[i]\r
+ return this.hexify(sig).toUpperCase()\r
+ }\r
+\r
+ static verify (msg: Uint8Array, sig: Uint8Array, publicKey: Uint8Array): boolean {\r
+ this.checkArrayTypes(msg, sig, publicKey)\r
+ if (sig.length !== this.crypto_sign_BYTES)\r
+ throw new Error('bad signature size')\r
+ if (publicKey.length !== this.crypto_sign_PUBLICKEYBYTES)\r
+ throw new Error('bad public key size')\r
+ const sm = new Uint8Array(this.crypto_sign_BYTES + msg.length)\r
+ const m = new Uint8Array(this.crypto_sign_BYTES + msg.length)\r
+ for (let i = 0; i < this.crypto_sign_BYTES; i++) sm[i] = sig[i]\r
+ for (let i = 0; i < msg.length; i++) sm[i + this.crypto_sign_BYTES] = msg[i]\r
+ return (this.crypto_sign_open(m, sm, sm.length, publicKey) >= 0)\r
+ }\r
+\r
+ static convert (seed: string | Uint8Array): string {\r
+ if (typeof seed === 'string') seed = this.parseHex(seed)\r
+ this.checkArrayTypes(seed)\r
+ if (seed.length !== this.crypto_sign_SEEDBYTES)\r
+ throw new Error('bad seed size')\r
+\r
+ const pk = new Uint8Array(this.crypto_sign_PUBLICKEYBYTES)\r
+ const p: Float64Array[] = [this.gf(), this.gf(), this.gf(), this.gf()]\r
+\r
+ const hash = new Blake2b(64).update(seed).digest()\r
+ hash[0] &= 248\r
+ hash[31] &= 127\r
+ hash[31] |= 64\r
+\r
+ this.scalarbase(p, hash)\r
+ this.pack(pk, p)\r
+\r
+ return this.hexify(pk).toUpperCase()\r
+ }\r
+}\r
+\r
+export default `\r
+ const Blake2b = ${Blake2b}\r
+ const WorkerInterface = ${WorkerInterface}\r
+ const NanoNaCl = ${NanoNaCl}\r
+`\r
--- /dev/null
+// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Based on nano-webgl-pow by Ben Green (numtel) <ben@latenightsketches.com>
+// https://github.com/numtel/nano-webgl-pow
+import { WorkerInterface } from '../pool.js'
+
+export class Pow extends WorkerInterface {
+ static {
+ Pow.listen()
+ }
+ /**
+ * Calculates proof-of-work as described by the Nano cryptocurrency protocol.
+ *
+ * @param {any[]} data - Array of hashes and minimum thresholds
+ * @returns Promise for proof-of-work attached to original array objects
+ */
+ static async work (data: any[]): Promise<any[]> {
+ return new Promise(async (resolve, reject): Promise<void> => {
+ for (const d of data) {
+ try {
+ d.work = await this.find(d.hash, d.threshold)
+ } catch (err) {
+ reject(err)
+ }
+ }
+ resolve(data)
+ })
+ }
+
+ /**
+ * Finds a nonce that satisfies the Nano proof-of-work requirements.
+ *
+ * @param {string} hashHex - Hexadecimal hash of previous block, or public key for new accounts
+ * @param {number} [threshold=0xfffffff8] - Difficulty of proof-of-work calculation
+ */
+ static async find (hash: string, threshold: number = 0xfffffff8): Promise<string> {
+ return new Promise<string>(resolve => {
+ this.#calculate(hash, resolve, threshold)
+ })
+ }
+
+ // Vertex Shader
+ static #vsSource = `#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;
+}`
+
+ // Fragment shader
+ static #fsSource = `#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
+#define 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 int SIGMA82[192] = int[192](
+ 0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,
+ 28,20,8,16,18,30,26,12,2,24,0,4,22,14,10,6,
+ 22,16,24,0,10,4,30,26,20,28,6,12,14,2,18,8,
+ 14,18,6,2,26,24,22,28,4,12,10,20,8,0,30,16,
+ 18,0,10,14,4,8,20,30,28,2,22,24,12,16,6,26,
+ 4,24,12,20,0,22,16,6,8,26,14,10,30,28,2,18,
+ 24,10,2,30,28,26,8,20,0,14,12,6,18,4,16,22,
+ 26,22,14,28,24,2,6,18,10,0,30,8,16,12,4,20,
+ 12,30,28,18,22,6,0,16,24,4,26,14,2,8,20,10,
+ 20,4,16,8,14,12,2,10,30,22,18,28,6,24,26,0,
+ 0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,
+ 28,20,8,16,18,30,26,12,2,24,0,4,22,14,10,6
+);
+
+// 64-bit unsigned addition within the compression buffer
+// Sets v[a,a+1] += b
+// b0 is the low 32 bits of b, b1 represents the high 32 bits
+void add_uint64 (int a, uint b0, uint b1) {
+ uint o0 = v[a] + b0;
+ uint o1 = v[a + 1] + b1;
+ if (v[a] > 0xFFFFFFFFu - b0) { // did low 32 bits overflow?
+ o1++;
+ }
+ v[a] = o0;
+ v[a + 1] = o1;
+}
+
+// G Mixing function
+void B2B_G (int a, int b, int c, int d, int ix, int iy) {
+ add_uint64(a, v[b], v[b+1]);
+ add_uint64(a, m[ix], m[ix + 1]);
+
+ // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated to the right by 32 bits
+ uint xor0 = v[d] ^ v[a];
+ uint xor1 = v[d + 1] ^ v[a + 1];
+ v[d] = xor1;
+ v[d + 1] = xor0;
+
+ add_uint64(c, v[d], v[d+1]);
+
+ // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 24 bits
+ xor0 = v[b] ^ v[c];
+ xor1 = v[b + 1] ^ v[c + 1];
+ v[b] = (xor0 >> 24) ^ (xor1 << 8);
+ v[b + 1] = (xor1 >> 24) ^ (xor0 << 8);
+
+ add_uint64(a, v[b], v[b+1]);
+ add_uint64(a, m[iy], m[iy + 1]);
+
+ // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated right by 16 bits
+ xor0 = v[d] ^ v[a];
+ xor1 = v[d + 1] ^ v[a + 1];
+ v[d] = (xor0 >> 16) ^ (xor1 << 16);
+ v[d + 1] = (xor1 >> 16) ^ (xor0 << 16);
+
+ add_uint64(c, v[d], v[d+1]);
+
+ // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 63 bits
+ xor0 = v[b] ^ v[c];
+ xor1 = v[b + 1] ^ v[c + 1];
+ v[b] = (xor1 >> 31) ^ (xor0 << 1);
+ v[b + 1] = (xor0 >> 31) ^ (xor1 << 1);
+}
+
+void main() {
+ int i;
+ uvec4 u_work0 = work[0];
+ uvec4 u_work1 = work[1];
+ 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[0] = (x_pos ^ (y_pos << 8) ^ ((u_work0.b ^ x_index) << 16) ^ ((u_work0.a ^ y_index) << 24));
+
+ // Remaining bytes are un-modified from the random generated value
+ m[1] = (u_work1.r ^ (u_work1.g << 8) ^ (u_work1.b << 16) ^ (u_work1.a << 24));
+
+ // Block hash
+ for (i=0;i<8;i++) {
+ m[i+2] = blockhash[i];
+ }
+
+ // twelve rounds of mixing
+ for(i=0;i<12;i++) {
+ B2B_G(0, 8, 16, 24, SIGMA82[i * 16 + 0], SIGMA82[i * 16 + 1]);
+ B2B_G(2, 10, 18, 26, SIGMA82[i * 16 + 2], SIGMA82[i * 16 + 3]);
+ B2B_G(4, 12, 20, 28, SIGMA82[i * 16 + 4], SIGMA82[i * 16 + 5]);
+ B2B_G(6, 14, 22, 30, SIGMA82[i * 16 + 6], SIGMA82[i * 16 + 7]);
+ B2B_G(0, 10, 20, 30, SIGMA82[i * 16 + 8], SIGMA82[i * 16 + 9]);
+ B2B_G(2, 12, 22, 24, SIGMA82[i * 16 + 10], SIGMA82[i * 16 + 11]);
+ B2B_G(4, 14, 16, 26, SIGMA82[i * 16 + 12], SIGMA82[i * 16 + 13]);
+ B2B_G(6, 8, 18, 28, SIGMA82[i * 16 + 14], SIGMA82[i * 16 + 15]);
+ }
+
+ // 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[1] ^ v[17]) > threshold) {
+ fragColor = vec4(
+ float(x_index + 1u)/255., // +1 to distinguish from 0 (unsuccessful) pixels
+ float(y_index + 1u)/255., // Same as previous
+ float(x_pos)/255., // Return the 2 custom bytes used in work value
+ float(y_pos)/255. // Second custom byte
+ );
+ } else {
+ discard;
+ }
+}`
+
+ /** Used to set canvas size. Must be a multiple of 256. */
+ static #WORKLOAD: number = 256 * Math.max(1, Math.floor(navigator.hardwareConcurrency))
+
+ static #hexify (arr: number[] | Uint8Array): string {
+ let out = ''
+ for (let i = arr.length - 1; i >= 0; i--) {
+ out += arr[i].toString(16).padStart(2, '0')
+ }
+ return out
+ }
+
+ static #gl: WebGL2RenderingContext | null
+ static #program: WebGLProgram | null
+ static #vertexShader: WebGLShader | null
+ static #fragmentShader: WebGLShader | null
+ static #positionBuffer: WebGLBuffer | null
+ static #uvBuffer: WebGLBuffer | null
+ static #uboBuffer: WebGLBuffer | null
+ static #workBuffer: WebGLBuffer | null
+ static #query: WebGLQuery | null
+ static #pixels: Uint8Array
+ // 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 {
+ 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, this.#vsSource)
+ 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, this.#fsSource)
+ 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 #calculate (hashHex: string, callback: (nonce: string | PromiseLike<string>) => any, threshold: number): void {
+ if (Pow.#gl == null) throw new Error('WebGL 2 is required')
+ if (!/^[A-F-a-f0-9]{64}$/.test(hashHex)) throw new Error(`invalid_hash ${hashHex}`)
+ 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 = hashHex.slice(i, i + 8)
+ uboView.setUint32(i * 2, parseInt(uint32, 16))
+ }
+ uboView.setUint32(128, threshold, true)
+ uboView.setFloat32(132, Pow.#WORKLOAD - 1, true)
+ Pow.#gl.bindBuffer(Pow.#gl.UNIFORM_BUFFER, Pow.#uboBuffer)
+ Pow.#gl.bufferSubData(Pow.#gl.UNIFORM_BUFFER, 0, uboView)
+ Pow.#gl.bindBuffer(Pow.#gl.UNIFORM_BUFFER, null)
+
+ // Draw output until success or progressCallback says to stop
+ const work = new Uint8Array(8)
+ const draw = (): void => {
+ if (Pow.#gl == null) throw new Error('WebGL 2 is required')
+ if (Pow.#query == null) throw new Error('WebGL 2 is required to run queries')
+ Pow.#gl.clear(Pow.#gl.COLOR_BUFFER_BIT)
+
+ // Upload work buffer
+ crypto.getRandomValues(work)
+ Pow.#gl.bindBuffer(Pow.#gl.UNIFORM_BUFFER, Pow.#workBuffer)
+ Pow.#gl.bufferSubData(Pow.#gl.UNIFORM_BUFFER, 0, Uint32Array.from(work))
+ Pow.#gl.bindBuffer(Pow.#gl.UNIFORM_BUFFER, null)
+
+ Pow.#gl.beginQuery(Pow.#gl.ANY_SAMPLES_PASSED_CONSERVATIVE, Pow.#query)
+ Pow.#gl.drawArrays(Pow.#gl.TRIANGLES, 0, 6)
+ Pow.#gl.endQuery(Pow.#gl.ANY_SAMPLES_PASSED_CONSERVATIVE)
+
+ requestAnimationFrame(checkQueryResult)
+ }
+
+ function checkQueryResult () {
+ if (Pow.#gl == null) throw new Error('WebGL 2 is required to check query results')
+ if (Pow.#query == null) throw new Error('Query not found')
+ if (Pow.#gl.getQueryParameter(Pow.#query, Pow.#gl.QUERY_RESULT_AVAILABLE)) {
+ const anySamplesPassed = Pow.#gl.getQueryParameter(Pow.#query, Pow.#gl.QUERY_RESULT)
+ if (anySamplesPassed) {
+ // A valid nonce was found
+ readBackResult()
+ } else {
+ // No valid nonce found, start the next draw call
+ requestAnimationFrame(draw)
+ }
+ } else {
+ // Query result not yet available, check again in the next frame
+ requestAnimationFrame(checkQueryResult)
+ }
+ }
+ function readBackResult () {
+ if (Pow.#gl == null) throw new Error('WebGL 2 is required to check read results')
+ Pow.#gl.readPixels(0, 0, Pow.#gl.drawingBufferWidth, Pow.#gl.drawingBufferHeight, Pow.#gl.RGBA, Pow.#gl.UNSIGNED_BYTE, Pow.#pixels)
+ // Check the pixels for any success
+ for (let i = 0; i < Pow.#pixels.length; i += 4) {
+ if (Pow.#pixels[i] !== 0) {
+ const hex = Pow.#hexify(work.subarray(4, 8)) + Pow.#hexify([
+ Pow.#pixels[i + 2],
+ Pow.#pixels[i + 3],
+ work[2] ^ (Pow.#pixels[i] - 1),
+ work[3] ^ (Pow.#pixels[i + 1] - 1)
+ ])
+ // Return the work value with the custom bits
+ typeof callback === 'function' && callback(hex)
+ return
+ }
+ }
+ }
+ draw()
+ }
+}
+
+export default `
+ const WorkerInterface = ${WorkerInterface}
+ const Pow = ${Pow}
+`
// SPDX-License-Identifier: GPL-3.0-or-later
import { Account } from './lib/account.js'
+import { Blake2b } from './lib/blake2b.js'
import { SendBlock, ReceiveBlock, ChangeBlock } from './lib/block.js'
+import { Pow } from './lib/workers/powgl.js'
import { Rpc } from './lib/rpc.js'
import { Rolodex } from './lib/rolodex.js'
import { Safe } from './lib/safe.js'
-import Tools from './lib/tools.js'
+import { Tools } from './lib/tools.js'
import { Bip44Wallet, Blake2bWallet, LedgerWallet } from './lib/wallet.js'
-export { Account, SendBlock, ReceiveBlock, ChangeBlock, Rpc, Rolodex, Safe, Tools, Bip44Wallet, Blake2bWallet, LedgerWallet }
+export { Account, Blake2b, SendBlock, ReceiveBlock, ChangeBlock, Pow, Rpc, Rolodex, Safe, Tools, Bip44Wallet, Blake2bWallet, LedgerWallet }
--- /dev/null
+<!DOCTYPE html>
+
+<head>
+ <link rel="icon" href="./favicon.ico">
+ <script type="module" src="./dist/test.min.js"></script>
+ <style>body{background:black;}</style>
+</head>
+
+<body></body>
+
+</html>
+++ /dev/null
-// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-if (globalThis.sessionStorage == null) {
- const _sessionStorage = {}
- Object.defineProperty(globalThis, 'sessionStorage', {
- value: {
- length: Object.entries(_sessionStorage).length,
- setItem: (key, value) => _sessionStorage[key] = value,
- getItem: (key) => _sessionStorage[key],
- removeItem: (key) => delete _sessionStorage[key],
- clear: () => _sessionStorage = {}
- },
- configurable: true,
- enumerable: true
- })
-}
* Do not send any funds to the test vectors below!
*
* Sources:
-* https://docs.nano.org/integration-guides/key-management/
+* https://docs.nano.org/integration-guides/key-management/#test-vectors
+* https://docs.nano.org/integration-guides/key-management/#creating-transactions
* https://github.com/trezor/python-mnemonic/blob/master/vectors.json
* https://tools.nanos.cc/?tool=seed
*/
PRIVATE_2: '1257DF74609B9C6461A3F4E7FD6E3278F2DDCF2562694F2C3AA0515AF4F09E38',
PUBLIC_2: 'A46DA51986E25A14D82E32D765DCEE69B9EECCD4405411430D91DDB61B717566',
- ADDRESS_2: 'nano_3b5fnnerfrkt4me4wepqeqggwtfsxu8fai4n473iu6gxprfq4xd8pk9gh1dg'
+ ADDRESS_2: 'nano_3b5fnnerfrkt4me4wepqeqggwtfsxu8fai4n473iu6gxprfq4xd8pk9gh1dg',
+
+ SEND_BLOCK: {
+ account: "nano_1e5aqegc1jb7qe964u4adzmcezyo6o146zb8hm6dft8tkp79za3sxwjym5rx",
+ previous: "92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D",
+ representative: "nano_1stofnrxuz3cai7ze75o174bpm7scwj9jn3nxsn8ntzg784jf1gzn1jjdkou",
+ balance: "11618869000000000000000000000000",
+ link: "nano_1q3hqecaw15cjt7thbtxu3pbzr1eihtzzpzxguoc37bj1wc5ffoh7w74gi6p",
+ hash: "BB569136FA05F8CBF65CEF2EDE368475B289C4477342976556BA4C0DDF216E45",
+ key: "781186FB9EF17DB6E3D1056550D9FAE5D5BBADA6A6BC370E4CBB938B1DC71DA3",
+ signature: "74BCC59DBA39A1E34A5F75F96D6DE9154E3477AAD7DE30EA563DFCFE501A804228008F98DDF4A15FD35705102785C50EF76732C3A74B0FEC5B0DD67B574A5900",
+ work: "fbffed7c73b61367"
+ },
+ RECEIVE_BLOCK: {
+ account: "nano_1e5aqegc1jb7qe964u4adzmcezyo6o146zb8hm6dft8tkp79za3sxwjym5rx",
+ previous: "92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D",
+ representative: "nano_1stofnrxuz3cai7ze75o174bpm7scwj9jn3nxsn8ntzg784jf1gzn1jjdkou",
+ balance: "11618869000000000000000000000000",
+ link: "CBC911F57B6827649423C92C88C0C56637A4274FF019E77E24D61D12B5338783",
+ hash: "350D145570578A36D3D5ADE58DC7465F4CAAF257DD55BD93055FF826057E2CDD",
+ key: "781186FB9EF17DB6E3D1056550D9FAE5D5BBADA6A6BC370E4CBB938B1DC71DA3",
+ signature: "EEFFE1EFCCC8F2F6F2F1B79B80ABE855939DD9D6341323186494ADEE775DAADB3B6A6A07A85511F2185F6E739C4A54F1454436E22255A542ED879FD04FEED001",
+ work: "c5cf86de24b24419"
+ },
+ OPEN_BLOCK: {
+ account: "nano_1rawdji18mmcu9psd6h87qath4ta7iqfy8i4rqi89sfdwtbcxn57jm9k3q11",
+ previous: "0000000000000000000000000000000000000000000000000000000000000000",
+ representative: "nano_1stofnrxuz3cai7ze75o174bpm7scwj9jn3nxsn8ntzg784jf1gzn1jjdkou",
+ balance: "100",
+ link: "5B2DA492506339C0459867AA1DA1E7EDAAC4344342FAB0848F43B46D248C8E99",
+ hash: "ED3BE5340CC9D62964B5A5F84375A06078CBEDC45FB5FA2926985D6E27D803BB",
+ key: "0ED82E6990A16E7AD2375AB5D54BEAABF6C676D09BEC74D9295FCAE35439F694",
+ signature: "C4C1D0E25E9E1118F0E139704E9001FF54BDABAB4C3A59DE24510E5B48F269ACBC2F3393DFA46B390CA9C6831074829D91E694B81E8C0C2C9C4FA49A757ECB03",
+ work: "08d09dc3405d9441"
+ }
})
-/**
-* Source: https://github.com/trezor/python-mnemonic/blob/master/vectors.json
-* BLAKE2b keys calculated with Nano KeyTools: https://tools.nanos.cc/?tool=seed
-*/
export const TREZOR_TEST_VECTORS = Object.freeze({
PASSWORD: 'TREZOR',
--- /dev/null
+// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>\r
+// SPDX-License-Identifier: GPL-3.0-or-later\r
+\r
+'use strict'\r
+\r
+import { assert, suite, test } from '#GLOBALS.mjs'\r
+import { NANO_TEST_VECTORS } from '#test/TEST_VECTORS.js'\r
+import { SendBlock, Blake2b } from '#dist/main.js'\r
+\r
+await suite('Calculate proof-of-work', async () => {\r
+\r
+ await test('SendBlock PoW', async () => {\r
+ const block = new SendBlock(\r
+ NANO_TEST_VECTORS.SEND_BLOCK.account,\r
+ NANO_TEST_VECTORS.SEND_BLOCK.balance,\r
+ NANO_TEST_VECTORS.SEND_BLOCK.link,\r
+ '0',\r
+ NANO_TEST_VECTORS.SEND_BLOCK.representative,\r
+ NANO_TEST_VECTORS.SEND_BLOCK.previous\r
+ )\r
+ await block.pow()\r
+ assert.equals(block.previous.length, 64)\r
+ assert.equals(block.work?.length, 16)\r
+\r
+ const work = block.work\r
+ ?.match(/.{2}/g)\r
+ ?.map(hex => parseInt(hex, 16))\r
+ .reverse()\r
+ if (work == null) throw new Error('Work invalid')\r
+ const previous = block.previous\r
+ ?.match(/.{2}/g)\r
+ ?.map(hex => parseInt(hex, 16))\r
+ if (previous == null) throw new Error('Previous block hash invalid')\r
+\r
+ const bytes = new Uint8Array([...work, ...previous])\r
+ assert.equals(bytes.byteLength, 40)\r
+\r
+ const hash = new Blake2b(8)\r
+ .update(bytes)\r
+ .digest('hex')\r
+ .slice(8, 16)\r
+ assert.ok(parseInt(hash.slice(0, 2), 16) > 0xf0)\r
+ assert.equals(parseInt(hash.slice(2, 8), 16), 0xffffff)\r
+ })\r
+})\r
\r
'use strict'\r
\r
-import './GLOBALS.mjs'\r
-import { describe, it } from 'node:test'\r
-import { strict as assert } from 'assert'\r
-import { NANO_TEST_VECTORS } from './TEST_VECTORS.js'\r
-import { Bip44Wallet, Blake2bWallet, LedgerWallet } from '../dist/main.js'\r
-\r
-describe('creating a new wallet', async () => {\r
- it('BIP-44 wallet with random entropy', async () => {\r
+import { assert, skip, suite, test } from '#GLOBALS.mjs'\r
+import { NANO_TEST_VECTORS } from '#test/TEST_VECTORS.js'\r
+import { Bip44Wallet, Blake2bWallet, LedgerWallet } from '#dist/main.js'\r
+\r
+await suite('Create wallets', async () => {\r
+ await test('BIP-44 wallet with random entropy', async () => {\r
const wallet = await Bip44Wallet.create(NANO_TEST_VECTORS.PASSWORD)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
\r
assert.ok(/[A-Fa-f0-9]{32,64}/.test(wallet.seed))\r
})\r
\r
- it('BLAKE2b wallet with random entropy', async () => {\r
+ await test('BLAKE2b wallet with random entropy', async () => {\r
const wallet = await Blake2bWallet.create(NANO_TEST_VECTORS.PASSWORD)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
\r
assert.ok(/[A-Fa-f0-9]{32,64}/.test(wallet.seed))\r
})\r
\r
- it('BIP-44 replace invalid salt with empty string', async () => {\r
+ await test('BIP-44 replace invalid salt with empty string', async () => {\r
const invalidArgs = [null, true, false, 0, 1, 2, { "foo": "bar" }]\r
for (const arg of invalidArgs) {\r
- await assert.doesNotReject(Bip44Wallet.create(NANO_TEST_VECTORS.PASSWORD, arg), `Rejected ${arg}`)\r
+ //@ts-expect-error\r
+ await assert.resolves(Bip44Wallet.create(NANO_TEST_VECTORS.PASSWORD, arg))\r
}\r
})\r
\r
- it('fail when using new', async () => {\r
+ await test('fail when using new', async () => {\r
+ //@ts-expect-error\r
assert.throws(() => new Bip44Wallet())\r
+ //@ts-expect-error\r
assert.throws(() => new Blake2bWallet())\r
+ //@ts-expect-error\r
assert.throws(() => new LedgerWallet())\r
})\r
\r
- it('fail without a password', async () => {\r
+ await test('fail without a password', async () => {\r
+ //@ts-expect-error\r
await assert.rejects(Bip44Wallet.create())\r
+ //@ts-expect-error\r
await assert.rejects(Blake2bWallet.create())\r
})\r
+})\r
\r
- it('connect to ledger', { skip: true }, async () => {\r
- const wallet = await LedgerWallet.create()\r
- assert.ok(wallet)\r
- })\r
+await skip('connect to ledger', async () => {\r
+ const wallet = await LedgerWallet.create()\r
+ assert.ok(wallet)\r
})\r
\r
'use strict'\r
\r
-import './GLOBALS.mjs'\r
-import { describe, it } from 'node:test'\r
-import { strict as assert } from 'assert'\r
-import { NANO_TEST_VECTORS } from './TEST_VECTORS.js'\r
-import { Bip44Wallet, Blake2bWallet, LedgerWallet } from '../dist/main.js'\r
+import { assert, skip, suite, test } from '#GLOBALS.mjs'\r
+import { NANO_TEST_VECTORS } from '#test/TEST_VECTORS.js'\r
+import { Bip44Wallet, Blake2bWallet, LedgerWallet } from '#dist/main.js'\r
\r
-describe('derive child accounts from the same seed', async () => {\r
- const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)\r
- await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
-\r
- it('should derive the first account from the given BIP-44 seed', async () => {\r
+await suite('Account derivation', async () => {\r
+ await test('should derive the first account from the given BIP-44 seed', async () => {\r
+ const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)\r
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const accounts = await wallet.accounts()\r
\r
- assert.equal(accounts.length, 1)\r
- assert.equal(accounts[0].privateKey, NANO_TEST_VECTORS.PRIVATE_0)\r
- assert.equal(accounts[0].publicKey, NANO_TEST_VECTORS.PUBLIC_0)\r
- assert.equal(accounts[0].address, NANO_TEST_VECTORS.ADDRESS_0)\r
+ assert.equals(accounts.length, 1)\r
+ assert.equals(accounts[0].privateKey, NANO_TEST_VECTORS.PRIVATE_0)\r
+ assert.equals(accounts[0].publicKey, NANO_TEST_VECTORS.PUBLIC_0)\r
+ assert.equals(accounts[0].address, NANO_TEST_VECTORS.ADDRESS_0)\r
})\r
\r
- it('should derive low indexed accounts from the given BIP-44 seed', async () => {\r
+ await test('should derive low indexed accounts from the given BIP-44 seed', async () => {\r
+ const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)\r
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const accounts = await wallet.accounts(1, 2)\r
\r
- assert.equal(accounts.length, 2)\r
- assert.equal(accounts[0].privateKey, NANO_TEST_VECTORS.PRIVATE_1)\r
- assert.equal(accounts[0].publicKey, NANO_TEST_VECTORS.PUBLIC_1)\r
- assert.equal(accounts[0].address, NANO_TEST_VECTORS.ADDRESS_1)\r
- assert.equal(accounts[1].privateKey, NANO_TEST_VECTORS.PRIVATE_2)\r
- assert.equal(accounts[1].publicKey, NANO_TEST_VECTORS.PUBLIC_2)\r
- assert.equal(accounts[1].address, NANO_TEST_VECTORS.ADDRESS_2)\r
+ assert.equals(accounts.length, 2)\r
+ assert.equals(accounts[0].privateKey, NANO_TEST_VECTORS.PRIVATE_1)\r
+ assert.equals(accounts[0].publicKey, NANO_TEST_VECTORS.PUBLIC_1)\r
+ assert.equals(accounts[0].address, NANO_TEST_VECTORS.ADDRESS_1)\r
+ assert.equals(accounts[1].privateKey, NANO_TEST_VECTORS.PRIVATE_2)\r
+ assert.equals(accounts[1].publicKey, NANO_TEST_VECTORS.PUBLIC_2)\r
+ assert.equals(accounts[1].address, NANO_TEST_VECTORS.ADDRESS_2)\r
})\r
\r
- it('should derive high indexed accounts from the given seed', async () => {\r
+ await test('should derive high indexed accounts from the given seed', async () => {\r
+ const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)\r
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const accounts = await wallet.accounts(0x70000000, 0x700000ff)\r
\r
- assert.equal(accounts.length, 0x100)\r
- for (const a of accounts) {\r
- assert.ok(a)\r
- assert.ok(a.address)\r
- assert.ok(a.publicKey)\r
- assert.ok(a.privateKey)\r
- assert.ok(a.index != null)\r
+ assert.equals(accounts.length, 0x100)\r
+ for (let i = 0; i < accounts.length; i++) {\r
+ const a = accounts[i]\r
+ assert.exists(a)\r
+ assert.exists(a.address)\r
+ assert.exists(a.publicKey)\r
+ assert.exists(a.privateKey)\r
+ assert.exists(a.index)\r
+ assert.equals(a.index, i + 0x70000000)\r
}\r
})\r
\r
- it('should derive accounts for a BLAKE2b wallet', async () => {\r
- const bwallet = await Blake2bWallet.create(NANO_TEST_VECTORS.PASSWORD)\r
- await bwallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
- const lowAccounts = await bwallet.accounts(0, 2)\r
+ await test('should derive accounts for a BLAKE2b wallet', async () => {\r
+ const wallet = await Blake2bWallet.create(NANO_TEST_VECTORS.PASSWORD)\r
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
+ const lowAccounts = await wallet.accounts(0, 2)\r
\r
- assert.equal(lowAccounts.length, 3)\r
+ assert.equals(lowAccounts.length, 3)\r
for (const a of lowAccounts) {\r
- assert.ok(a)\r
- assert.ok(a.address)\r
- assert.ok(a.publicKey)\r
- assert.ok(a.privateKey)\r
- assert.ok(a.index != null)\r
+ assert.exists(a)\r
+ assert.exists(a.address)\r
+ assert.exists(a.publicKey)\r
+ assert.exists(a.privateKey)\r
+ assert.exists(a.index)\r
}\r
\r
- const highAccounts = await bwallet.accounts(0x70000000, 0x700000ff)\r
+ const highAccounts = await wallet.accounts(0x70000000, 0x700000ff)\r
\r
- assert.equal(highAccounts.length, 0x100)\r
+ assert.equals(highAccounts.length, 0x100)\r
for (const a of highAccounts) {\r
- assert.ok(a)\r
- assert.ok(a.address)\r
- assert.ok(a.publicKey)\r
- assert.ok(a.privateKey)\r
- assert.ok(a.index != null)\r
+ assert.exists(a)\r
+ assert.exists(a.address)\r
+ assert.exists(a.publicKey)\r
+ assert.exists(a.privateKey)\r
+ assert.exists(a.index)\r
}\r
})\r
-})\r
-\r
-describe('Ledger device accounts', { skip: true }, async () => {\r
- const wallet = await LedgerWallet.create()\r
\r
- it('should fetch the first account from a Ledger device', async () => {\r
+ await skip('fetch the first account from a Ledger device', async () => {\r
+ const wallet = await LedgerWallet.create()\r
const accounts = await wallet.accounts()\r
\r
- assert.equal(accounts.length, 1)\r
- assert.ok(accounts[0].publicKey)\r
- assert.ok(accounts[0].address)\r
- })\r
-})\r
-\r
-describe('child key derivation performance', { skip: true }, async () => {\r
- it('performance test of BIP-44 ckd', async () => {\r
- const wallet = await Bip44Wallet.create(NANO_TEST_VECTORS.PASSWORD)\r
- await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
-\r
- const accounts = await wallet.accounts(0, 0x7fff)\r
-\r
- assert.equal(accounts.length, 0x8000)\r
- })\r
-\r
- it('performance test of BLAKE2b ckd', async () => {\r
- const wallet = await Blake2bWallet.create(NANO_TEST_VECTORS.PASSWORD)\r
- await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
-\r
- const accounts = await wallet.accounts(0, 0x7fff)\r
-\r
- assert.equal(accounts.length, 0x8000)\r
+ assert.equals(accounts.length, 1)\r
+ assert.exists(accounts[0].publicKey)\r
+ assert.exists(accounts[0].address)\r
})\r
})\r
\r
'use strict'\r
\r
-import './GLOBALS.mjs'\r
-import { describe, it } from 'node:test'\r
-import { strict as assert } from 'assert'\r
-import { BIP32_TEST_VECTORS, CUSTOM_TEST_VECTORS, NANO_TEST_VECTORS, TREZOR_TEST_VECTORS } from './TEST_VECTORS.js'\r
-import { Account, Bip44Wallet, Blake2bWallet } from '../dist/main.js'\r
-\r
-describe('import wallet with test vectors test', () => {\r
- it('should successfully import a wallet with the official Nano test vectors mnemonic', async () => {\r
+import { assert, suite, test } from '#GLOBALS.mjs'\r
+import { BIP32_TEST_VECTORS, CUSTOM_TEST_VECTORS, NANO_TEST_VECTORS, TREZOR_TEST_VECTORS } from '#test/TEST_VECTORS.js'\r
+import { Account, Bip44Wallet, Blake2bWallet } from '#dist/main.js'\r
+\r
+await suite('Import wallets', async () => {\r
+ await test('nano.org BIP-44 test vector mnemonic', async () => {\r
const wallet = await Bip44Wallet.fromMnemonic(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.MNEMONIC, NANO_TEST_VECTORS.PASSWORD)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const accounts = await wallet.accounts()\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
assert.ok(accounts[0] instanceof Account)\r
- assert.equal(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
- assert.equal(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
- assert.equal(accounts[0].privateKey, NANO_TEST_VECTORS.PRIVATE_0)\r
- assert.equal(accounts[0].publicKey, NANO_TEST_VECTORS.PUBLIC_0)\r
- assert.equal(accounts[0].address, NANO_TEST_VECTORS.ADDRESS_0)\r
+ assert.equals(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
+ assert.equals(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
+ assert.equals(accounts[0].privateKey, NANO_TEST_VECTORS.PRIVATE_0)\r
+ assert.equals(accounts[0].publicKey, NANO_TEST_VECTORS.PUBLIC_0)\r
+ assert.equals(accounts[0].address, NANO_TEST_VECTORS.ADDRESS_0)\r
})\r
\r
- it('should successfully import a wallet with the checksum starting with a zero', async () => {\r
- const wallet = await Bip44Wallet.fromMnemonic(NANO_TEST_VECTORS.PASSWORD, 'food define cancel major spoon trash cigar basic aim bless wolf win ability seek paddle bench seed century group they mercy address monkey cake')\r
+ await test('nano.org BIP-44 test vector seed with no mnemonic', async () => {\r
+ const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
- assert.equal(wallet.seed, 'F665F804E5907985455D1E5A7AD344843A2ED4179A7E06EEF263DE925FF6F4C0991B0A9344FCEE939FE0F1B1841B8C9B20FEACF6B954B74B2D26A01906B758E2')\r
+ const accounts = await wallet.accounts()\r
+\r
+ assert.ok('mnemonic' in wallet)\r
+ assert.ok('seed' in wallet)\r
+ assert.ok(accounts[0] instanceof Account)\r
+ assert.equals(wallet.mnemonic, '')\r
+ assert.equals(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
+ assert.equals(accounts[0].privateKey, NANO_TEST_VECTORS.PRIVATE_0)\r
+ assert.equals(accounts[0].publicKey, NANO_TEST_VECTORS.PUBLIC_0)\r
+ assert.equals(accounts[0].address, NANO_TEST_VECTORS.ADDRESS_0)\r
})\r
\r
- it('should successfully import a wallet with a 12-word phrase', async () => {\r
+ await test('Trezor-derived BIP-44 entropy for 12-word mnemonic', async () => {\r
const wallet = await Bip44Wallet.fromEntropy(NANO_TEST_VECTORS.PASSWORD, CUSTOM_TEST_VECTORS.ENTROPY_0)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const accounts = await wallet.accounts()\r
const account = accounts[0]\r
\r
- assert.equal(wallet.mnemonic, CUSTOM_TEST_VECTORS.MNEMONIC_0)\r
- assert.equal(wallet.seed, CUSTOM_TEST_VECTORS.SEED_0)\r
- assert.equal(account.privateKey, CUSTOM_TEST_VECTORS.PRIVATE_0)\r
- assert.equal(account.publicKey, CUSTOM_TEST_VECTORS.PUBLIC_0)\r
- assert.equal(account.address, CUSTOM_TEST_VECTORS.ADDRESS_0)\r
+ assert.equals(wallet.mnemonic, CUSTOM_TEST_VECTORS.MNEMONIC_0)\r
+ assert.equals(wallet.seed, CUSTOM_TEST_VECTORS.SEED_0)\r
+ assert.equals(account.privateKey, CUSTOM_TEST_VECTORS.PRIVATE_0)\r
+ assert.equals(account.publicKey, CUSTOM_TEST_VECTORS.PUBLIC_0)\r
+ assert.equals(account.address, CUSTOM_TEST_VECTORS.ADDRESS_0)\r
})\r
\r
- it('should successfully import a wallet with a 15-word phrase', async () => {\r
+ await test('Trezor-derived BIP-44 entropy for 15-word mnemonic', async () => {\r
const wallet = await Bip44Wallet.fromEntropy(NANO_TEST_VECTORS.PASSWORD, CUSTOM_TEST_VECTORS.ENTROPY_1)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const accounts = await wallet.accounts()\r
const account = accounts[0]\r
\r
- assert.equal(wallet.mnemonic, CUSTOM_TEST_VECTORS.MNEMONIC_1)\r
- assert.equal(wallet.seed, CUSTOM_TEST_VECTORS.SEED_1)\r
- assert.equal(account.privateKey, CUSTOM_TEST_VECTORS.PRIVATE_1)\r
- assert.equal(account.publicKey, CUSTOM_TEST_VECTORS.PUBLIC_1)\r
- assert.equal(account.address, CUSTOM_TEST_VECTORS.ADDRESS_1)\r
+ assert.equals(wallet.mnemonic, CUSTOM_TEST_VECTORS.MNEMONIC_1)\r
+ assert.equals(wallet.seed, CUSTOM_TEST_VECTORS.SEED_1)\r
+ assert.equals(account.privateKey, CUSTOM_TEST_VECTORS.PRIVATE_1)\r
+ assert.equals(account.publicKey, CUSTOM_TEST_VECTORS.PUBLIC_1)\r
+ assert.equals(account.address, CUSTOM_TEST_VECTORS.ADDRESS_1)\r
})\r
\r
- it('should successfully import a wallet with a 18-word phrase', async () => {\r
+ await test('Trezor-derived BIP-44 entropy for 18-word mnemonic', async () => {\r
const wallet = await Bip44Wallet.fromEntropy(NANO_TEST_VECTORS.PASSWORD, CUSTOM_TEST_VECTORS.ENTROPY_2)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const accounts = await wallet.accounts()\r
const account = accounts[0]\r
\r
- assert.equal(wallet.mnemonic, CUSTOM_TEST_VECTORS.MNEMONIC_2)\r
- assert.equal(wallet.seed, CUSTOM_TEST_VECTORS.SEED_2)\r
- assert.equal(account.privateKey, CUSTOM_TEST_VECTORS.PRIVATE_2)\r
- assert.equal(account.publicKey, CUSTOM_TEST_VECTORS.PUBLIC_2)\r
- assert.equal(account.address, CUSTOM_TEST_VECTORS.ADDRESS_2)\r
+ assert.equals(wallet.mnemonic, CUSTOM_TEST_VECTORS.MNEMONIC_2)\r
+ assert.equals(wallet.seed, CUSTOM_TEST_VECTORS.SEED_2)\r
+ assert.equals(account.privateKey, CUSTOM_TEST_VECTORS.PRIVATE_2)\r
+ assert.equals(account.publicKey, CUSTOM_TEST_VECTORS.PUBLIC_2)\r
+ assert.equals(account.address, CUSTOM_TEST_VECTORS.ADDRESS_2)\r
})\r
\r
- it('should successfully import a wallet with a 21-word phrase', async () => {\r
+ await test('Trezor-derived BIP-44 entropy for 21-word mnemonic', async () => {\r
const wallet = await Bip44Wallet.fromEntropy(NANO_TEST_VECTORS.PASSWORD, CUSTOM_TEST_VECTORS.ENTROPY_3)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const accounts = await wallet.accounts()\r
const account = accounts[0]\r
\r
- assert.equal(wallet.mnemonic, CUSTOM_TEST_VECTORS.MNEMONIC_3)\r
- assert.equal(wallet.seed, CUSTOM_TEST_VECTORS.SEED_3)\r
- assert.equal(account.privateKey, CUSTOM_TEST_VECTORS.PRIVATE_3)\r
- assert.equal(account.publicKey, CUSTOM_TEST_VECTORS.PUBLIC_3)\r
- assert.equal(account.address, CUSTOM_TEST_VECTORS.ADDRESS_3)\r
- })\r
-\r
- it('should successfully import a wallet with the official Nano test vectors seed', async () => {\r
- const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)\r
- await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
- const accounts = await wallet.accounts()\r
-\r
- assert.ok('mnemonic' in wallet)\r
- assert.ok('seed' in wallet)\r
- assert.ok(accounts[0] instanceof Account)\r
- assert.equal(wallet.mnemonic, '')\r
- assert.equal(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
- assert.equal(accounts[0].privateKey, NANO_TEST_VECTORS.PRIVATE_0)\r
- assert.equal(accounts[0].publicKey, NANO_TEST_VECTORS.PUBLIC_0)\r
- assert.equal(accounts[0].address, NANO_TEST_VECTORS.ADDRESS_0)\r
+ assert.equals(wallet.mnemonic, CUSTOM_TEST_VECTORS.MNEMONIC_3)\r
+ assert.equals(wallet.seed, CUSTOM_TEST_VECTORS.SEED_3)\r
+ assert.equals(account.privateKey, CUSTOM_TEST_VECTORS.PRIVATE_3)\r
+ assert.equals(account.publicKey, CUSTOM_TEST_VECTORS.PUBLIC_3)\r
+ assert.equals(account.address, CUSTOM_TEST_VECTORS.ADDRESS_3)\r
})\r
\r
- it('should successfully import a BIP-44 wallet with the zero seed', async () => {\r
+ await test('BIP-44 zero-string entropy', async () => {\r
const wallet = await Bip44Wallet.fromEntropy(NANO_TEST_VECTORS.PASSWORD, TREZOR_TEST_VECTORS.ENTROPY_0, TREZOR_TEST_VECTORS.PASSWORD)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const accounts = await wallet.accounts(0, 3)\r
\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equal(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_0)\r
- assert.equal(wallet.seed, TREZOR_TEST_VECTORS.SEED_0.toUpperCase())\r
- assert.equal(accounts.length, 4)\r
+ assert.equals(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_0)\r
+ assert.equals(wallet.seed, TREZOR_TEST_VECTORS.SEED_0.toUpperCase())\r
+ assert.equals(accounts.length, 4)\r
for (let i = 0; i < accounts.length; i++) {\r
- assert.ok(accounts[i])\r
- assert.ok(accounts[i].address)\r
- assert.ok(accounts[i].publicKey)\r
- assert.ok(accounts[i].privateKey)\r
- assert.equal(accounts[i].index, i)\r
+ assert.exists(accounts[i])\r
+ assert.exists(accounts[i].address)\r
+ assert.exists(accounts[i].publicKey)\r
+ assert.exists(accounts[i].privateKey)\r
+ assert.equals(accounts[i].index, i)\r
}\r
})\r
\r
- it('should successfully import a BLAKE2b wallet with the zero seed', async () => {\r
+ await test('BLAKE2b zero-string seed', async () => {\r
const wallet = await Blake2bWallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, TREZOR_TEST_VECTORS.ENTROPY_0)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const accounts = await wallet.accounts(0, 3)\r
\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equal(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_0)\r
- assert.equal(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_0)\r
- assert.equal(accounts.length, 4)\r
+ assert.equals(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_0)\r
+ assert.equals(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_0)\r
+ assert.equals(accounts.length, 4)\r
+\r
for (let i = 0; i < accounts.length; i++) {\r
- assert.ok(accounts[i])\r
- assert.ok(accounts[i].address)\r
- assert.ok(accounts[i].publicKey)\r
- assert.ok(accounts[i].privateKey)\r
- assert.equal(accounts[i].index, i)\r
+ assert.exists(accounts[i])\r
+ assert.exists(accounts[i].address)\r
+ assert.exists(accounts[i].publicKey)\r
+ assert.exists(accounts[i].privateKey)\r
+ assert.equals(accounts[i].index, i)\r
}\r
})\r
\r
- it('should successfully import a BLAKE2b wallet with Trezor test vectors', async () => {\r
+ await test('Trezor-derived BLAKE2b test vectors verified with third-party libraries', async () => {\r
const wallet = await Blake2bWallet.fromMnemonic(NANO_TEST_VECTORS.PASSWORD, TREZOR_TEST_VECTORS.MNEMONIC_1)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const accounts = await wallet.accounts(0, 1)\r
\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equal(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_1)\r
- assert.equal(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_1)\r
+ assert.equals(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_1)\r
+ assert.equals(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_1)\r
assert.ok(accounts[0] instanceof Account)\r
- assert.equal(accounts[0].index, 0)\r
- assert.equal(accounts[0].privateKey, TREZOR_TEST_VECTORS.BLAKE2B_1_PRIVATE_0)\r
- assert.equal(accounts[0].publicKey, TREZOR_TEST_VECTORS.BLAKE2B_1_PUBLIC_0)\r
- assert.equal(accounts[0].address, TREZOR_TEST_VECTORS.BLAKE2B_1_ADDRESS_0)\r
+ assert.equals(accounts[0].index, 0)\r
+ assert.equals(accounts[0].privateKey, TREZOR_TEST_VECTORS.BLAKE2B_1_PRIVATE_0)\r
+ assert.equals(accounts[0].publicKey, TREZOR_TEST_VECTORS.BLAKE2B_1_PUBLIC_0)\r
+ assert.equals(accounts[0].address, TREZOR_TEST_VECTORS.BLAKE2B_1_ADDRESS_0)\r
assert.ok(accounts[1] instanceof Account)\r
- assert.equal(accounts[1].index, 1)\r
- assert.equal(accounts[1].privateKey, TREZOR_TEST_VECTORS.BLAKE2B_1_PRIVATE_1)\r
- assert.equal(accounts[1].publicKey, TREZOR_TEST_VECTORS.BLAKE2B_1_PUBLIC_1)\r
- assert.equal(accounts[1].address, TREZOR_TEST_VECTORS.BLAKE2B_1_ADDRESS_1)\r
+ assert.equals(accounts[1].index, 1)\r
+ assert.equals(accounts[1].privateKey, TREZOR_TEST_VECTORS.BLAKE2B_1_PRIVATE_1)\r
+ assert.equals(accounts[1].publicKey, TREZOR_TEST_VECTORS.BLAKE2B_1_PUBLIC_1)\r
+ assert.equals(accounts[1].address, TREZOR_TEST_VECTORS.BLAKE2B_1_ADDRESS_1)\r
})\r
\r
- it('should get identical BLAKE2b wallets when created with a seed versus with its derived mnemonic', async () => {\r
+ await test('BLAKE2b seed creates identical wallet as its derived mnemonic', async () => {\r
const wallet = await Blake2bWallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, TREZOR_TEST_VECTORS.ENTROPY_2)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const walletAccounts = await wallet.accounts()\r
\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.ok(walletAccount)\r
- assert.equal(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_2)\r
+ assert.exists(walletAccount)\r
+ assert.equals(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_2)\r
\r
const imported = await Blake2bWallet.fromMnemonic(TREZOR_TEST_VECTORS.PASSWORD, TREZOR_TEST_VECTORS.MNEMONIC_2)\r
await imported.unlock(TREZOR_TEST_VECTORS.PASSWORD)\r
const importedAccounts = await imported.accounts()\r
const importedAccount = importedAccounts[0]\r
\r
- assert.equal(imported.mnemonic, wallet.mnemonic)\r
- assert.equal(imported.seed, wallet.seed)\r
- assert.equal(importedAccount.privateKey, walletAccount.privateKey)\r
- assert.equal(importedAccount.publicKey, walletAccount.publicKey)\r
+ assert.equals(imported.mnemonic, wallet.mnemonic)\r
+ assert.equals(imported.seed, wallet.seed)\r
+ assert.equals(importedAccount.privateKey, walletAccount.privateKey)\r
+ assert.equals(importedAccount.publicKey, walletAccount.publicKey)\r
})\r
\r
- it('should get identical BLAKE2b wallets when created with max entropy value', async () => {\r
+ await test('BLAKE2b mnemonic for maximum seed value', async () => {\r
const wallet = await Blake2bWallet.fromMnemonic(NANO_TEST_VECTORS.PASSWORD, TREZOR_TEST_VECTORS.MNEMONIC_3)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const accounts = await wallet.accounts()\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
assert.ok(accounts[0] instanceof Account)\r
- assert.equal(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_3)\r
- assert.equal(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_3)\r
- assert.equal(accounts[0].index, 0)\r
- assert.equal(accounts[0].privateKey, TREZOR_TEST_VECTORS.BLAKE2B_3_PRIVATE_0)\r
- assert.equal(accounts[0].publicKey, TREZOR_TEST_VECTORS.BLAKE2B_3_PUBLIC_0)\r
- assert.equal(accounts[0].address, TREZOR_TEST_VECTORS.BLAKE2B_3_ADDRESS_0)\r
+ assert.equals(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_3)\r
+ assert.equals(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_3)\r
+ assert.equals(accounts[0].index, 0)\r
+ assert.equals(accounts[0].privateKey, TREZOR_TEST_VECTORS.BLAKE2B_3_PRIVATE_0)\r
+ assert.equals(accounts[0].publicKey, TREZOR_TEST_VECTORS.BLAKE2B_3_PUBLIC_0)\r
+ assert.equals(accounts[0].address, TREZOR_TEST_VECTORS.BLAKE2B_3_ADDRESS_0)\r
})\r
-})\r
\r
-describe('invalid wallet', async () => {\r
- it('throw when given invalid entropy', async () => {\r
- assert.rejects(async () => await Bip44Wallet.fromEntropy(NANO_TEST_VECTORS.PASSWORD, '6CAF5A42BB8074314AAE20295975ECE663BE7AAD945A73613D193B0CC41C797'))\r
- assert.rejects(async () => await Bip44Wallet.fromEntropy(NANO_TEST_VECTORS.PASSWORD, '6CAF5A42BB8074314AAE20295975ECE663BE7AAD945A73613D193B0CC41C79701'))\r
- assert.rejects(async () => await Bip44Wallet.fromEntropy(NANO_TEST_VECTORS.PASSWORD, TREZOR_TEST_VECTORS.ENTROPY_0.replaceAll(/./g, 'x')))\r
+ await test('Reject invalid entropy', async () => {\r
+ await assert.rejects(Bip44Wallet.fromEntropy(NANO_TEST_VECTORS.PASSWORD, '6CAF5A42BB8074314AAE20295975ECE663BE7AAD945A73613D193B0CC41C797'))\r
+ await assert.rejects(Bip44Wallet.fromEntropy(NANO_TEST_VECTORS.PASSWORD, '6CAF5A42BB8074314AAE20295975ECE663BE7AAD945A73613D193B0CC41C79701'))\r
+ await assert.rejects(Bip44Wallet.fromEntropy(NANO_TEST_VECTORS.PASSWORD, TREZOR_TEST_VECTORS.ENTROPY_0.replaceAll(/./g, 'x')))\r
})\r
\r
- it('should throw when given a seed with an invalid length', async () => {\r
+ await test('Reject invalid length seed', async () => {\r
await assert.rejects(Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED + 'f'),\r
- { message: `Expected a ${NANO_TEST_VECTORS.BIP39_SEED.length}-character seed, but received ${NANO_TEST_VECTORS.BIP39_SEED.length + 1}-character string.` })\r
+ `Expected a ${NANO_TEST_VECTORS.BIP39_SEED.length}-character seed, but received ${NANO_TEST_VECTORS.BIP39_SEED.length + 1}-character string.`)\r
await assert.rejects(Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED.slice(0, -1)),\r
- { message: `Expected a ${NANO_TEST_VECTORS.BIP39_SEED.length}-character seed, but received ${NANO_TEST_VECTORS.BIP39_SEED.length - 1}-character string.` })\r
+ `Expected a ${NANO_TEST_VECTORS.BIP39_SEED.length}-character seed, but received ${NANO_TEST_VECTORS.BIP39_SEED.length - 1}-character string.`)\r
})\r
\r
- it('should throw when given a seed containing non-hex characters', async () => {\r
+ await test('Reject seed containing non-hex characters', async () => {\r
await assert.rejects(Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, TREZOR_TEST_VECTORS.SEED_0.replace(/./, 'g')),\r
- { message: 'Seed contains invalid hexadecimal characters.' })\r
+ 'Seed contains invalid hexadecimal characters.')\r
await assert.rejects(Blake2bWallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, TREZOR_TEST_VECTORS.ENTROPY_1.replace(/./, 'g')),\r
- { message: 'Seed contains invalid hexadecimal characters.' })\r
+ 'Seed contains invalid hexadecimal characters.')\r
})\r
})\r
\r
-describe('import from storage', async () => {\r
- it('should retrieve a Bip44Wallet from storage using an ID', async () => {\r
+await suite('Retrieve wallets from session storage using a wallet-generated ID', async () => {\r
+ await test('Bip44Wallet', async () => {\r
const id = (await Bip44Wallet.fromMnemonic(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.MNEMONIC, NANO_TEST_VECTORS.PASSWORD)).id\r
const wallet = await Bip44Wallet.restore(id)\r
\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equal(wallet.mnemonic, '')\r
- assert.equal(wallet.seed, '')\r
+ assert.equals(wallet.mnemonic, '')\r
+ assert.equals(wallet.seed, '')\r
\r
const unlockResult = await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
\r
- assert.equal(unlockResult, true)\r
+ assert.equals(unlockResult, true)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equal(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
- assert.equal(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
+ assert.equals(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
+ assert.equals(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
})\r
\r
- it('should retrieve a Blake2bWallet from storage using an ID', async () => {\r
+ await test('Blake2bWallet', async () => {\r
const id = (await Blake2bWallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, TREZOR_TEST_VECTORS.ENTROPY_0)).id\r
const wallet = await Blake2bWallet.restore(id)\r
\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equal(wallet.mnemonic, '')\r
- assert.equal(wallet.seed, '')\r
+ assert.equals(wallet.mnemonic, '')\r
+ assert.equals(wallet.seed, '')\r
\r
const unlockResult = await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
\r
- assert.equal(unlockResult, true)\r
+ assert.equals(unlockResult, true)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equal(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_0)\r
- assert.equal(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_0)\r
+ assert.equals(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_0)\r
+ assert.equals(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_0)\r
})\r
})\r
\r
'use strict'\r
\r
-import './GLOBALS.mjs'\r
-import { describe, it } from 'node:test'\r
-import { strict as assert } from 'assert'\r
-import { NANO_TEST_VECTORS, TREZOR_TEST_VECTORS } from './TEST_VECTORS.js'\r
-import { Bip44Wallet, Blake2bWallet } from '../dist/main.js'\r
-\r
-describe('locking and unlocking a Bip44Wallet', async () => {\r
- it('should succeed with a password', async () => {\r
+import { assert, suite, test } from '#GLOBALS.mjs'\r
+import { NANO_TEST_VECTORS, TREZOR_TEST_VECTORS } from '#test/TEST_VECTORS.js'\r
+import { Bip44Wallet, Blake2bWallet } from '#dist/main.js'\r
+\r
+await suite('Lock and unlock wallets', async () => {\r
+ await test('locking and unlocking a Bip44Wallet with a password', async () => {\r
const wallet = await Bip44Wallet.fromMnemonic(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.MNEMONIC, NANO_TEST_VECTORS.PASSWORD)\r
\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equal(wallet.mnemonic, '')\r
- assert.equal(wallet.seed, '')\r
+ assert.equals(wallet.mnemonic, '')\r
+ assert.equals(wallet.seed, '')\r
\r
const unlockResult = await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
\r
- assert.equal(unlockResult, true)\r
+ assert.equals(unlockResult, true)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equal(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
- assert.equal(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
+ assert.equals(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
+ assert.equals(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
})\r
\r
- it('should succeed with a random CryptoKey', async () => {\r
+ await test('locking and unlocking a Bip44Wallet with a random CryptoKey', async () => {\r
const wallet = await Bip44Wallet.fromMnemonic(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.MNEMONIC, NANO_TEST_VECTORS.PASSWORD)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const key = await globalThis.crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt'])\r
assert.ok(lockResult)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equal(wallet.mnemonic, '')\r
- assert.equal(wallet.seed, '')\r
+ assert.equals(wallet.mnemonic, '')\r
+ assert.equals(wallet.seed, '')\r
\r
const unlockResult = await wallet.unlock(key)\r
\r
- assert.equal(unlockResult, true)\r
+ assert.equals(unlockResult, true)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equal(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
- assert.equal(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
+ assert.equals(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
+ assert.equals(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
})\r
\r
- it('should fail to unlock with different passwords', async () => {\r
+ await test('fail to unlock a Bip44Wallet with different passwords', async () => {\r
const wallet = await Bip44Wallet.fromMnemonic(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.MNEMONIC, NANO_TEST_VECTORS.PASSWORD)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const lockResult = await wallet.lock(TREZOR_TEST_VECTORS.PASSWORD)\r
\r
await assert.rejects(wallet.unlock(NANO_TEST_VECTORS.PASSWORD), { message: 'Failed to unlock wallet' })\r
- assert.equal(lockResult, true)\r
+ assert.equals(lockResult, true)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
assert.notEqual(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
assert.notEqual(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
})\r
\r
- it('should fail to unlock with different keys', async () => {\r
+ await test('fail to unlock a Bip44Wallet with different keys', async () => {\r
const wallet = await Bip44Wallet.fromMnemonic(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.MNEMONIC, NANO_TEST_VECTORS.PASSWORD)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const rightKey = await globalThis.crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt'])\r
const lockResult = await wallet.lock(rightKey)\r
\r
await assert.rejects(wallet.unlock(wrongKey), { message: 'Failed to unlock wallet' })\r
- assert.equal(lockResult, true)\r
+ assert.equals(lockResult, true)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
assert.notEqual(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
assert.notEqual(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
})\r
\r
- it('should fail to unlock with different valid inputs', async () => {\r
+ await test('fail to unlock a Bip44Wallet with different valid inputs', async () => {\r
const wallet = await Bip44Wallet.fromMnemonic(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.MNEMONIC, NANO_TEST_VECTORS.PASSWORD)\r
const key = await globalThis.crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt'])\r
\r
assert.notEqual(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
})\r
\r
- it('should fail with no input', async () => {\r
+ await test('fail to unlock a Bip44Wallet with no input', async () => {\r
const wallet = await Bip44Wallet.fromMnemonic(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.MNEMONIC, NANO_TEST_VECTORS.PASSWORD)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
\r
+ //@ts-expect-error\r
await assert.rejects(wallet.lock(), { message: 'Failed to lock wallet' })\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equal(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
- assert.equal(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
+ assert.equals(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
+ assert.equals(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
\r
await wallet.lock('password')\r
\r
+ //@ts-expect-error\r
await assert.rejects(wallet.unlock(), { message: 'Failed to unlock wallet' })\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
assert.notEqual(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
})\r
\r
- it('should fail with invalid input', async () => {\r
+ await test('fail to unlock a Bip44Wallet with invalid input', async () => {\r
const wallet = await Bip44Wallet.fromMnemonic(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.MNEMONIC, NANO_TEST_VECTORS.PASSWORD)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
\r
+ //@ts-expect-error\r
await assert.rejects(wallet.lock(1), { message: 'Failed to lock wallet' })\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equal(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
- assert.equal(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
+ assert.equals(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
+ assert.equals(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
\r
await wallet.lock(NANO_TEST_VECTORS.PASSWORD)\r
\r
+ //@ts-expect-error\r
await assert.rejects(wallet.unlock(1), { message: 'Failed to unlock wallet' })\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
assert.notEqual(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
assert.notEqual(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
})\r
-})\r
\r
-describe('locking and unlocking a Blake2bWallet', async () => {\r
- it('should succeed with a password', async () => {\r
+ await test('locking and unlocking a Blake2bWallet with a password', async () => {\r
const wallet = await Blake2bWallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, TREZOR_TEST_VECTORS.ENTROPY_0)\r
\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equal(wallet.mnemonic, '')\r
- assert.equal(wallet.seed, '')\r
+ assert.equals(wallet.mnemonic, '')\r
+ assert.equals(wallet.seed, '')\r
\r
const unlockResult = await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
\r
- assert.equal(unlockResult, true)\r
+ assert.equals(unlockResult, true)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equal(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_0)\r
- assert.equal(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_0)\r
+ assert.equals(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_0)\r
+ assert.equals(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_0)\r
})\r
\r
- it('should succeed with a random CryptoKey', async () => {\r
+ await test('locking and unlocking a Blake2bWallet with a random CryptoKey', async () => {\r
const wallet = await Blake2bWallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, TREZOR_TEST_VECTORS.ENTROPY_1)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const key = await globalThis.crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt'])\r
const lockResult = await wallet.lock(key)\r
\r
- assert.equal(lockResult, true)\r
+ assert.equals(lockResult, true)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equal(wallet.mnemonic, '')\r
- assert.equal(wallet.seed, '')\r
+ assert.equals(wallet.mnemonic, '')\r
+ assert.equals(wallet.seed, '')\r
\r
const unlockResult = await wallet.unlock(key)\r
\r
- assert.equal(lockResult, true)\r
- assert.equal(unlockResult, true)\r
+ assert.equals(lockResult, true)\r
+ assert.equals(unlockResult, true)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equal(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_1)\r
- assert.equal(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_1)\r
+ assert.equals(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_1)\r
+ assert.equals(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_1)\r
})\r
\r
- it('should fail to unlock with different passwords', async () => {\r
+ await test('fail to unlock a Blake2bWallet with different passwords', async () => {\r
const wallet = await Blake2bWallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, TREZOR_TEST_VECTORS.ENTROPY_1)\r
\r
await assert.rejects(wallet.unlock(TREZOR_TEST_VECTORS.PASSWORD), { message: 'Failed to unlock wallet' })\r
assert.notEqual(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_1)\r
})\r
\r
- it('should fail to unlock with different keys', async () => {\r
+ await test('fail to unlock a Blake2bWallet with different keys', async () => {\r
const wallet = await Blake2bWallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, TREZOR_TEST_VECTORS.ENTROPY_1)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const rightKey = await globalThis.crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt'])\r
const lockResult = await wallet.lock(rightKey)\r
\r
await assert.rejects(wallet.unlock(wrongKey), { message: 'Failed to unlock wallet' })\r
- assert.equal(lockResult, true)\r
+ assert.equals(lockResult, true)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
assert.notEqual(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_1)\r
assert.notEqual(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_1)\r
})\r
\r
- it('should fail to unlock with different valid inputs', async () => {\r
+ await test('fail to unlock a Blake2bWallet with different valid inputs', async () => {\r
const wallet = await Blake2bWallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, TREZOR_TEST_VECTORS.ENTROPY_1)\r
const key = await globalThis.crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt'])\r
\r
assert.notEqual(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_1)\r
})\r
\r
- it('should fail with no input', async () => {\r
+ await test('fail to unlock a Blake2bWallet with no input', async () => {\r
const wallet = await Blake2bWallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, TREZOR_TEST_VECTORS.ENTROPY_1)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
\r
+ //@ts-expect-error\r
await assert.rejects(wallet.lock(), { message: 'Failed to lock wallet' })\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equal(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_1)\r
- assert.equal(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_1)\r
+ assert.equals(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_1)\r
+ assert.equals(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_1)\r
\r
await wallet.lock(NANO_TEST_VECTORS.PASSWORD)\r
\r
+ //@ts-expect-error\r
await assert.rejects(wallet.unlock(), { message: 'Failed to unlock wallet' })\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
assert.notEqual(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_1)\r
})\r
\r
- it('should fail with invalid input', async () => {\r
+ await test('fail to unlock a Blake2bWallet with invalid input', async () => {\r
const wallet = await Blake2bWallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, TREZOR_TEST_VECTORS.ENTROPY_1)\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
\r
+ //@ts-expect-error\r
await assert.rejects(wallet.lock(1), { message: 'Failed to lock wallet' })\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equal(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_1)\r
- assert.equal(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_1)\r
+ assert.equals(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_1)\r
+ assert.equals(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_1)\r
\r
await wallet.lock(NANO_TEST_VECTORS.PASSWORD)\r
\r
+ //@ts-expect-error\r
await assert.rejects(wallet.unlock(1), { message: 'Failed to unlock wallet' })\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
--- /dev/null
+// SPDX-FileCopyrightText: 2024 Chris Duncan <chris@zoso.dev>
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import './calculate-pow.test.mjs'
+import './create-wallet.test.mjs'
+import './derive-accounts.test.mjs'
+import './import-wallet.test.mjs'
+import './lock-unlock-wallet.mjs'
+import './manage-rolodex.mjs'
+import './refresh-accounts.test.mjs'
+import './sign-blocks.test.mjs'
+import './tools.test.mjs'
+
+console.log('%cTESTING COMPLETE', 'color:orange;font-weight:bold')
'use strict'
-import './GLOBALS.mjs'
-import { describe, it } from 'node:test'
-import { strict as assert } from 'assert'
-import { Rolodex, Tools } from '../dist/main.js'
-import { NANO_TEST_VECTORS } from './TEST_VECTORS.js'
-
-describe('rolodex valid contact management', async () => {
- it('should create a rolodex and add two contacts', async () => {
+import { assert, suite, test } from '#GLOBALS.mjs'
+import { NANO_TEST_VECTORS } from '#test/TEST_VECTORS.js'
+import { Rolodex, Tools } from '#dist/main.js'
+
+await suite('Rolodex valid contact management', async () => {
+ await test('should create a rolodex and add two contacts', async () => {
const rolodex = new Rolodex()
- assert.equal(rolodex.constructor, Rolodex)
+ assert.equals(rolodex.constructor, Rolodex)
await rolodex.add('JohnDoe', NANO_TEST_VECTORS.ADDRESS_0)
await rolodex.add('JaneSmith', NANO_TEST_VECTORS.ADDRESS_1)
- assert.equal(rolodex.getAllNames().length, 2)
- assert.equal(rolodex.getAllNames()[0], 'JohnDoe')
- assert.equal(rolodex.getAllNames()[1], 'JaneSmith')
- assert.equal(rolodex.getAddresses('JohnDoe').length, 1)
- assert.equal(rolodex.getAddresses('JohnDoe')[0], NANO_TEST_VECTORS.ADDRESS_0)
- assert.equal(rolodex.getAddresses('JaneSmith').length, 1)
- assert.equal(rolodex.getAddresses('JaneSmith')[0], NANO_TEST_VECTORS.ADDRESS_1)
+ assert.equals(rolodex.getAllNames().length, 2)
+ assert.equals(rolodex.getAllNames()[0], 'JohnDoe')
+ assert.equals(rolodex.getAllNames()[1], 'JaneSmith')
+ assert.equals(rolodex.getAddresses('JohnDoe').length, 1)
+ assert.equals(rolodex.getAddresses('JohnDoe')[0], NANO_TEST_VECTORS.ADDRESS_0)
+ assert.equals(rolodex.getAddresses('JaneSmith').length, 1)
+ assert.equals(rolodex.getAddresses('JaneSmith')[0], NANO_TEST_VECTORS.ADDRESS_1)
})
- it('should get a name from an address', async () => {
+ await test('should get a name from an address', async () => {
const rolodex = new Rolodex()
await rolodex.add('JohnDoe', NANO_TEST_VECTORS.ADDRESS_0)
- assert.equal(rolodex.getName(NANO_TEST_VECTORS.ADDRESS_0), 'JohnDoe')
+ assert.equals(rolodex.getName(NANO_TEST_VECTORS.ADDRESS_0), 'JohnDoe')
})
- it('should add three addresses to the same contact', async () => {
+ await test('should add three addresses to the same contact', async () => {
const rolodex = new Rolodex()
await rolodex.add('JohnDoe', NANO_TEST_VECTORS.ADDRESS_1)
await rolodex.add('JohnDoe', NANO_TEST_VECTORS.ADDRESS_2)
await rolodex.add('JohnDoe', NANO_TEST_VECTORS.ADDRESS_0)
- assert.equal(rolodex.getAddresses('JohnDoe').length, 3)
- assert.equal(rolodex.getAddresses('JohnDoe')[0], NANO_TEST_VECTORS.ADDRESS_1)
- assert.equal(rolodex.getAddresses('JohnDoe')[1], NANO_TEST_VECTORS.ADDRESS_2)
- assert.equal(rolodex.getAddresses('JohnDoe')[2], NANO_TEST_VECTORS.ADDRESS_0)
+ assert.equals(rolodex.getAddresses('JohnDoe').length, 3)
+ assert.equals(rolodex.getAddresses('JohnDoe')[0], NANO_TEST_VECTORS.ADDRESS_1)
+ assert.equals(rolodex.getAddresses('JohnDoe')[1], NANO_TEST_VECTORS.ADDRESS_2)
+ assert.equals(rolodex.getAddresses('JohnDoe')[2], NANO_TEST_VECTORS.ADDRESS_0)
})
- it('should update the name on an existing entry', async () => {
+ await test('should update the name on an existing entry', async () => {
const rolodex = new Rolodex()
await rolodex.add('JohnDoe', NANO_TEST_VECTORS.ADDRESS_0)
await rolodex.add('JaneSmith', NANO_TEST_VECTORS.ADDRESS_0)
- assert.equal(rolodex.getAddresses('JohnDoe').length, 0)
- assert.equal(rolodex.getAddresses('JaneSmith').length, 1)
- assert.equal(rolodex.getAddresses('JaneSmith')[0], NANO_TEST_VECTORS.ADDRESS_0)
+ assert.equals(rolodex.getAddresses('JohnDoe').length, 0)
+ assert.equals(rolodex.getAddresses('JaneSmith').length, 1)
+ assert.equals(rolodex.getAddresses('JaneSmith')[0], NANO_TEST_VECTORS.ADDRESS_0)
})
- it('should return empty address array for an unknown contact', async () => {
+ await test('should return empty address array for an unknown contact', async () => {
const rolodex = new Rolodex()
await rolodex.add('JohnDoe', NANO_TEST_VECTORS.ADDRESS_0)
- assert.equal(Array.isArray(rolodex.getAddresses('JaneSmith')), true)
- assert.equal(rolodex.getAddresses('JaneSmith').length, 0)
+ assert.equals(Array.isArray(rolodex.getAddresses('JaneSmith')), true)
+ assert.equals(rolodex.getAddresses('JaneSmith').length, 0)
})
- it('should return empty address array for blank contact names', () => {
+ await test('should return empty address array for blank contact names', () => {
const rolodex = new Rolodex()
- assert.equal(Array.isArray(rolodex.getAddresses(undefined)), true)
- assert.equal(rolodex.getAddresses(undefined).length, 0)
- assert.equal(Array.isArray(rolodex.getAddresses(null)), true)
- assert.equal(rolodex.getAddresses(null).length, 0)
- assert.equal(Array.isArray(rolodex.getAddresses('')), true)
- assert.equal(rolodex.getAddresses('').length, 0)
+ //@ts-expect-error
+ assert.equals(Array.isArray(rolodex.getAddresses(undefined)), true)
+ //@ts-expect-error
+ assert.equals(rolodex.getAddresses(undefined).length, 0)
+ //@ts-expect-error
+ assert.equals(Array.isArray(rolodex.getAddresses(null)), true)
+ //@ts-expect-error
+ assert.equals(rolodex.getAddresses(null).length, 0)
+ assert.equals(Array.isArray(rolodex.getAddresses('')), true)
+ assert.equals(rolodex.getAddresses('').length, 0)
})
- it('should return null for an unknown address', async () => {
+ await test('should return null for an unknown address', async () => {
const rolodex = new Rolodex()
await rolodex.add('JohnDoe', NANO_TEST_VECTORS.ADDRESS_0)
- assert.equal(rolodex.getName(NANO_TEST_VECTORS.ADDRESS_1), null)
- assert.notEqual(rolodex.getName(NANO_TEST_VECTORS.ADDRESS_1), undefined)
+ assert.ok(rolodex.getName(NANO_TEST_VECTORS.ADDRESS_1) === null)
+ assert.ok(rolodex.getName(NANO_TEST_VECTORS.ADDRESS_1) !== undefined)
})
- it('should return null for a blank address', async () => {
+ await test('should return null for a blank address', async () => {
const rolodex = new Rolodex()
await rolodex.add('JohnDoe', NANO_TEST_VECTORS.ADDRESS_0)
- assert.equal(rolodex.getName(undefined), null)
- assert.notEqual(rolodex.getName(undefined), undefined)
- assert.equal(rolodex.getName(null), null)
- assert.notEqual(rolodex.getName(null), undefined)
- assert.equal(rolodex.getName(''), null)
- assert.notEqual(rolodex.getName(''), undefined)
+ //@ts-expect-error
+ assert.ok(rolodex.getName(undefined) === null)
+ //@ts-expect-error
+ assert.ok(rolodex.getName(undefined) !== undefined)
+ //@ts-expect-error
+ assert.ok(rolodex.getName(null) === null)
+ //@ts-expect-error
+ assert.ok(rolodex.getName(null) !== undefined)
+ assert.ok(rolodex.getName('') === null)
+ assert.ok(rolodex.getName('') !== undefined)
})
})
-describe('rolodex exceptions', async () => {
- it('should throw if adding no data', async () => {
+await suite('Rolodex exceptions', async () => {
+ await test('should throw if adding no data', async () => {
const rolodex = new Rolodex()
+ //@ts-expect-error
await assert.rejects(rolodex.add())
})
- it('should throw if passed no address', async () => {
+ await test('should throw if passed no address', async () => {
const rolodex = new Rolodex()
+ //@ts-expect-error
await assert.rejects(rolodex.add('JohnDoe'))
+ //@ts-expect-error
await assert.rejects(rolodex.add('JohnDoe', undefined))
+ //@ts-expect-error
await assert.rejects(rolodex.add('JohnDoe', null))
await assert.rejects(rolodex.add('JohnDoe', ''))
})
- it('should throw if name is blank', async () => {
+ await test('should throw if name is blank', async () => {
const rolodex = new Rolodex()
+ //@ts-expect-error
await assert.rejects(rolodex.add(undefined, NANO_TEST_VECTORS.ADDRESS_0))
+ //@ts-expect-error
await assert.rejects(rolodex.add(null, NANO_TEST_VECTORS.ADDRESS_0))
await assert.rejects(rolodex.add('', NANO_TEST_VECTORS.ADDRESS_0))
})
})
-describe('rolodex data signature verification', async () => {
- const data = 'Test data'
- const signature = await Tools.sign(NANO_TEST_VECTORS.PRIVATE_0, data)
- const rolodex = new Rolodex()
-
- it('should verify valid data and signature', async () => {
+await suite('Rolodex data signature verification', async () => {
+ await test('should verify valid data and signature', async () => {
+ const data = 'Test data'
+ const signature = await Tools.sign(NANO_TEST_VECTORS.PRIVATE_0, data)
+ const rolodex = new Rolodex()
await rolodex.add('JohnDoe', NANO_TEST_VECTORS.ADDRESS_0)
const result = await rolodex.verify('JohnDoe', signature, data)
- assert.equal(result, true)
+ assert.equals(result, true)
})
- it('should reject incorrect contact for signature', async () => {
+ await test('should reject incorrect contact for signature', async () => {
+ const data = 'Test data'
+ const signature = await Tools.sign(NANO_TEST_VECTORS.PRIVATE_0, data)
+ const rolodex = new Rolodex()
await rolodex.add('JaneSmith', NANO_TEST_VECTORS.ADDRESS_1)
const result = await rolodex.verify('JaneSmith', signature, data)
- assert.equal(result, false)
+ assert.equals(result, false)
})
})
'use strict'
-import './GLOBALS.mjs'
-import { describe, it } from 'node:test'
-import { strict as assert } from 'assert'
-import { NANO_TEST_VECTORS } from './TEST_VECTORS.js'
-import { Account, Bip44Wallet, Rpc } from '../dist/main.js'
-
-const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)
-await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)
-const node = new Rpc(process.env.NODE_URL, process.env.API_KEY_NAME, process.env.API_KEY_VALUE)
-
-const skip = true
-
-describe('refreshing account info', { skip }, async () => {
- it('should fetch balance, frontier, and representative', async () => {
+import { assert, skip, suite, test } from '#GLOBALS.mjs'
+import { NANO_TEST_VECTORS } from '#test/TEST_VECTORS.js'
+import { Account, Bip44Wallet, Rpc } from '#dist/main.js'
+
+let rpc
+//@ts-ignore
+var process = process || null
+if (process) {
+ //@ts-expect-error
+ rpc = new Rpc(process?.env?.NODE_URL ?? '', process?.env?.API_KEY_NAME)
+}
+
+await skip('refreshing account info', async () => {
+ await test('fetch balance, frontier, and representative', async () => {
+ const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)
const accounts = await wallet.accounts()
const account = accounts[0]
- await account.refresh(node)
+ await account.refresh(rpc)
- assert.equal(typeof account.balance, 'bigint')
+ assert.equals(typeof account.balance, 'bigint')
assert.notEqual(account.balance, undefined)
assert.notEqual(account.balance, null)
assert.notEqual(account.balance, '')
- assert.notEqual(account.balance < 0, true)
+ assert.notEqual(account.balance && account.balance < 0, true)
- assert.equal(typeof account.frontier, 'string')
+ assert.equals(typeof account.frontier, 'string')
assert.notEqual(account.frontier, undefined)
assert.notEqual(account.frontier, null)
assert.notEqual(account.frontier, '')
- assert.match(account.frontier, /^[0-9A-F]{64}$/i)
+ assert.match(account.frontier ?? '', /^[0-9A-F]{64}$/i)
- assert.equal(account.representative.constructor, Account)
+ assert.equals(account.representative && account.representative.constructor, Account)
assert.notEqual(account.representative, undefined)
assert.notEqual(account.representative, null)
assert.notEqual(account.representative, '')
- assert.notEqual(account.representative.address, undefined)
- assert.notEqual(account.representative.address, null)
- assert.notEqual(account.representative.address, '')
+ assert.notEqual(account.representative?.address, undefined)
+ assert.notEqual(account.representative?.address, null)
+ assert.notEqual(account.representative?.address, '')
})
- it('should throw when refreshing unopened account', async () => {
+ await test('throw when refreshing unopened account', async () => {
+ const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)
const accounts = await wallet.accounts(0x7fffffff)
const account = accounts[0]
- await assert.rejects(account.refresh(node),
+ await assert.rejects(account.refresh(rpc),
{ message: 'Account not found' })
})
- it('should throw when referencing invalid account index', async () => {
+ await test('throw when referencing invalid account index', async () => {
+ const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)
await assert.rejects(wallet.accounts(0x80000000),
{ message: 'Invalid child key index 0x80000000' })
})
- it('should throw with invalid node', async () => {
+ await test('throw with invalid node', async () => {
+ const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)
const invalidNode = new Rpc('http://invalid.com')
const accounts = await wallet.accounts()
const account = accounts[0]
})
})
-describe('finding next unopened account', { skip }, async () => {
- it('should return correct account from test vector', async () => {
- const account = await wallet.getNextNewAccount(node)
+await skip('Fetch next unopened account', async () => {
+ await test('return correct account from test vector', async () => {
+ const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)
+ const account = await wallet.getNextNewAccount(rpc)
assert.ok(account)
- assert.equal(account.address, NANO_TEST_VECTORS.ADDRESS_1)
- assert.equal(account.publicKey, NANO_TEST_VECTORS.PUBLIC_1)
+ assert.equals(account.address, NANO_TEST_VECTORS.ADDRESS_1)
+ assert.equals(account.publicKey, NANO_TEST_VECTORS.PUBLIC_1)
})
- it('should return successfully for small batch size', async () => {
- const account = await wallet.getNextNewAccount(node, 1)
+ await test('return successfully for small batch size', async () => {
+ const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)
+ const account = await wallet.getNextNewAccount(rpc, 1)
assert.ok(account)
- assert.equal(account.address, NANO_TEST_VECTORS.ADDRESS_1)
- assert.equal(account.publicKey, NANO_TEST_VECTORS.PUBLIC_1)
+ assert.equals(account.address, NANO_TEST_VECTORS.ADDRESS_1)
+ assert.equals(account.publicKey, NANO_TEST_VECTORS.PUBLIC_1)
})
- it('should return successfully for large batch size', async () => {
- const account = await wallet.getNextNewAccount(node, 100)
+ await test('return successfully for large batch size', async () => {
+ const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)
+ const account = await wallet.getNextNewAccount(rpc, 100)
assert.ok(account)
- assert.equal(account.address, NANO_TEST_VECTORS.ADDRESS_1)
- assert.equal(account.publicKey, NANO_TEST_VECTORS.PUBLIC_1)
+ assert.equals(account.address, NANO_TEST_VECTORS.ADDRESS_1)
+ assert.equals(account.publicKey, NANO_TEST_VECTORS.PUBLIC_1)
})
- it('should throw on invalid node URL', async () => {
+ await test('should throw on invalid node URL', async () => {
+ const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)
+ //@ts-expect-error
await assert.rejects(wallet.getNextNewAccount())
+ //@ts-expect-error
await assert.rejects(wallet.getNextNewAccount(null))
+ //@ts-expect-error
await assert.rejects(wallet.getNextNewAccount(1))
+ //@ts-expect-error
await assert.rejects(wallet.getNextNewAccount(''))
+ //@ts-expect-error
await assert.rejects(wallet.getNextNewAccount('foo'))
})
- it('should throw on invalid batch size', async () => {
- await assert.rejects(wallet.getNextNewAccount(node, null))
- await assert.rejects(wallet.getNextNewAccount(node, -1))
- await assert.rejects(wallet.getNextNewAccount(node, ''))
- await assert.rejects(wallet.getNextNewAccount(node, 'foo'))
- await assert.rejects(wallet.getNextNewAccount(node, { 'foo': 'bar' }))
+ await test('should throw on invalid batch size', async () => {
+ const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)
+ //@ts-expect-error
+ await assert.rejects(wallet.getNextNewAccount(rpc, null))
+ await assert.rejects(wallet.getNextNewAccount(rpc, -1))
+ //@ts-expect-error
+ await assert.rejects(wallet.getNextNewAccount(rpc, ''))
+ //@ts-expect-error
+ await assert.rejects(wallet.getNextNewAccount(rpc, 'foo'))
+ //@ts-expect-error
+ await assert.rejects(wallet.getNextNewAccount(rpc, { 'foo': 'bar' }))
})
})
-describe('refreshing wallet accounts', { skip }, async () => {
- it('should get balance, frontier, and representative for one account', async () => {
- const accounts = await wallet.refresh(node)
+await skip('Refreshing wallet accounts', async () => {
+ await test('should get balance, frontier, and representative for one account', async () => {
+ const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)
+ const accounts = await wallet.refresh(rpc)
const account = accounts[0]
assert.ok(account instanceof Account)
- assert.equal(typeof account.balance, 'bigint')
+ assert.equals(typeof account.balance, 'bigint')
assert.notEqual(account.frontier, undefined)
assert.notEqual(account.frontier, null)
- assert.equal(typeof account.frontier, 'string')
+ assert.equals(typeof account.frontier, 'string')
})
- it('should get balance, frontier, and representative for multiple accounts', async () => {
- const accounts = await wallet.refresh(node, 0, 2)
- assert.equal(accounts.length, 1)
+ await test('should get balance, frontier, and representative for multiple accounts', async () => {
+ const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)
+ const accounts = await wallet.refresh(rpc, 0, 2)
+ assert.equals(accounts.length, 1)
assert.ok(accounts[0] instanceof Account)
})
- it('should handle failure gracefully', async () => {
- await assert.doesNotReject(wallet.refresh(node, 0, 20))
+ await test('should handle failure gracefully', async () => {
+ const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)
+ await assert.doesNotReject(wallet.refresh(rpc, 0, 20))
})
})
\r
'use strict'\r
\r
-import './GLOBALS.mjs'\r
-import { describe, it } from 'node:test'\r
-import { strict as assert } from 'assert'\r
-import { NANO_TEST_VECTORS } from './TEST_VECTORS.js'\r
-import { SendBlock, ReceiveBlock, ChangeBlock } from '../dist/main.js'\r
+import { assert, suite, test } from '#GLOBALS.mjs'\r
+import { NANO_TEST_VECTORS } from '#test/TEST_VECTORS.js'\r
+import { SendBlock, ReceiveBlock, ChangeBlock } from '#dist/main.js'\r
\r
-describe('valid blocks', async () => {\r
- it('should not allow negative balances', async () => {\r
+await suite('Valid blocks', async () => {\r
+ await test('should not allow negative balances', async () => {\r
assert.throws(() => {\r
const block = new SendBlock(\r
NANO_TEST_VECTORS.ADDRESS_0,\r
}, { message: 'Negative balance' })\r
})\r
\r
- it('should allow zero balances', async () => {\r
+ await test('should allow zero balances', async () => {\r
const block = new SendBlock(\r
NANO_TEST_VECTORS.ADDRESS_0,\r
'9007199254740991',\r
'92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D'\r
)\r
assert.notEqual(block.balance, 0)\r
- assert.equal(block.balance, BigInt(0))\r
+ assert.equals(block.balance, BigInt(0))\r
})\r
\r
- it('should subtract balance from SendBlock correctly', async () => {\r
+ await test('should subtract balance from SendBlock correctly', async () => {\r
const block = new SendBlock(\r
NANO_TEST_VECTORS.ADDRESS_0,\r
'3000000000000000000000000000000',\r
NANO_TEST_VECTORS.ADDRESS_2,\r
'92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D'\r
)\r
- assert.equal(block.balance, 1000000000000000000000000000000n)\r
+ assert.equals(block.balance, 1000000000000000000000000000000n)\r
})\r
\r
- it('should add balance from ReceiveBlock correctly', async () => {\r
+ await test('should add balance from ReceiveBlock correctly', async () => {\r
const block = new ReceiveBlock(\r
NANO_TEST_VECTORS.ADDRESS_0,\r
'2000000000000000000000000000000',\r
NANO_TEST_VECTORS.ADDRESS_2,\r
'92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D'\r
)\r
- assert.equal(block.balance, 3000000000000000000000000000000n)\r
+ assert.equals(block.balance, 3000000000000000000000000000000n)\r
})\r
})\r
\r
-describe('block signing tests using official test vectors', async () => {\r
- it('should create a valid signature for a receive block', async () => {\r
- const work = 'c5cf86de24b24419'\r
+await suite('Block signing tests using official test vectors', async () => {\r
+ await test('should create a valid signature for an open block', async () => {\r
const block = new ReceiveBlock(\r
- 'nano_1e5aqegc1jb7qe964u4adzmcezyo6o146zb8hm6dft8tkp79za3sxwjym5rx',\r
- '18618869000000000000000000000000',\r
- 'CBC911F57B6827649423C92C88C0C56637A4274FF019E77E24D61D12B5338783',\r
- '7000000000000000000000000000000',\r
- 'nano_1stofnrxuz3cai7ze75o174bpm7scwj9jn3nxsn8ntzg784jf1gzn1jjdkou',\r
- '92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D',\r
- work\r
+ NANO_TEST_VECTORS.OPEN_BLOCK.account,\r
+ '0',\r
+ NANO_TEST_VECTORS.OPEN_BLOCK.link,\r
+ NANO_TEST_VECTORS.OPEN_BLOCK.balance,\r
+ NANO_TEST_VECTORS.OPEN_BLOCK.representative,\r
+ NANO_TEST_VECTORS.OPEN_BLOCK.previous,\r
+ NANO_TEST_VECTORS.OPEN_BLOCK.work\r
+ )\r
+ await block.sign(NANO_TEST_VECTORS.OPEN_BLOCK.key)\r
+ assert.equals(await block.hash(), NANO_TEST_VECTORS.OPEN_BLOCK.hash)\r
+ assert.equals(block.signature, NANO_TEST_VECTORS.OPEN_BLOCK.signature)\r
+ })\r
+\r
+ await test('should create a valid signature for a receive block', async () => {\r
+ const block = new ReceiveBlock(\r
+ NANO_TEST_VECTORS.RECEIVE_BLOCK.account,\r
+ NANO_TEST_VECTORS.RECEIVE_BLOCK.balance,\r
+ NANO_TEST_VECTORS.RECEIVE_BLOCK.link,\r
+ '0',\r
+ NANO_TEST_VECTORS.RECEIVE_BLOCK.representative,\r
+ NANO_TEST_VECTORS.RECEIVE_BLOCK.previous,\r
+ NANO_TEST_VECTORS.RECEIVE_BLOCK.work\r
)\r
- await block.sign('781186FB9EF17DB6E3D1056550D9FAE5D5BBADA6A6BC370E4CBB938B1DC71DA3')\r
- assert.equal(block.signature, 'F25D751AD0379A5718E08F3773DA6061A9E18842EF5615163C7F207B804CC2C5DD2720CFCE5FE6A78E4CC108DD9CAB65051526403FA2C24A1ED943BB4EA7880B')\r
- assert.equal(block.work, work)\r
+ await block.sign(NANO_TEST_VECTORS.RECEIVE_BLOCK.key)\r
+ assert.equals(await block.hash(), NANO_TEST_VECTORS.RECEIVE_BLOCK.hash)\r
+ assert.equals(block.signature, NANO_TEST_VECTORS.RECEIVE_BLOCK.signature)\r
})\r
\r
- it('should create a valid signature for a receive block without work', async () => {\r
+ await test('should create a valid signature for a receive block without work', async () => {\r
const block = new ReceiveBlock(\r
- 'nano_1e5aqegc1jb7qe964u4adzmcezyo6o146zb8hm6dft8tkp79za3sxwjym5rx',\r
- '18618869000000000000000000000000',\r
- 'CBC911F57B6827649423C92C88C0C56637A4274FF019E77E24D61D12B5338783',\r
- '7000000000000000000000000000000',\r
- 'nano_1stofnrxuz3cai7ze75o174bpm7scwj9jn3nxsn8ntzg784jf1gzn1jjdkou',\r
- '92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D',\r
+ NANO_TEST_VECTORS.RECEIVE_BLOCK.account,\r
+ NANO_TEST_VECTORS.RECEIVE_BLOCK.balance,\r
+ NANO_TEST_VECTORS.RECEIVE_BLOCK.link,\r
+ '0',\r
+ NANO_TEST_VECTORS.RECEIVE_BLOCK.representative,\r
+ NANO_TEST_VECTORS.RECEIVE_BLOCK.previous\r
)\r
- await block.sign('781186FB9EF17DB6E3D1056550D9FAE5D5BBADA6A6BC370E4CBB938B1DC71DA3')\r
- assert.equal(block.signature, 'F25D751AD0379A5718E08F3773DA6061A9E18842EF5615163C7F207B804CC2C5DD2720CFCE5FE6A78E4CC108DD9CAB65051526403FA2C24A1ED943BB4EA7880B')\r
- assert.equal(block.work, '')\r
+ await block.sign(NANO_TEST_VECTORS.RECEIVE_BLOCK.key)\r
+ assert.equals(await block.hash(), NANO_TEST_VECTORS.RECEIVE_BLOCK.hash)\r
+ assert.equals(block.signature, NANO_TEST_VECTORS.RECEIVE_BLOCK.signature)\r
+ assert.equals(block.work, '')\r
})\r
\r
- it('should create a valid signature for a send block', async () => {\r
- const work = 'fbffed7c73b61367'\r
+ await test('should create a valid signature for a send block', async () => {\r
const block = new SendBlock(\r
- 'nano_1e5aqegc1jb7qe964u4adzmcezyo6o146zb8hm6dft8tkp79za3sxwjym5rx',\r
- '5618869000000000000000000000000',\r
- 'nano_1q3hqecaw15cjt7thbtxu3pbzr1eihtzzpzxguoc37bj1wc5ffoh7w74gi6p',\r
- '2000000000000000000000000000000',\r
- 'nano_1stofnrxuz3cai7ze75o174bpm7scwj9jn3nxsn8ntzg784jf1gzn1jjdkou',\r
- '92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D',\r
- work,\r
+ NANO_TEST_VECTORS.SEND_BLOCK.account,\r
+ NANO_TEST_VECTORS.SEND_BLOCK.balance,\r
+ NANO_TEST_VECTORS.SEND_BLOCK.link,\r
+ '0',\r
+ NANO_TEST_VECTORS.SEND_BLOCK.representative,\r
+ NANO_TEST_VECTORS.SEND_BLOCK.previous,\r
+ NANO_TEST_VECTORS.SEND_BLOCK.work\r
)\r
- await block.sign('781186FB9EF17DB6E3D1056550D9FAE5D5BBADA6A6BC370E4CBB938B1DC71DA3')\r
- assert.equal(block.signature.toUpperCase(), '79240D56231EF1885F354473733AF158DC6DA50E53836179565A20C0BE89D473ED3FF8CD11545FF0ED162A0B2C4626FD6BF84518568F8BB965A4884C7C32C205')\r
- assert.equal(block.work, work)\r
+ await block.sign(NANO_TEST_VECTORS.SEND_BLOCK.key)\r
+ assert.equals(await block.hash(), NANO_TEST_VECTORS.SEND_BLOCK.hash)\r
+ assert.equals(block.signature, NANO_TEST_VECTORS.SEND_BLOCK.signature)\r
})\r
\r
- it('should create a valid signature for a send block without work', async () => {\r
+ await test('should create a valid signature for a send block without work', async () => {\r
const block = new SendBlock(\r
- 'nano_1e5aqegc1jb7qe964u4adzmcezyo6o146zb8hm6dft8tkp79za3sxwjym5rx',\r
- '5618869000000000000000000000000',\r
- 'nano_1q3hqecaw15cjt7thbtxu3pbzr1eihtzzpzxguoc37bj1wc5ffoh7w74gi6p',\r
- '2000000000000000000000000000000',\r
- 'nano_1stofnrxuz3cai7ze75o174bpm7scwj9jn3nxsn8ntzg784jf1gzn1jjdkou',\r
- '92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D',\r
+ NANO_TEST_VECTORS.SEND_BLOCK.account,\r
+ NANO_TEST_VECTORS.SEND_BLOCK.balance,\r
+ NANO_TEST_VECTORS.SEND_BLOCK.link,\r
+ '0',\r
+ NANO_TEST_VECTORS.SEND_BLOCK.representative,\r
+ NANO_TEST_VECTORS.SEND_BLOCK.previous\r
)\r
- await block.sign('781186FB9EF17DB6E3D1056550D9FAE5D5BBADA6A6BC370E4CBB938B1DC71DA3')\r
- assert.equal(block.signature.toUpperCase(), '79240D56231EF1885F354473733AF158DC6DA50E53836179565A20C0BE89D473ED3FF8CD11545FF0ED162A0B2C4626FD6BF84518568F8BB965A4884C7C32C205')\r
- assert.equal(block.work, '')\r
+ await block.sign(NANO_TEST_VECTORS.SEND_BLOCK.key)\r
+ assert.equals(await block.hash(), NANO_TEST_VECTORS.SEND_BLOCK.hash)\r
+ assert.equals(block.signature, NANO_TEST_VECTORS.SEND_BLOCK.signature)\r
+ assert.equals(block.work, '')\r
})\r
\r
- it('should create a valid signature for a change rep block', async () => {\r
+ await test('should create a valid signature for a change rep block', async () => {\r
const work = '0000000000000000'\r
const block = new ChangeBlock(\r
'nano_3igf8hd4sjshoibbbkeitmgkp1o6ug4xads43j6e4gqkj5xk5o83j8ja9php',\r
work,\r
)\r
await block.sign('781186FB9EF17DB6E3D1056550D9FAE5D5BBADA6A6BC370E4CBB938B1DC71DA3') // Did not find a private key at nano docs for this address\r
- assert.equal(block.signature.toUpperCase(), 'A3C3C66D6519CBC0A198E56855942DEACC6EF741021A1B11279269ADC587DE1DA53CD478B8A47553231104CF24D742E1BB852B0546B87038C19BAE20F9082B0D')\r
- assert.equal(block.work, work)\r
+ assert.equals(block.signature?.toUpperCase(), 'A3C3C66D6519CBC0A198E56855942DEACC6EF741021A1B11279269ADC587DE1DA53CD478B8A47553231104CF24D742E1BB852B0546B87038C19BAE20F9082B0D')\r
+ assert.equals(block.work, work)\r
})\r
\r
- it('should create a valid signature for a change rep block without work', async () => {\r
+ await test('should create a valid signature for a change rep block without work', async () => {\r
const block = new ChangeBlock(\r
NANO_TEST_VECTORS.ADDRESS_0,\r
'0',\r
'F3C1D7B6EE97DA09D4C00538CEA93CBA5F74D78FD3FBE71347D2DFE7E53DF327'\r
)\r
await block.sign(NANO_TEST_VECTORS.PRIVATE_0)\r
- assert.equal(block.signature.toUpperCase(), '2BD2F905E74B5BEE3E2277CED1D1E3F7535E5286B6E22F7B08A814AA9E5C4E1FEA69B61D60B435ADC2CE756E6EE5F5BE7EC691FE87E024A0B22A3D980CA5B305')\r
- assert.equal(block.work, '')\r
+ assert.equals(block.signature?.toUpperCase(), '2BD2F905E74B5BEE3E2277CED1D1E3F7535E5286B6E22F7B08A814AA9E5C4E1FEA69B61D60B435ADC2CE756E6EE5F5BE7EC691FE87E024A0B22A3D980CA5B305')\r
+ assert.equals(block.work, '')\r
})\r
})\r
\r
'use strict'\r
\r
-import './GLOBALS.mjs'\r
-import { describe, it } from 'node:test'\r
-import { strict as assert } from 'assert'\r
-import { RAW_MAX, NANO_TEST_VECTORS } from './TEST_VECTORS.js'\r
-import { Bip44Wallet, Account, SendBlock, Rpc, Tools } from '../dist/main.js'\r
-\r
-const skip = true\r
-\r
-const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)\r
-await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
-const rpc = new Rpc(process.env.NODE_URL, process.env.API_KEY_NAME, process.env.API_KEY_VALUE)\r
-\r
-describe('unit conversion tests', async () => {\r
- it('should convert nano to raw', async () => {\r
+import { assert, skip, suite, test } from '#GLOBALS.mjs'\r
+import { RAW_MAX, NANO_TEST_VECTORS } from '#test/TEST_VECTORS.js'\r
+import { Bip44Wallet, Account, SendBlock, Rpc, Tools } from '#dist/main.js'\r
+\r
+let rpc\r
+//@ts-ignore\r
+var process = process || null\r
+if (process) {\r
+ //@ts-expect-error\r
+ rpc = new Rpc(process?.env?.NODE_URL ?? '', process?.env?.API_KEY_NAME)\r
+}\r
+\r
+await suite('unit conversion tests', async () => {\r
+ await test('should convert nano to raw', async () => {\r
const result = await Tools.convert('1', 'NANO', 'RAW')\r
- assert.equal(result, '1000000000000000000000000000000')\r
+ assert.equals(result, '1000000000000000000000000000000')\r
})\r
\r
- it('should convert raw to nano', async () => {\r
+ await test('should convert raw to nano', async () => {\r
const result = await Tools.convert('1000000000000000000000000000000', 'RAW', 'NANO')\r
- assert.equal(result, '1')\r
+ assert.equals(result, '1')\r
})\r
\r
- it('should convert 1 raw to 10^-29 nano', async () => {\r
+ await test('should convert 1 raw to 10^-29 nano', async () => {\r
const result = await Tools.convert('1', 'RAW', 'NANO')\r
- assert.equal(result, '.000000000000000000000000000001')\r
+ assert.equals(result, '.000000000000000000000000000001')\r
})\r
\r
- it('should ignore leading and trailing zeros', async () => {\r
+ await test('should ignore leading and trailing zeros', async () => {\r
const result = await Tools.convert('0011002200.0033004400', 'nano', 'nano')\r
- assert.equal(result, '11002200.00330044')\r
+ assert.equals(result, '11002200.00330044')\r
})\r
\r
- it('should convert raw to nyano', async () => {\r
+ await test('should convert raw to nyano', async () => {\r
const result = await Tools.convert(RAW_MAX, 'RAW', 'NYANO')\r
- assert.equal(result, '340282366920938.463463374607431768211455')\r
+ assert.equals(result, '340282366920938.463463374607431768211455')\r
})\r
\r
- it('should convert case-insensitive nyano to raw', async () => {\r
+ await test('should convert case-insensitive nyano to raw', async () => {\r
const result = await Tools.convert('0.000000000000000123456789', 'nYaNo', 'rAw')\r
- assert.equal(result, '123456789')\r
+ assert.equals(result, '123456789')\r
})\r
\r
- it('should convert nano to pico', async () => {\r
+ await test('should convert nano to pico', async () => {\r
const result = await Tools.convert('123.456', 'nano', 'pico')\r
- assert.equal(result, '123456')\r
+ assert.equals(result, '123456')\r
})\r
\r
- it('should convert knano to pico', async () => {\r
+ await test('should convert knano to pico', async () => {\r
const result = await Tools.convert('123.456', 'nano', 'pico')\r
- assert.equal(result, '123456')\r
+ assert.equals(result, '123456')\r
})\r
\r
- it('should throw if amount exceeds raw max', async () => {\r
+ await test('should throw if amount exceeds raw max', async () => {\r
await assert.rejects(Tools.convert(RAW_MAX, 'NANO', 'RAW'),\r
{ message: 'Amount exceeds Nano limits' })\r
})\r
\r
- it('should throw if amount exceeds raw min', async () => {\r
+ await test('should throw if amount exceeds raw min', async () => {\r
await assert.rejects(Tools.convert('0.1', 'RAW', 'NANO'),\r
{ message: 'Amount must be at least 1 raw' })\r
})\r
\r
- it('should throw if amount is blank', async () => {\r
+ await test('should throw if amount is blank', async () => {\r
await assert.rejects(Tools.convert('', 'RAW', 'NANO'),\r
{ message: 'Invalid amount' })\r
})\r
\r
- it('should throw if amount has non-digit characters', async () => {\r
+ await test('should throw if amount has non-digit characters', async () => {\r
await assert.rejects(Tools.convert('0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF', 'RAW', 'NANO'),\r
{ message: 'Invalid amount' })\r
})\r
})\r
\r
-describe('signature tests', async () => {\r
- it('should sign data with a single parameter', async () => {\r
+await suite('signature tests', async () => {\r
+ await test('should sign data with a single parameter', async () => {\r
const result = await Tools.sign(NANO_TEST_VECTORS.PRIVATE_0, 'miro@metsanheimo.fi')\r
- assert.equal(result, 'FECB9B084065ADC969904B55A0099C63746B68DF41FECB713244D387EED83A80B9D4907278C5EBC0998A5FC8BA597FBAAABBFCE0ABD2CA2212ACFE788637040C')\r
+ assert.equals(result, 'FECB9B084065ADC969904B55A0099C63746B68DF41FECB713244D387EED83A80B9D4907278C5EBC0998A5FC8BA597FBAAABBFCE0ABD2CA2212ACFE788637040C')\r
})\r
\r
- it('should sign data with multiple parameters', async () => {\r
+ await test('should sign data with multiple parameters', async () => {\r
const result = await Tools.sign(NANO_TEST_VECTORS.PRIVATE_0, 'miro@metsanheimo.fi', 'somePassword')\r
- assert.equal(result, 'BB534F9B469AF451B1941FFEF8EE461FC5D284B5D393140900C6E13A65EF08D0AE2BC77131EE182922F66C250C7237A83878160457D5C39A70E55F7FCE925804')\r
+ assert.equals(result, 'BB534F9B469AF451B1941FFEF8EE461FC5D284B5D393140900C6E13A65EF08D0AE2BC77131EE182922F66C250C7237A83878160457D5C39A70E55F7FCE925804')\r
})\r
\r
- it('should verify a signature using the public key', async () => {\r
+ await test('should verify a signature using the public key', async () => {\r
const result = await Tools.verify(NANO_TEST_VECTORS.PUBLIC_0, 'FECB9B084065ADC969904B55A0099C63746B68DF41FECB713244D387EED83A80B9D4907278C5EBC0998A5FC8BA597FBAAABBFCE0ABD2CA2212ACFE788637040C', 'miro@metsanheimo.fi')\r
- assert.equal(result, true)\r
+ assert.equals(result, true)\r
\r
const result2 = await Tools.verify(NANO_TEST_VECTORS.PUBLIC_0, 'FECB9B084065ADC969904B55A0099C63746B68DF41FECB713244D387EED83A80B9D4907278C5EBC0998A5FC8BA597FBAAABBFCE0ABD2CA2212ACFE788637040C', 'mir@metsanheimo.fi')\r
- assert.equal(result2, false)\r
+ assert.equals(result2, false)\r
\r
const result3 = await Tools.verify(NANO_TEST_VECTORS.PUBLIC_0, 'AECB9B084065ADC969904B55A0099C63746B68DF41FECB713244D387EED83A80B9D4907278C5EBC0998A5FC8BA597FBAAABBFCE0ABD2CA2212ACFE788637040C', 'miro@metsanheimo.fi')\r
- assert.equal(result3, false)\r
+ assert.equals(result3, false)\r
})\r
\r
- it('should verify a block using the public key', async () => {\r
+ await test('should verify a block using the public key', async () => {\r
+ const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)\r
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const accounts = await wallet.accounts()\r
+ const account = accounts[0]\r
const sendBlock = new SendBlock(\r
- accounts[0].address,\r
+ account.address,\r
'5618869000000000000000000000000',\r
'nano_1q3hqecaw15cjt7thbtxu3pbzr1eihtzzpzxguoc37bj1wc5ffoh7w74gi6p',\r
'2000000000000000000000000000000',\r
'nano_1stofnrxuz3cai7ze75o174bpm7scwj9jn3nxsn8ntzg784jf1gzn1jjdkou',\r
'92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D',\r
)\r
- await sendBlock.sign(accounts[0].privateKey)\r
- const valid = await sendBlock.verify(accounts[0].publicKey)\r
- assert.equal(valid, true)\r
+ await sendBlock.sign(account.privateKey ?? '')\r
+ const valid = await sendBlock.verify(account.publicKey)\r
+ assert.equals(valid, true)\r
})\r
\r
- it('should reject a block using the wrong public key', async () => {\r
+ await test('should reject a block using the wrong public key', async () => {\r
+ const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)\r
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const accounts = await wallet.accounts()\r
+ const account = accounts[0]\r
const sendBlock = new SendBlock(\r
- accounts[0].address,\r
+ account.address,\r
'5618869000000000000000000000000',\r
'nano_1q3hqecaw15cjt7thbtxu3pbzr1eihtzzpzxguoc37bj1wc5ffoh7w74gi6p',\r
'2000000000000000000000000000000',\r
'nano_1stofnrxuz3cai7ze75o174bpm7scwj9jn3nxsn8ntzg784jf1gzn1jjdkou',\r
'92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D',\r
)\r
- sendBlock.sign(accounts[0].privateKey)\r
-\r
- sendBlock.account = new Account('nano_1q3hqecaw15cjt7thbtxu3pbzr1eihtzzpzxguoc37bj1wc5ffoh7w74gi6p')\r
- const valid = await sendBlock.verify(accounts[0].publicKey)\r
- assert.equal(valid, false)\r
- })\r
-\r
- it('should create a BLAKE2b hash of a single string', async () => {\r
- const hash = await Tools.hash('asd')\r
- assert.equal(hash, 'F787FBCDD2B4C6F6447921D6F163E8FDDFB83D08432430CACAAAB1BBEDD723FE')\r
- })\r
+ await sendBlock.sign(account.privateKey ?? '')\r
\r
- it('should create a BLAKE2b hash of a string array', async () => {\r
- const hash = await Tools.hash(['asd'])\r
- assert.equal(hash, 'F787FBCDD2B4C6F6447921D6F163E8FDDFB83D08432430CACAAAB1BBEDD723FE')\r
+ sendBlock.account = Account.fromAddress('nano_1q3hqecaw15cjt7thbtxu3pbzr1eihtzzpzxguoc37bj1wc5ffoh7w74gi6p')\r
+ const valid = await sendBlock.verify(account.publicKey)\r
+ assert.equals(valid, false)\r
})\r
-})\r
\r
-describe('sweeper', async () => {\r
- it('throws without required parameters', async () => {\r
+ await test('sweeper throws without required parameters', async () => {\r
+ //@ts-expect-error\r
await assert.rejects(Tools.sweep(),\r
- { message: 'Missing required sweep arguments' })\r
+ 'Missing required sweep arguments')\r
})\r
\r
- it('fails gracefully for ineligible accounts', { skip }, async () => {\r
+ await skip('sweeper fails gracefully for ineligible accounts', async () => {\r
+ const wallet = await Bip44Wallet.fromSeed(NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)\r
+ await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const results = await Tools.sweep(rpc, wallet, NANO_TEST_VECTORS.ADDRESS_1)\r
assert.ok(results)\r
- assert.equal(results.length, 1)\r
+ assert.equals(results.length, 1)\r
})\r
})\r
projects / libnemo.git / commitdiff