*/
export const options = {
bundle: true,
+ platform: 'browser',
entryPoints: [
{ in: './src/main.ts', out: 'main.min' },
{ in: './src/types.d.ts', out: 'types.d' }
"@types/w3c-web-usb": "^1.0.10",
"@types/web-bluetooth": "^0.0.21",
"esbuild": "^0.25.5",
+ "fake-indexeddb": "^6.0.1",
"typescript": "^5.8.3"
},
"funding": {
"@types/yauzl": "^2.9.1"
}
},
+ "node_modules/fake-indexeddb": {
+ "version": "6.0.1",
+ "resolved": "https://registry.npmjs.org/fake-indexeddb/-/fake-indexeddb-6.0.1.tgz",
+ "integrity": "sha512-He2AjQGHe46svIFq5+L2Nx/eHDTI1oKgoevBP+TthnjymXiKkeJQ3+ITeWey99Y5+2OaPFbI1qEsx/5RsGtWnQ==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=18"
+ }
+ },
"node_modules/fast-fifo": {
"version": "1.3.2",
"resolved": "https://registry.npmjs.org/fast-fifo/-/fast-fifo-1.3.2.tgz",
"@types/w3c-web-usb": "^1.0.10",
"@types/web-bluetooth": "^0.0.21",
"esbuild": "^0.25.5",
+ "fake-indexeddb": "^6.0.1",
"typescript": "^5.8.3"
},
"type": "module",
* 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 {ArrayBuffer} 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
+ * @returns {Promise<ArrayBuffer>} Private child key for the account
*/
static async nanoCKD (seed: ArrayBuffer, index: number): Promise<ArrayBuffer> {
return await this.ckd(seed, this.BIP44_COIN_NANO, index)
* BIP-44 derivation path. Purpose is always 44'. Coin defaults to Nano. Only
* hardened child keys are defined.
*
- * @param {string} seed - Hexadecimal seed derived from mnemonic phrase
+ * @param {ArrayBuffer} 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
+ * @returns {Promise<ArrayBuffer>} Private child key for the account
*/
static async ckd (seed: ArrayBuffer, coin: number = this.BIP44_COIN_NANO, index: number): Promise<ArrayBuffer> {
if (seed.byteLength < 16 || seed.byteLength > 64) {
}
}
+let importWorkerThreads = ''
+NODE: importWorkerThreads = `import { parentPort } from 'node:worker_threads'`
export default `
+ ${importWorkerThreads}
const WorkerInterface = ${WorkerInterface}
const Bip44Ckd = ${Bip44Ckd}
`
const privateKey = new Uint8Array(data.privateKey)\r
const publicKey = new Uint8Array(data.publicKey)\r
const signature = new Uint8Array(data.signature)\r
- switch (method) {\r
- case 'convert': {\r
- return bytes.toHex(await this.convert(privateKey))\r
- }\r
- case 'detached': {\r
- return bytes.toHex(await this.detached(msg, privateKey))\r
- }\r
- case 'verify': {\r
- return await this.verify(msg, signature, publicKey)\r
- }\r
- default: {\r
- throw new TypeError(`unknown NanoNaCl method ${method}`)\r
+ try {\r
+ switch (method) {\r
+ case 'convert': {\r
+ return bytes.toHex(await this.convert(privateKey))\r
+ }\r
+ case 'detached': {\r
+ return bytes.toHex(await this.detached(msg, privateKey))\r
+ }\r
+ case 'verify': {\r
+ return await this.verify(msg, signature, publicKey)\r
+ }\r
+ default: {\r
+ throw new TypeError(`unknown NanoNaCl method ${method}`)\r
+ }\r
}\r
+ } catch (err) {\r
+ throw new Error(`NanoNaCl worker failed on ${method ?? 'unknown method'}`, { cause: err })\r
}\r
}\r
\r
}\r
}\r
\r
+let importWorkerThreads = ''\r
+NODE: importWorkerThreads = `import { parentPort } from 'node:worker_threads'`\r
export default `\r
+ ${importWorkerThreads}\r
${Convert}\r
const Blake2b = ${Blake2b}\r
const WorkerInterface = ${WorkerInterface}\r
#isIdle: boolean
#queue: Task[] = []
#url: string
- #worker: Worker
+ #worker: Worker | NodeWorker
/**
* Creates a Web Worker from a stringified script.
BROWSER: this.#worker.addEventListener('message', message => {
this.#report(message.data)
})
- //@ts-expect-error
- NODE: this.#worker = new NodeWorker(worker, { type: 'module', eval: true })
- //@ts-expect-error
- NODE: this.#worker.addListener('message', message => {
- this.#report(message.data)
+ NODE: this.#worker = new NodeWorker(worker, {
+ eval: true,
+ stderr: false,
+ stdout: false
+ })
+ NODE: this.#worker.on('message', message => {
+ this.#report(message)
})
Queue.#instances.push(this)
}
async assign (headers: Headers | null, data?: Data): Promise<any> {
- return await this.#assign(task => this.#queue.push(task), headers, data)
+ return this.#assign(task => this.#queue.push(task), headers, data)
}
async prioritize (headers: Headers | null, data?: Data): Promise<any> {
- return await this.#assign(task => this.#queue.unshift(task), headers, data)
+ return this.#assign(task => this.#queue.unshift(task), headers, data)
}
terminate (): void {
buffers.push(data[d])
}
}
- this.#worker.postMessage({ headers, data }, buffers)
+ BROWSER: this.#worker.postMessage({ headers, data }, buffers)
+ NODE: this.#worker.postMessage({ data: { headers, data } }, buffers)
} catch (err) {
reject(err)
}
this.listen()
}
- static async work (headers: Headers, data: Data): Promise<any> {
+ static async work (headers: Headers, data: Data): Promise<boolean | Data> {
const { method, name, store } = headers
- const { password } = data
- delete data.password
+ const password = data?.password
+ if (data != null) delete data.password
this.#storage = await this.#open(this.DB_NAME)
let result
try {
break
}
default: {
- result = `unknown Safe method ${method}`
+ throw new Error(`unknown Safe method ${method}`)
}
}
} catch (err) {
console.log(err)
- result = false
+ throw new Error('Safe error', { cause: err })
}
return result
}
/**
* Retrieves data from the Safe and decrypts it with a password byte array.
*/
- static async get (name: string | string[] | unknown, store: string | unknown, password: ArrayBuffer | unknown): Promise<Data | null> {
+ static async get (name: string | string[] | unknown, store: string | unknown, password: ArrayBuffer | unknown): Promise<Data> {
const names = Array.isArray(name) ? name : [name]
if (names.some(v => typeof v !== 'string')) {
throw new Error('Invalid fields')
return results
} catch (err) {
console.log(err)
- return null
+ throw new Error('Failed to get records', { cause: err })
} finally {
bytes.erase(password)
}
}
}
+let importWorkerThreads = ''
+let importFakeIndexedDb = ''
+NODE: importWorkerThreads = `import { parentPort } from 'node:worker_threads'`
+NODE: importFakeIndexedDb = `import 'fake-indexeddb/auto'`
export default `
+ ${importWorkerThreads}
+ ${importFakeIndexedDb}
${Convert}
const PBKDF2_ITERATIONS = ${PBKDF2_ITERATIONS}
const Entropy = ${Entropy}
// SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
// SPDX-License-Identifier: GPL-3.0-or-later
+import { parentPort } from 'node:worker_threads'
import { Data, Headers } from '#types'
/**
*/
export abstract class WorkerInterface {
static parentPort: any
+ static {
+ NODE: this.parentPort = parentPort
+ }
/**
* Processes data through a worker.
*
* @returns Promise for processed data
*/
static async work (headers: Headers | null, data?: Data): Promise<any> {
- NODE: this.parentPort = (await import('node:worker_threads')).parentPort
return new Promise(async (resolve, reject): Promise<void> => {
try {
let x, y = new ArrayBuffer(0)
*/
static report (results: Headers): void {
const buffers = []
- for (const d of Object.keys(results)) {
- if (results[d] instanceof ArrayBuffer) {
- buffers.push(results[d])
+ try {
+ if (typeof results === 'object') {
+ for (const d of Object.keys(results)) {
+ if (results[d] instanceof ArrayBuffer) {
+ buffers.push(results[d])
+ }
+ }
}
+ } catch (err) {
+ console.error(err)
+ throw new Error('Failed to report results', { cause: err })
}
//@ts-expect-error
- postMessage(results, buffers)
+ BROWSER: postMessage(results, buffers)
+ NODE: parentPort?.postMessage(results, buffers)
}
/**
* ```
*/
static listen (): void {
- const listener = (message: MessageEvent<any>): void => {
+ const listener = async (message: MessageEvent<any>): Promise<void> => {
const { name, headers, data } = message.data
if (name === 'STOP') {
close()
const queue = new Queue()
-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 { process }
-
export const isNode = process.versions?.node != null
+let NodeTestSuite, NodeTestTest
+if (isNode) {
+ ({ suite: NodeTestSuite, test: NodeTestTest } = await import('node:test'))
+}
+
export const failures = []
export const passes = []
function fail (err) {
}
}
-export function suite (name, opts, fn) {
- if (fn === undefined) fn = opts
- return queue.add(async () => {
- if (opts?.skip) {
- console.group(`%cSKIP `, 'color:CornflowerBlue', name)
+export const suite = NodeTestSuite != null
+ ? NodeTestSuite
+ : (name, opts, fn) => {
+ if (fn === undefined) fn = opts
+ return queue.add(async () => {
+ if (opts?.skip) {
+ console.group(`%cSKIP `, 'color:CornflowerBlue', name)
+ console.groupEnd()
+ return
+ }
+ if (fn?.constructor?.name === 'AsyncFunction') fn = fn()
+ if (typeof fn === 'function') fn = new Promise(resolve => resolve(fn()))
+ name === 'TEST RUNNER CHECK'
+ ? console.groupCollapsed(`%c${name}`, 'font-weight:bold')
+ : console.group(`%c${name}`, 'font-weight:bold')
+ await fn
console.groupEnd()
- return
- }
- if (fn?.constructor?.name === 'AsyncFunction') fn = fn()
- if (typeof fn === 'function') fn = new Promise(resolve => resolve(fn()))
- opts?.collapse
- ? console.groupCollapsed(`%c${name}`, 'font-weight:bold')
- : console.group(`%c${name}`, 'font-weight:bold')
- await fn
- console.groupEnd()
- })
-}
+ })
+ }
-export async function test (name, opts, fn) {
- if (opts?.skip) return console.log(`%cSKIP `, 'color:CornflowerBlue', name)
- if (fn === undefined) fn = opts
- if (fn instanceof Promise) {
- try {
- await fn
- pass(name)
- } catch (err) {
- fail(new Error(name, { cause: err }))
- }
- } else if (typeof fn === 'function') {
- try {
- await fn()
- pass(name)
- } catch (err) {
- fail(new Error(name, { cause: err }))
+export const test = NodeTestTest != null
+ ? NodeTestTest
+ : async (name, opts, fn) => {
+ if (opts?.skip) return console.log(`%cSKIP `, 'color:CornflowerBlue', name)
+ if (fn === undefined) fn = opts
+ if (fn instanceof Promise) {
+ try {
+ await fn
+ pass(name)
+ } catch (err) {
+ fail(new Error(name, { cause: err }))
+ }
+ } else if (typeof fn === 'function') {
+ try {
+ await fn()
+ pass(name)
+ } catch (err) {
+ fail(new Error(name, { cause: err }))
+ }
+ } else {
+ fail(new Error(name, { cause: `test cannot execute on ${typeof fn} ${fn}` }))
}
- } else {
- fail(new Error(name, { cause: `test cannot execute on ${typeof fn} ${fn}` }))
}
-}
export const assert = {
ok: (bool) => {
}
return a != null
},
- equals: (a, b) => {
+ equal: (a, b) => {
if (a == null || b == null) {
- throw new Error(`assert.equals() will not compare null or undefined`)
+ throw new Error(`assert.equal() will not compare null or undefined`)
}
if (a !== b) {
throw new Error(`${a} not equal to ${b}`)
}
}
-await suite('TEST RUNNER CHECK', { collapse: true }, async () => {
+await suite('TEST RUNNER CHECK', async () => {
await new Promise(r => setTimeout(r, 0))
console.assert(failures.length === 0)
console.assert(passes.length === 0)
- await test('promise should pass', new Promise(resolve => { resolve('') }))
+ //@ts-expect-error
+ await test('promise should pass', new Promise(resolve => resolve(null)))
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)) === true, `good promise not logged`)
- await test('promise should fail', new Promise((resolve, reject) => { reject('FAILURE EXPECTED HERE') }))
+ //@ts-expect-error
+ await test('promise should fail', new Promise((resolve, reject) => reject('FAILURE EXPECTED HERE')))
console.assert(failures.some(call => /.*promise should fail.*/.test(call)) === true, `bad promise not errored`)
console.assert(passes.some(call => /.*promise should fail.*/.test(call)) === false, 'bad promise logged')
console.assert(failures.some(call => /.*function should pass.*/.test(call)) === false, 'good function errored')
console.assert(passes.some(call => /.*function should pass.*/.test(call)) === true, 'good function not logged')
+ //@ts-expect-error
await test('function should fail', 'FAILURE EXPECTED HERE')
console.assert(failures.some(call => /.*function should fail.*/.test(call)) === true, 'bad function not errored')
console.assert(passes.some(call => /.*function should fail.*/.test(call)) === false, 'bad function logged')
}\r
try {\r
const output = new Blake2b(64, key).update(input).digest('hex')\r
- assert.equals(output, test.out)\r
+ assert.equal(output, test.out)\r
} catch (err) {\r
console.error(`blake2b reference test vector ${i} failed`, { cause: err })\r
}\r
}\r
try {\r
const output = new Blake2b(test.outlen ?? 64, key, salt, personal).update(input).digest('hex')\r
- assert.equals(output, test.out)\r
+ assert.equal(output, test.out)\r
} catch (err) {\r
console.error(`blake2b libsodium test vector ${i} failed`, { cause: err })\r
}\r
'92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D'\r
)\r
assert.notEqual(block.balance, 0)\r
- assert.equals(block.balance, BigInt(0))\r
+ assert.equal(block.balance, BigInt(0))\r
})\r
\r
await test('subtract balance from SendBlock correctly', async () => {\r
NANO_TEST_VECTORS.ADDRESS_2,\r
'92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D'\r
)\r
- assert.equals(block.balance, 1000000000000000000000000000000n)\r
+ assert.equal(block.balance, 1000000000000000000000000000000n)\r
})\r
\r
await test('add balance from ReceiveBlock correctly', async () => {\r
NANO_TEST_VECTORS.ADDRESS_2,\r
'92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D'\r
)\r
- assert.equals(block.balance, 3000000000000000000000000000000n)\r
+ assert.equal(block.balance, 3000000000000000000000000000000n)\r
})\r
})\r
\r
NANO_TEST_VECTORS.OPEN_BLOCK.work\r
)\r
await block.sign(NANO_TEST_VECTORS.OPEN_BLOCK.key)\r
- assert.equals(block.hash, NANO_TEST_VECTORS.OPEN_BLOCK.hash)\r
- assert.equals(block.signature, NANO_TEST_VECTORS.OPEN_BLOCK.signature)\r
+ assert.equal(block.hash, NANO_TEST_VECTORS.OPEN_BLOCK.hash)\r
+ assert.equal(block.signature, NANO_TEST_VECTORS.OPEN_BLOCK.signature)\r
})\r
\r
await test('sign receive block', async () => {\r
NANO_TEST_VECTORS.RECEIVE_BLOCK.work\r
)\r
await block.sign(NANO_TEST_VECTORS.RECEIVE_BLOCK.key)\r
- assert.equals(block.hash, NANO_TEST_VECTORS.RECEIVE_BLOCK.hash)\r
- assert.equals(block.signature, NANO_TEST_VECTORS.RECEIVE_BLOCK.signature)\r
+ assert.equal(block.hash, NANO_TEST_VECTORS.RECEIVE_BLOCK.hash)\r
+ assert.equal(block.signature, NANO_TEST_VECTORS.RECEIVE_BLOCK.signature)\r
})\r
\r
await test('sign receive block without work', async () => {\r
NANO_TEST_VECTORS.RECEIVE_BLOCK.previous\r
)\r
await block.sign(NANO_TEST_VECTORS.RECEIVE_BLOCK.key)\r
- assert.equals(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
+ assert.equal(block.hash, NANO_TEST_VECTORS.RECEIVE_BLOCK.hash)\r
+ assert.equal(block.signature, NANO_TEST_VECTORS.RECEIVE_BLOCK.signature)\r
+ assert.equal(block.work, '')\r
})\r
\r
await test('sign send block', async () => {\r
NANO_TEST_VECTORS.SEND_BLOCK.work\r
)\r
await block.sign(NANO_TEST_VECTORS.SEND_BLOCK.key)\r
- assert.equals(block.hash, NANO_TEST_VECTORS.SEND_BLOCK.hash)\r
- assert.equals(block.signature, NANO_TEST_VECTORS.SEND_BLOCK.signature)\r
+ assert.equal(block.hash, NANO_TEST_VECTORS.SEND_BLOCK.hash)\r
+ assert.equal(block.signature, NANO_TEST_VECTORS.SEND_BLOCK.signature)\r
})\r
\r
await test('sign send block without work', async () => {\r
NANO_TEST_VECTORS.SEND_BLOCK.previous\r
)\r
await block.sign(NANO_TEST_VECTORS.SEND_BLOCK.key)\r
- assert.equals(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
+ assert.equal(block.hash, NANO_TEST_VECTORS.SEND_BLOCK.hash)\r
+ assert.equal(block.signature, NANO_TEST_VECTORS.SEND_BLOCK.signature)\r
+ assert.equal(block.work, '')\r
})\r
\r
await test('sign change rep block', async () => {\r
work,\r
)\r
await block.sign('781186FB9EF17DB6E3D1056550D9FAE5D5BBADA6A6BC370E4CBB938B1DC71DA3') // Did not find a private key at nano docs for this address\r
- assert.equals(block.signature?.toUpperCase(), 'A3C3C66D6519CBC0A198E56855942DEACC6EF741021A1B11279269ADC587DE1DA53CD478B8A47553231104CF24D742E1BB852B0546B87038C19BAE20F9082B0D')\r
- assert.equals(block.work, work)\r
+ assert.equal(block.signature?.toUpperCase(), 'A3C3C66D6519CBC0A198E56855942DEACC6EF741021A1B11279269ADC587DE1DA53CD478B8A47553231104CF24D742E1BB852B0546B87038C19BAE20F9082B0D')\r
+ assert.equal(block.work, work)\r
})\r
\r
await test('sign change rep block without work', async () => {\r
'F3C1D7B6EE97DA09D4C00538CEA93CBA5F74D78FD3FBE71347D2DFE7E53DF327'\r
)\r
await block.sign(NANO_TEST_VECTORS.PRIVATE_0)\r
- assert.equals(block.signature?.toUpperCase(), '2BD2F905E74B5BEE3E2277CED1D1E3F7535E5286B6E22F7B08A814AA9E5C4E1FEA69B61D60B435ADC2CE756E6EE5F5BE7EC691FE87E024A0B22A3D980CA5B305')\r
- assert.equals(block.work, '')\r
+ assert.equal(block.signature?.toUpperCase(), '2BD2F905E74B5BEE3E2277CED1D1E3F7535E5286B6E22F7B08A814AA9E5C4E1FEA69B61D60B435ADC2CE756E6EE5F5BE7EC691FE87E024A0B22A3D980CA5B305')\r
+ assert.equal(block.work, '')\r
})\r
})\r
)\r
await block.pow()\r
\r
- assert.equals(block.previous.length, 64)\r
- assert.equals(block.work?.length, 16)\r
+ assert.equal(block.previous.length, 64)\r
+ assert.equal(block.work?.length, 16)\r
\r
const work = block.work\r
?.match(/.{2}/g)\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
+ assert.equal(bytes.byteLength, 40)\r
\r
const hash = new Blake2b(8)\r
.update(bytes)\r
.slice(8, 16)\r
\r
assert.ok(parseInt(hash.slice(0, 2), 16) > 0xf0)\r
- assert.equals(parseInt(hash.slice(2, 8), 16), 0xffffff)\r
+ assert.equal(parseInt(hash.slice(2, 8), 16), 0xffffff)\r
})\r
})\r
const account = await wallet.account()\r
const privateKey = await account.export(wallet.seed, 'hex')\r
\r
- assert.equals(privateKey, NANO_TEST_VECTORS.PRIVATE_0)\r
- assert.equals(account.publicKey, NANO_TEST_VECTORS.PUBLIC_0)\r
- assert.equals(account.address, NANO_TEST_VECTORS.ADDRESS_0)\r
- assert.equals(account.index, 0)\r
+ assert.equal(privateKey, NANO_TEST_VECTORS.PRIVATE_0)\r
+ assert.equal(account.publicKey, NANO_TEST_VECTORS.PUBLIC_0)\r
+ assert.equal(account.address, NANO_TEST_VECTORS.ADDRESS_0)\r
+ assert.equal(account.index, 0)\r
\r
const accounts = await wallet.accounts()\r
assert.exists(accounts[0])\r
- assert.equals(account, accounts[0])\r
+ assert.equal(account, accounts[0])\r
\r
await wallet.destroy()\r
})\r
const privateKey1 = await accounts[1].export(wallet.seed, 'hex')\r
const privateKey2 = await accounts[2].export(wallet.seed, 'hex')\r
\r
- assert.equals(accounts.length, 2)\r
- assert.equals(privateKey1, NANO_TEST_VECTORS.PRIVATE_1)\r
- assert.equals(accounts[1].publicKey, NANO_TEST_VECTORS.PUBLIC_1)\r
- assert.equals(accounts[1].address, NANO_TEST_VECTORS.ADDRESS_1)\r
- assert.equals(accounts[1].index, 1)\r
- assert.equals(privateKey2, NANO_TEST_VECTORS.PRIVATE_2)\r
- assert.equals(accounts[2].publicKey, NANO_TEST_VECTORS.PUBLIC_2)\r
- assert.equals(accounts[2].address, NANO_TEST_VECTORS.ADDRESS_2)\r
- assert.equals(accounts[2].index, 2)\r
+ assert.equal(accounts.length, 2)\r
+ assert.equal(privateKey1, NANO_TEST_VECTORS.PRIVATE_1)\r
+ assert.equal(accounts[1].publicKey, NANO_TEST_VECTORS.PUBLIC_1)\r
+ assert.equal(accounts[1].address, NANO_TEST_VECTORS.ADDRESS_1)\r
+ assert.equal(accounts[1].index, 1)\r
+ assert.equal(privateKey2, NANO_TEST_VECTORS.PRIVATE_2)\r
+ assert.equal(accounts[2].publicKey, NANO_TEST_VECTORS.PUBLIC_2)\r
+ assert.equal(accounts[2].address, NANO_TEST_VECTORS.ADDRESS_2)\r
+ assert.equal(accounts[2].index, 2)\r
\r
await wallet.destroy()\r
})\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const accounts = await wallet.accounts(0x70000000, 0x7000000f)\r
\r
- assert.equals(accounts.length, 0x10)\r
+ assert.equal(accounts.length, 0x10)\r
for (let i = 0x70000000; i < 0x7000000f; i++) {\r
const a = accounts[i]\r
assert.exists(a)\r
- assert.equals(a.index, i)\r
+ assert.equal(a.index, i)\r
assert.exists(a.address)\r
assert.exists(a.publicKey)\r
const privateKey = await a.export(wallet.seed, 'hex')\r
const account = await wallet.account(1)\r
const privateKey = await account.export(wallet.seed, 'hex')\r
\r
- assert.equals(privateKey, NANO_TEST_VECTORS.BLAKE2B_PRIVATE_1)\r
- // assert.equals(account.publicKey, NANO_TEST_VECTORS.BLAKE2B_PUBLIC_0)\r
- // assert.equals(account.address, NANO_TEST_VECTORS.BLAKE2B_ADDRESS_0)\r
- assert.equals(account.index, 1)\r
+ assert.equal(privateKey, NANO_TEST_VECTORS.BLAKE2B_PRIVATE_1)\r
+ // assert.equal(account.publicKey, NANO_TEST_VECTORS.BLAKE2B_PUBLIC_0)\r
+ // assert.equal(account.address, NANO_TEST_VECTORS.BLAKE2B_ADDRESS_0)\r
+ assert.equal(account.index, 1)\r
\r
const accounts = await wallet.accounts(1)\r
assert.exists(accounts[1])\r
- assert.equals(account, accounts[1])\r
+ assert.equal(account, accounts[1])\r
\r
await wallet.destroy()\r
})\r
// const privateKey1 = await accounts[1].export(wallet.seed, 'hex')\r
// const privateKey2 = await accounts[2].export(wallet.seed, 'hex')\r
\r
- assert.equals(accounts.length, 2)\r
- // assert.equals(privateKey1, NANO_TEST_VECTORS.BLAKE2B_PRIVATE_1)\r
- // assert.equals(accounts[1].publicKey, NANO_TEST_VECTORS.BLAKE2B_PUBLIC_1)\r
- // assert.equals(accounts[1].address, NANO_TEST_VECTORS.BLAKE2B_ADDRESS_1)\r
- assert.equals(accounts[1].index, 1)\r
- // assert.equals(privateKey2, NANO_TEST_VECTORS.BLAKE2B_PRIVATE_2)\r
- // assert.equals(accounts[2].publicKey, NANO_TEST_VECTORS.BLAKE2B_PUBLIC_2)\r
- // assert.equals(accounts[2].address, NANO_TEST_VECTORS.BLAKE2B_ADDRESS_2)\r
- assert.equals(accounts[2].index, 2)\r
+ assert.equal(accounts.length, 2)\r
+ // assert.equal(privateKey1, NANO_TEST_VECTORS.BLAKE2B_PRIVATE_1)\r
+ // assert.equal(accounts[1].publicKey, NANO_TEST_VECTORS.BLAKE2B_PUBLIC_1)\r
+ // assert.equal(accounts[1].address, NANO_TEST_VECTORS.BLAKE2B_ADDRESS_1)\r
+ assert.equal(accounts[1].index, 1)\r
+ // assert.equal(privateKey2, NANO_TEST_VECTORS.BLAKE2B_PRIVATE_2)\r
+ // assert.equal(accounts[2].publicKey, NANO_TEST_VECTORS.BLAKE2B_PUBLIC_2)\r
+ // assert.equal(accounts[2].address, NANO_TEST_VECTORS.BLAKE2B_ADDRESS_2)\r
+ assert.equal(accounts[2].index, 2)\r
\r
await wallet.destroy()\r
})\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const accounts = await wallet.accounts(0x70000000, 0x7000000f)\r
\r
- assert.equals(accounts.length, 0x10)\r
+ assert.equal(accounts.length, 0x10)\r
for (let i = 0x70000000; i < 0x7000000f; i++) {\r
const a = accounts[i]\r
assert.exists(a)\r
- assert.equals(a.index, i)\r
+ assert.equal(a.index, i)\r
assert.exists(a.address)\r
assert.exists(a.publicKey)\r
const privateKey = await a.export(wallet.seed, 'hex')\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
assert.ok(account instanceof Account)\r
- assert.equals(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
- assert.equals(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
- assert.equals(account.publicKey, NANO_TEST_VECTORS.PUBLIC_0)\r
- assert.equals(account.address, NANO_TEST_VECTORS.ADDRESS_0)\r
+ assert.equal(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
+ assert.equal(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
+ assert.equal(account.publicKey, NANO_TEST_VECTORS.PUBLIC_0)\r
+ assert.equal(account.address, NANO_TEST_VECTORS.ADDRESS_0)\r
\r
const privateKey = await account.export(wallet.seed, 'hex')\r
- assert.equals(privateKey, NANO_TEST_VECTORS.PRIVATE_0)\r
+ assert.equal(privateKey, NANO_TEST_VECTORS.PRIVATE_0)\r
\r
await wallet.destroy()\r
})\r
assert.ok('seed' in wallet)\r
assert.ok(account instanceof Account)\r
assert.nullish(wallet.mnemonic)\r
- assert.equals(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
- assert.equals(account.publicKey, NANO_TEST_VECTORS.PUBLIC_0)\r
- assert.equals(account.address, NANO_TEST_VECTORS.ADDRESS_0)\r
+ assert.equal(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
+ assert.equal(account.publicKey, NANO_TEST_VECTORS.PUBLIC_0)\r
+ assert.equal(account.address, NANO_TEST_VECTORS.ADDRESS_0)\r
\r
const privateKey = await account.export(wallet.seed, 'hex')\r
- assert.equals(privateKey, NANO_TEST_VECTORS.PRIVATE_0)\r
+ assert.equal(privateKey, NANO_TEST_VECTORS.PRIVATE_0)\r
\r
await wallet.destroy()\r
})\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const account = await wallet.account()\r
\r
- assert.equals(wallet.mnemonic, CUSTOM_TEST_VECTORS.MNEMONIC_0)\r
- assert.equals(wallet.seed, CUSTOM_TEST_VECTORS.SEED_0)\r
- assert.equals(account.publicKey, CUSTOM_TEST_VECTORS.PUBLIC_0)\r
- assert.equals(account.address, CUSTOM_TEST_VECTORS.ADDRESS_0)\r
+ assert.equal(wallet.mnemonic, CUSTOM_TEST_VECTORS.MNEMONIC_0)\r
+ assert.equal(wallet.seed, CUSTOM_TEST_VECTORS.SEED_0)\r
+ assert.equal(account.publicKey, CUSTOM_TEST_VECTORS.PUBLIC_0)\r
+ assert.equal(account.address, CUSTOM_TEST_VECTORS.ADDRESS_0)\r
\r
const privateKey = await account.export(wallet.seed, 'hex')\r
- assert.equals(privateKey, CUSTOM_TEST_VECTORS.PRIVATE_0)\r
+ assert.equal(privateKey, CUSTOM_TEST_VECTORS.PRIVATE_0)\r
\r
await wallet.destroy()\r
})\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const account = await wallet.account()\r
\r
- assert.equals(wallet.mnemonic, CUSTOM_TEST_VECTORS.MNEMONIC_1)\r
- assert.equals(wallet.seed, CUSTOM_TEST_VECTORS.SEED_1)\r
- assert.equals(account.publicKey, CUSTOM_TEST_VECTORS.PUBLIC_1)\r
- assert.equals(account.address, CUSTOM_TEST_VECTORS.ADDRESS_1)\r
+ assert.equal(wallet.mnemonic, CUSTOM_TEST_VECTORS.MNEMONIC_1)\r
+ assert.equal(wallet.seed, CUSTOM_TEST_VECTORS.SEED_1)\r
+ assert.equal(account.publicKey, CUSTOM_TEST_VECTORS.PUBLIC_1)\r
+ assert.equal(account.address, CUSTOM_TEST_VECTORS.ADDRESS_1)\r
\r
const privateKey = await account.export(wallet.seed, 'hex')\r
- assert.equals(privateKey, CUSTOM_TEST_VECTORS.PRIVATE_1)\r
+ assert.equal(privateKey, CUSTOM_TEST_VECTORS.PRIVATE_1)\r
\r
await wallet.destroy()\r
})\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const account = await wallet.account()\r
\r
- assert.equals(wallet.mnemonic, CUSTOM_TEST_VECTORS.MNEMONIC_2)\r
- assert.equals(wallet.seed, CUSTOM_TEST_VECTORS.SEED_2)\r
- assert.equals(account.publicKey, CUSTOM_TEST_VECTORS.PUBLIC_2)\r
- assert.equals(account.address, CUSTOM_TEST_VECTORS.ADDRESS_2)\r
+ assert.equal(wallet.mnemonic, CUSTOM_TEST_VECTORS.MNEMONIC_2)\r
+ assert.equal(wallet.seed, CUSTOM_TEST_VECTORS.SEED_2)\r
+ assert.equal(account.publicKey, CUSTOM_TEST_VECTORS.PUBLIC_2)\r
+ assert.equal(account.address, CUSTOM_TEST_VECTORS.ADDRESS_2)\r
\r
const privateKey = await account.export(wallet.seed, 'hex')\r
- assert.equals(privateKey, CUSTOM_TEST_VECTORS.PRIVATE_2)\r
+ assert.equal(privateKey, CUSTOM_TEST_VECTORS.PRIVATE_2)\r
\r
await wallet.destroy()\r
})\r
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const account = await wallet.account()\r
\r
- assert.equals(wallet.mnemonic, CUSTOM_TEST_VECTORS.MNEMONIC_3)\r
- assert.equals(wallet.seed, CUSTOM_TEST_VECTORS.SEED_3)\r
- assert.equals(account.publicKey, CUSTOM_TEST_VECTORS.PUBLIC_3)\r
- assert.equals(account.address, CUSTOM_TEST_VECTORS.ADDRESS_3)\r
+ assert.equal(wallet.mnemonic, CUSTOM_TEST_VECTORS.MNEMONIC_3)\r
+ assert.equal(wallet.seed, CUSTOM_TEST_VECTORS.SEED_3)\r
+ assert.equal(account.publicKey, CUSTOM_TEST_VECTORS.PUBLIC_3)\r
+ assert.equal(account.address, CUSTOM_TEST_VECTORS.ADDRESS_3)\r
\r
const privateKey = await account.export(wallet.seed, 'hex')\r
- assert.equals(privateKey, CUSTOM_TEST_VECTORS.PRIVATE_3)\r
+ assert.equal(privateKey, CUSTOM_TEST_VECTORS.PRIVATE_3)\r
\r
await wallet.destroy()\r
})\r
\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\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
+ 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
\r
for (let i = 0; i < accounts.length; i++) {\r
assert.exists(accounts[i])\r
\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\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
+ 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
\r
for (let i = 0; i < accounts.length; i++) {\r
assert.exists(accounts[i])\r
\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equals(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_1)\r
- assert.equals(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_1)\r
+ assert.equal(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_1)\r
+ assert.equal(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_1)\r
\r
assert.ok(accounts[0] instanceof Account)\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.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
const privateKey0 = await accounts[0].export(wallet.seed, 'hex')\r
- assert.equals(privateKey0, TREZOR_TEST_VECTORS.BLAKE2B_1_PRIVATE_0)\r
+ assert.equal(privateKey0, TREZOR_TEST_VECTORS.BLAKE2B_1_PRIVATE_0)\r
\r
assert.ok(accounts[1] instanceof Account)\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
+ 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
const privateKey1 = await accounts[1].export(wallet.seed, 'hex')\r
- assert.equals(privateKey1, TREZOR_TEST_VECTORS.BLAKE2B_1_PRIVATE_1)\r
+ assert.equal(privateKey1, TREZOR_TEST_VECTORS.BLAKE2B_1_PRIVATE_1)\r
\r
await wallet.destroy()\r
})\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
assert.exists(walletAccount)\r
- assert.equals(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_2)\r
+ assert.equal(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 importedAccount = await imported.account()\r
const importedAccountPrivateKey = await importedAccount.export(imported.seed, 'hex')\r
\r
- assert.equals(imported.mnemonic, wallet.mnemonic)\r
- assert.equals(imported.seed, wallet.seed)\r
- assert.equals(importedAccount.publicKey, walletAccount.publicKey)\r
- assert.equals(importedAccountPrivateKey, walletAccountPrivateKey)\r
+ assert.equal(imported.mnemonic, wallet.mnemonic)\r
+ assert.equal(imported.seed, wallet.seed)\r
+ assert.equal(importedAccount.publicKey, walletAccount.publicKey)\r
+ assert.equal(importedAccountPrivateKey, walletAccountPrivateKey)\r
\r
await wallet.destroy()\r
})\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
assert.ok(account instanceof Account)\r
- assert.equals(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_3)\r
- assert.equals(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_3)\r
- assert.equals(account.publicKey, TREZOR_TEST_VECTORS.BLAKE2B_3_PUBLIC_0)\r
- assert.equals(account.address, TREZOR_TEST_VECTORS.BLAKE2B_3_ADDRESS_0)\r
+ assert.equal(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_3)\r
+ assert.equal(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_3)\r
+ assert.equal(account.publicKey, TREZOR_TEST_VECTORS.BLAKE2B_3_PUBLIC_0)\r
+ assert.equal(account.address, TREZOR_TEST_VECTORS.BLAKE2B_3_ADDRESS_0)\r
\r
const privateKey = await account.export(wallet.seed, 'hex')\r
- assert.equals(privateKey, TREZOR_TEST_VECTORS.BLAKE2B_3_PRIVATE_0)\r
+ assert.equal(privateKey, TREZOR_TEST_VECTORS.BLAKE2B_3_PRIVATE_0)\r
\r
await wallet.destroy()\r
})\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
assert.nullish(wallet.mnemonic)\r
- assert.equals(wallet.seed, '')\r
+ assert.equal(wallet.seed, '')\r
\r
const unlockResult = await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
\r
- assert.equals(unlockResult, true)\r
+ assert.equal(unlockResult, true)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equals(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
- assert.equals(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
+ assert.equal(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
+ assert.equal(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
\r
await wallet.destroy()\r
})\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
assert.nullish(wallet.mnemonic)\r
- assert.equals(wallet.seed, '')\r
+ assert.equal(wallet.seed, '')\r
\r
const unlockResult = await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
\r
- assert.equals(unlockResult, true)\r
+ assert.equal(unlockResult, true)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equals(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_0)\r
- assert.equals(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_0)\r
+ assert.equal(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_0)\r
+ assert.equal(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_0)\r
\r
await wallet.destroy()\r
})\r
await test('request permissions', async () => {
wallet = await LedgerWallet.create()
let status = wallet.status
- assert.equals(status, 'DISCONNECTED')
- assert.equals(status, wallet.status)
+ assert.equal(status, 'DISCONNECTED')
+ assert.equal(status, wallet.status)
status = await click(
'Reset permissions, unlock device, quit Nano app, then click to continue',
async () => wallet.connect()
)
- assert.equals(status, 'BUSY')
- assert.equals(status, wallet.status)
+ assert.equal(status, 'BUSY')
+ assert.equal(status, wallet.status)
status = await click(
'Open Nano app on device, allow device to auto-lock, then click to continue',
async () => wallet.connect()
)
- assert.equals(status, 'LOCKED')
- assert.equals(status, wallet.status)
+ assert.equal(status, 'LOCKED')
+ assert.equal(status, wallet.status)
status = await click(
'Unlock device, verify Nano app is open, then click to continue',
async () => wallet.connect()
)
- assert.equals(status, 'CONNECTED')
- assert.equals(status, wallet.status)
+ assert.equal(status, 'CONNECTED')
+ assert.equal(status, wallet.status)
})
await test('get version', async () => {
const { status, name, version } = await wallet.version()
- assert.equals(status, 'OK')
- assert.equals(name, 'Nano')
- assert.equals(version, '1.2.6')
+ assert.equal(status, 'OK')
+ assert.equal(name, 'Nano')
+ assert.equal(version, '1.2.6')
})
await test('get first account', async () => {
assert.exists(account.address)
assert.exists(account.publicKey)
assert.exists(account.privateKey)
- assert.equals(account.privateKey, '0000000000000000000000000000000000000000000000000000000000000000')
+ assert.equal(account.privateKey, '0000000000000000000000000000000000000000000000000000000000000000')
})
await test('get second and third accounts', async () => {
const accounts = await wallet.accounts(1, 2)
assert.exists(accounts)
- assert.equals(accounts.length, 2)
+ assert.equal(accounts.length, 2)
for (const account of accounts) {
assert.ok(account instanceof Account)
assert.exists(account.address)
assert.exists(account.publicKey)
assert.exists(account.privateKey)
- assert.equals(account.privateKey, '0000000000000000000000000000000000000000000000000000000000000000')
+ assert.equal(account.privateKey, '0000000000000000000000000000000000000000000000000000000000000000')
}
})
assert.ok(account.balance >= 0)
assert.exists(account.publicKey)
assert.exists(account.privateKey)
- assert.equals(account.privateKey, '0000000000000000000000000000000000000000000000000000000000000000')
+ assert.equal(account.privateKey, '0000000000000000000000000000000000000000000000000000000000000000')
}
})
assert.ok(/^[A-Fa-f0-9]{64}$/.test(openBlock.hash))
assert.nullish(openBlock.signature)
- assert.equals(openBlock.account.publicKey, account.publicKey)
+ assert.equal(openBlock.account.publicKey, account.publicKey)
const { status, hash, signature } = await wallet.sign(0, openBlock)
- assert.equals(status, 'OK')
+ assert.equal(status, 'OK')
assert.ok(/^[A-Fa-f0-9]{64}$/.test(hash))
assert.ok(/^[A-Fa-f0-9]{128}$/.test(signature))
await openBlock.sign(0)
assert.ok(/^[A-Fa-f0-9]{128}$/.test(openBlock.signature))
- assert.equals(signature, openBlock.signature)
+ assert.equal(signature, openBlock.signature)
})
await test('cache open block', async () => {
const { status } = await wallet.updateCache(0, openBlock)
- assert.equals(status, 'OK')
+ assert.equal(status, 'OK')
})
await test('sign send block from wallet which requires cache to be up-to-date', async () => {
assert.ok(/^[A-Fa-f0-9]{64}$/.test(sendBlock.hash))
assert.nullish(sendBlock.signature)
- assert.equals(sendBlock.account.publicKey, account.publicKey)
+ assert.equal(sendBlock.account.publicKey, account.publicKey)
const { status, hash, signature } = await wallet.sign(0, sendBlock)
- assert.equals(status, 'OK')
+ assert.equal(status, 'OK')
assert.ok(/^[A-Fa-f0-9]{64}$/.test(hash))
assert.ok(/^[A-Fa-f0-9]{128}$/.test(signature))
sendBlock.signature = signature
assert.ok(/^[A-Fa-f0-9]{64}$/.test(sendBlock.hash))
assert.nullish(receiveBlock.signature)
- assert.equals(receiveBlock.account.publicKey, account.publicKey)
+ assert.equal(receiveBlock.account.publicKey, account.publicKey)
await receiveBlock.sign(0, sendBlock)
const nonce = new TextEncoder().encode('0123456789abcdef')
const { status, signature } = await click('Click to sign nonce', wallet.sign(0, nonce))
- assert.equals(status, 'OK')
+ assert.equal(status, 'OK')
assert.OK(/^[A-Fa-f0-9]{128}$/.test(signature))
})
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
assert.nullish(wallet.mnemonic)\r
- assert.equals(wallet.seed, '')\r
+ assert.equal(wallet.seed, '')\r
\r
const unlockResult = await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
\r
- assert.equals(unlockResult, true)\r
+ assert.equal(unlockResult, true)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equals(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
- assert.equals(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
+ assert.equal(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
+ assert.equal(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
\r
await wallet.destroy()\r
})\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
assert.nullish(wallet.mnemonic)\r
- assert.equals(wallet.seed, '')\r
+ assert.equal(wallet.seed, '')\r
\r
const unlockResult = await wallet.unlock(new Uint8Array(key))\r
\r
- assert.equals(unlockResult, true)\r
+ assert.equal(unlockResult, true)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equals(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
- assert.equals(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
+ assert.equal(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
+ assert.equal(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
\r
await wallet.destroy()\r
})\r
const account = await wallet.account()\r
const lockResult = await wallet.lock(NANO_TEST_VECTORS.PASSWORD)\r
\r
- assert.equals(lockResult, true)\r
+ assert.equal(lockResult, true)\r
\r
const unlockResult = await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const privateKey = await account.export(wallet.seed, 'hex')\r
\r
- assert.equals(unlockResult, true)\r
- assert.equals(privateKey, NANO_TEST_VECTORS.PRIVATE_0)\r
+ assert.equal(unlockResult, true)\r
+ assert.equal(privateKey, NANO_TEST_VECTORS.PRIVATE_0)\r
\r
await wallet.destroy()\r
})\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.equals(lockResult, true)\r
+ assert.equal(lockResult, true)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
assert.nullish(wallet.mnemonic)\r
const lockResult = await wallet.lock(new Uint8Array(rightKey))\r
\r
await assert.rejects(wallet.unlock(new Uint8Array(wrongKey)), { message: 'Failed to unlock wallet' })\r
- assert.equals(lockResult, true)\r
+ assert.equal(lockResult, true)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
assert.nullish(wallet.mnemonic)\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.equals(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
- assert.equals(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
+ assert.equal(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
+ assert.equal(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
\r
await wallet.lock('password')\r
\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.equals(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
- assert.equals(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
+ assert.equal(wallet.mnemonic, NANO_TEST_VECTORS.MNEMONIC)\r
+ assert.equal(wallet.seed, NANO_TEST_VECTORS.BIP39_SEED)\r
\r
await wallet.lock(NANO_TEST_VECTORS.PASSWORD)\r
\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
assert.nullish(wallet.mnemonic)\r
- assert.equals(wallet.seed, '')\r
+ assert.equal(wallet.seed, '')\r
\r
const unlockResult = await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
\r
- assert.equals(unlockResult, true)\r
+ assert.equal(unlockResult, true)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equals(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_0)\r
- assert.equals(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_0)\r
+ assert.equal(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_0)\r
+ assert.equal(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_0)\r
\r
await wallet.destroy()\r
})\r
const key = globalThis.crypto.getRandomValues(new Uint8Array(64))\r
const lockResult = await wallet.lock(new Uint8Array(key))\r
\r
- assert.equals(lockResult, true)\r
+ assert.equal(lockResult, true)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
assert.nullish(wallet.mnemonic)\r
- assert.equals(wallet.seed, '')\r
+ assert.equal(wallet.seed, '')\r
\r
const unlockResult = await wallet.unlock(new Uint8Array(key))\r
\r
- assert.equals(lockResult, true)\r
- assert.equals(unlockResult, true)\r
+ assert.equal(lockResult, true)\r
+ assert.equal(unlockResult, true)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
- assert.equals(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_1)\r
- assert.equals(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_1)\r
+ assert.equal(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_1)\r
+ assert.equal(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_1)\r
\r
await wallet.destroy()\r
})\r
const account = await wallet.account()\r
const lockResult = await wallet.lock(NANO_TEST_VECTORS.PASSWORD)\r
\r
- assert.equals(lockResult, true)\r
+ assert.equal(lockResult, true)\r
\r
const unlockResult = await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)\r
const privateKey = await account.export(wallet.seed, 'hex')\r
\r
- assert.equals(unlockResult, true)\r
- assert.equals(privateKey, TREZOR_TEST_VECTORS.BLAKE2B_PRIVATE_0)\r
+ assert.equal(unlockResult, true)\r
+ assert.equal(privateKey, TREZOR_TEST_VECTORS.BLAKE2B_PRIVATE_0)\r
\r
await wallet.destroy()\r
})\r
const lockResult = await wallet.lock(new Uint8Array(rightKey))\r
\r
await assert.rejects(wallet.unlock(new Uint8Array(wrongKey)), { message: 'Failed to unlock wallet' })\r
- assert.equals(lockResult, true)\r
+ assert.equal(lockResult, true)\r
assert.ok('mnemonic' in wallet)\r
assert.ok('seed' in wallet)\r
assert.nullish(wallet.mnemonic)\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.equals(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_1)\r
- assert.equals(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_1)\r
+ assert.equal(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_1)\r
+ assert.equal(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_1)\r
\r
await wallet.lock(NANO_TEST_VECTORS.PASSWORD)\r
\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.equals(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_1)\r
- assert.equals(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_1)\r
+ assert.equal(wallet.mnemonic, TREZOR_TEST_VECTORS.MNEMONIC_1)\r
+ assert.equal(wallet.seed, TREZOR_TEST_VECTORS.ENTROPY_1)\r
\r
await wallet.lock(NANO_TEST_VECTORS.PASSWORD)\r
\r
await test('should create a rolodex and add two contacts', async () => {
const rolodex = new Rolodex()
- assert.equals(rolodex.constructor, Rolodex)
+ assert.equal(rolodex.constructor, Rolodex)
await rolodex.add('JohnDoe', NANO_TEST_VECTORS.ADDRESS_0)
await rolodex.add('JaneSmith', 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)
+ 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)
})
await test('should get a name from an address', async () => {
const rolodex = new Rolodex()
await rolodex.add('JohnDoe', NANO_TEST_VECTORS.ADDRESS_0)
- assert.equals(rolodex.getName(NANO_TEST_VECTORS.ADDRESS_0), 'JohnDoe')
+ assert.equal(rolodex.getName(NANO_TEST_VECTORS.ADDRESS_0), 'JohnDoe')
})
await test('should add three addresses to the same contact', async () => {
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.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)
+ 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)
})
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.equals(rolodex.getAddresses('JohnDoe').length, 0)
- assert.equals(rolodex.getAddresses('JaneSmith').length, 1)
- assert.equals(rolodex.getAddresses('JaneSmith')[0], 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)
})
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.equals(Array.isArray(rolodex.getAddresses('JaneSmith')), true)
- assert.equals(rolodex.getAddresses('JaneSmith').length, 0)
+ assert.equal(Array.isArray(rolodex.getAddresses('JaneSmith')), true)
+ assert.equal(rolodex.getAddresses('JaneSmith').length, 0)
})
await test('should return empty address array for blank contact names', () => {
const rolodex = new Rolodex()
//@ts-expect-error
- assert.equals(Array.isArray(rolodex.getAddresses(undefined)), true)
+ assert.equal(Array.isArray(rolodex.getAddresses(undefined)), true)
//@ts-expect-error
- assert.equals(rolodex.getAddresses(undefined).length, 0)
+ assert.equal(rolodex.getAddresses(undefined).length, 0)
//@ts-expect-error
- assert.equals(Array.isArray(rolodex.getAddresses(null)), true)
+ assert.equal(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)
+ assert.equal(rolodex.getAddresses(null).length, 0)
+ assert.equal(Array.isArray(rolodex.getAddresses('')), true)
+ assert.equal(rolodex.getAddresses('').length, 0)
})
await test('should return null for an unknown address', async () => {
const rolodex = new Rolodex()
await rolodex.add('JohnDoe', NANO_TEST_VECTORS.ADDRESS_0)
const result = await rolodex.verify('JohnDoe', signature, data)
- assert.equals(result, true)
+ assert.equal(result, true)
})
await test('should reject incorrect contact for signature', async () => {
const rolodex = new Rolodex()
await rolodex.add('JaneSmith', NANO_TEST_VECTORS.ADDRESS_1)
const result = await rolodex.verify('JaneSmith', signature, data)
- assert.equals(result, false)
+ assert.equal(result, false)
})
})
assert.exists(account.balance)
assert.notEqual(account.balance, '')
- assert.equals(typeof account.balance, 'bigint')
+ assert.equal(typeof account.balance, 'bigint')
assert.ok(account.balance >= 0)
assert.exists(account.frontier)
- assert.equals(typeof account.frontier, 'string')
+ assert.equal(typeof account.frontier, 'string')
assert.notEqual(account.frontier, '')
assert.ok(/^[A-Fa-f0-9]{64}$/.test(account.frontier))
assert.exists(account.representative)
assert.notEqual(account.representative, '')
- assert.equals(account.representative.constructor, Account)
+ assert.equal(account.representative.constructor, Account)
assert.exists(account.representative?.address)
assert.notEqual(account.representative?.address, '')
const account = await wallet.unopened(rpc)
assert.exists(account)
- assert.equals(account.address, NANO_TEST_VECTORS.ADDRESS_1)
- assert.equals(account.publicKey, NANO_TEST_VECTORS.PUBLIC_1)
+ assert.equal(account.address, NANO_TEST_VECTORS.ADDRESS_1)
+ assert.equal(account.publicKey, NANO_TEST_VECTORS.PUBLIC_1)
await wallet.destroy()
})
const account = await wallet.unopened(rpc, 1)
assert.exists(account)
- assert.equals(account.address, NANO_TEST_VECTORS.ADDRESS_1)
- assert.equals(account.publicKey, NANO_TEST_VECTORS.PUBLIC_1)
+ assert.equal(account.address, NANO_TEST_VECTORS.ADDRESS_1)
+ assert.equal(account.publicKey, NANO_TEST_VECTORS.PUBLIC_1)
await wallet.destroy()
})
const account = await wallet.unopened(rpc, 100)
assert.exists(account)
- assert.equals(account.address, NANO_TEST_VECTORS.ADDRESS_1)
- assert.equals(account.publicKey, NANO_TEST_VECTORS.PUBLIC_1)
+ assert.equal(account.address, NANO_TEST_VECTORS.ADDRESS_1)
+ assert.equal(account.publicKey, NANO_TEST_VECTORS.PUBLIC_1)
await wallet.destroy()
})
const account = accounts[0]
assert.ok(account instanceof Account)
- assert.equals(typeof account.balance, 'bigint')
+ assert.equal(typeof account.balance, 'bigint')
assert.exists(account.frontier)
- assert.equals(typeof account.frontier, 'string')
+ assert.equal(typeof account.frontier, 'string')
await wallet.destroy()
})
await wallet.unlock(NANO_TEST_VECTORS.PASSWORD)
const accounts = await wallet.refresh(rpc, 0, 2)
- assert.equals(accounts.length, 1)
+ assert.equal(accounts.length, 1)
assert.ok(accounts[0] instanceof Account)
await wallet.destroy()
\r
await test('should convert nano to raw', async () => {\r
const result = await Tools.convert('1', 'NANO', 'RAW')\r
- assert.equals(result, '1000000000000000000000000000000')\r
+ assert.equal(result, '1000000000000000000000000000000')\r
})\r
\r
await test('should convert raw to nano', async () => {\r
const result = await Tools.convert('1000000000000000000000000000000', 'RAW', 'NANO')\r
- assert.equals(result, '1')\r
+ assert.equal(result, '1')\r
})\r
\r
await test('should convert 1 raw to 10^-29 nano', async () => {\r
const result = await Tools.convert('1', 'RAW', 'NANO')\r
- assert.equals(result, '.000000000000000000000000000001')\r
+ assert.equal(result, '.000000000000000000000000000001')\r
})\r
\r
await test('should ignore leading and trailing zeros', async () => {\r
const result = await Tools.convert('0011002200.0033004400', 'nano', 'nano')\r
- assert.equals(result, '11002200.00330044')\r
+ assert.equal(result, '11002200.00330044')\r
})\r
\r
await test('should convert raw to nyano', async () => {\r
const result = await Tools.convert(RAW_MAX, 'RAW', 'NYANO')\r
- assert.equals(result, '340282366920938.463463374607431768211455')\r
+ assert.equal(result, '340282366920938.463463374607431768211455')\r
})\r
\r
await test('should convert case-insensitive nyano to raw', async () => {\r
const result = await Tools.convert('0.000000000000000123456789', 'nYaNo', 'rAw')\r
- assert.equals(result, '123456789')\r
+ assert.equal(result, '123456789')\r
})\r
\r
await test('should convert nano to pico', async () => {\r
const result = await Tools.convert('123.456', 'nano', 'pico')\r
- assert.equals(result, '123456')\r
+ assert.equal(result, '123456')\r
})\r
\r
await test('should convert knano to pico', async () => {\r
const result = await Tools.convert('123.456', 'nano', 'pico')\r
- assert.equals(result, '123456')\r
+ assert.equal(result, '123456')\r
})\r
\r
await test('should throw if amount exceeds raw max', async () => {\r
\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.equals(result, 'FECB9B084065ADC969904B55A0099C63746B68DF41FECB713244D387EED83A80B9D4907278C5EBC0998A5FC8BA597FBAAABBFCE0ABD2CA2212ACFE788637040C')\r
+ assert.equal(result, 'FECB9B084065ADC969904B55A0099C63746B68DF41FECB713244D387EED83A80B9D4907278C5EBC0998A5FC8BA597FBAAABBFCE0ABD2CA2212ACFE788637040C')\r
})\r
\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.equals(result, 'BB534F9B469AF451B1941FFEF8EE461FC5D284B5D393140900C6E13A65EF08D0AE2BC77131EE182922F66C250C7237A83878160457D5C39A70E55F7FCE925804')\r
+ assert.equal(result, 'BB534F9B469AF451B1941FFEF8EE461FC5D284B5D393140900C6E13A65EF08D0AE2BC77131EE182922F66C250C7237A83878160457D5C39A70E55F7FCE925804')\r
})\r
\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.equals(result, true)\r
+ assert.equal(result, true)\r
\r
const result2 = await Tools.verify(NANO_TEST_VECTORS.PUBLIC_0, 'FECB9B084065ADC969904B55A0099C63746B68DF41FECB713244D387EED83A80B9D4907278C5EBC0998A5FC8BA597FBAAABBFCE0ABD2CA2212ACFE788637040C', 'mir@metsanheimo.fi')\r
- assert.equals(result2, false)\r
+ assert.equal(result2, false)\r
\r
const result3 = await Tools.verify(NANO_TEST_VECTORS.PUBLIC_0, 'AECB9B084065ADC969904B55A0099C63746B68DF41FECB713244D387EED83A80B9D4907278C5EBC0998A5FC8BA597FBAAABBFCE0ABD2CA2212ACFE788637040C', 'miro@metsanheimo.fi')\r
- assert.equals(result3, false)\r
+ assert.equal(result3, false)\r
})\r
\r
await test('should verify a block using the public key', async () => {\r
)\r
await sendBlock.sign(privateKey)\r
const valid = await sendBlock.verify(account.publicKey)\r
- assert.equals(valid, true)\r
+ assert.equal(valid, true)\r
\r
await wallet.destroy()\r
})\r
\r
sendBlock.account = Account.import('nano_1q3hqecaw15cjt7thbtxu3pbzr1eihtzzpzxguoc37bj1wc5ffoh7w74gi6p')\r
const valid = await sendBlock.verify(account.publicKey)\r
- assert.equals(valid, false)\r
+ assert.equal(valid, false)\r
\r
await wallet.destroy()\r
})\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.equals(results.length, 1)\r
+ assert.equal(results.length, 1)\r
\r
await wallet.destroy()\r
})\r
projects / libnemo.git / commitdiff