try {
const account = await Account.import({ index: 0, privateKey: input }, '')
this.signature = await account.sign(this, '')
+ await account.destroy()
} catch (err) {
throw new Error(`Failed to sign block`, { cause: err })
}
assert.ok('seed' in wallet)\r
assert.ok(/^[A-Fa-f0-9]{128}$/.test(wallet.seed))\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('BLAKE2b wallet with random entropy', async () => {\r
assert.ok('seed' in wallet)\r
assert.ok(/^[A-Fa-f0-9]{64}$/.test(wallet.seed))\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\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
const wallet = Bip44Wallet.create(NANO_TEST_VECTORS.PASSWORD, arg)\r
- await assert.resolves(wallet);\r
- (await wallet).destroy()\r
+ await assert.resolves(wallet)\r
+ await assert.resolves((await wallet).destroy())\r
}\r
})\r
\r
assert.exists(accounts[0])\r
assert.equal(account, accounts[0])\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('derive low indexed accounts from the given BIP-44 seed', async () => {\r
assert.equal(accounts[2].address, NANO_TEST_VECTORS.ADDRESS_2)\r
assert.equal(accounts[2].index, 2)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('derive high indexed accounts from the given seed', async () => {\r
assert.exists(privateKey)\r
}\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
}),\r
\r
assert.exists(accounts[1])\r
assert.equal(account, accounts[1])\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('derive low indexed accounts from the given BLAKE2B seed', async () => {\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
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('derive high indexed accounts from the given seed', async () => {\r
assert.exists(privateKey)\r
}\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
})\r
])\r
const privateKey = await account.export(wallet.seed, 'hex')\r
assert.equal(privateKey, NANO_TEST_VECTORS.PRIVATE_0)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('nano.org BIP-44 test vector seed with no mnemonic', async () => {\r
const privateKey = await account.export(wallet.seed, 'hex')\r
assert.equal(privateKey, NANO_TEST_VECTORS.PRIVATE_0)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('Trezor-derived BIP-44 entropy for 12-word mnemonic', async () => {\r
const privateKey = await account.export(wallet.seed, 'hex')\r
assert.equal(privateKey, CUSTOM_TEST_VECTORS.PRIVATE_0)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('Trezor-derived BIP-44 entropy for 15-word mnemonic', async () => {\r
const privateKey = await account.export(wallet.seed, 'hex')\r
assert.equal(privateKey, CUSTOM_TEST_VECTORS.PRIVATE_1)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('Trezor-derived BIP-44 entropy for 18-word mnemonic', async () => {\r
const privateKey = await account.export(wallet.seed, 'hex')\r
assert.equal(privateKey, CUSTOM_TEST_VECTORS.PRIVATE_2)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('Trezor-derived BIP-44 entropy for 21-word mnemonic', async () => {\r
const privateKey = await account.export(wallet.seed, 'hex')\r
assert.equal(privateKey, CUSTOM_TEST_VECTORS.PRIVATE_3)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('BIP-44 zero-string entropy', async () => {\r
assert.exists(privateKey)\r
}\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('BLAKE2b zero-string seed', async () => {\r
assert.exists(privateKey)\r
}\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('Trezor-derived BLAKE2b test vectors verified with third-party libraries', async () => {\r
const privateKey1 = await accounts[1].export(wallet.seed, 'hex')\r
assert.equal(privateKey1, TREZOR_TEST_VECTORS.BLAKE2B_1_PRIVATE_1)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('BLAKE2b seed creates identical wallet as its derived mnemonic', async () => {\r
assert.equal(importedAccount.publicKey, walletAccount.publicKey)\r
assert.equal(importedAccountPrivateKey, walletAccountPrivateKey)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
+ await assert.resolves(imported.destroy())\r
})\r
\r
await test('BLAKE2b mnemonic for maximum seed value', async () => {\r
const privateKey = await account.export(wallet.seed, 'hex')\r
assert.equal(privateKey, TREZOR_TEST_VECTORS.BLAKE2B_3_PRIVATE_0)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('Reject invalid entropy', async () => {\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
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('Import BLAKE2B wallet from session storage using a wallet-generated ID', async () => {\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
+ await assert.resolves(wallet.destroy())\r
})\r
})\r
])\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
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('locking and unlocking a Bip44Wallet with random bytes', async () => {\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
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('locking and unlocking a Bip44Wallet Account with a password', async () => {\r
assert.equal(unlockResult, true)\r
assert.equal(privateKey, NANO_TEST_VECTORS.PRIVATE_0)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('fail to unlock a Bip44Wallet with different passwords', async () => {\r
assert.nullish(wallet.mnemonic)\r
assert.nullish(wallet.seed)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('fail to unlock a Bip44Wallet with different random bytes', async () => {\r
assert.nullish(wallet.mnemonic)\r
assert.nullish(wallet.seed)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('fail to unlock a Bip44Wallet with different valid inputs', async () => {\r
assert.nullish(wallet.mnemonic)\r
assert.nullish(wallet.seed)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('fail to unlock a Bip44Wallet with no input', async () => {\r
assert.nullish(wallet.mnemonic)\r
assert.nullish(wallet.seed)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('fail to unlock a Bip44Wallet with invalid input', async () => {\r
assert.nullish(wallet.mnemonic)\r
assert.nullish(wallet.seed)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('locking and unlocking a Blake2bWallet with a password', async () => {\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
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('locking and unlocking a Blake2bWallet with random bytes', async () => {\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
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('locking and unlocking a Blake2bWallet Account with a password', async () => {\r
assert.equal(unlockResult, true)\r
assert.equal(privateKey, TREZOR_TEST_VECTORS.BLAKE2B_PRIVATE_0)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('fail to unlock a Blake2bWallet with different passwords', async () => {\r
assert.nullish(wallet.mnemonic)\r
assert.nullish(wallet.seed)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('fail to unlock a Blake2bWallet with different keys', async () => {\r
assert.nullish(wallet.mnemonic)\r
assert.nullish(wallet.seed)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('fail to unlock a Blake2bWallet with different valid inputs', async () => {\r
assert.nullish(wallet.mnemonic)\r
assert.nullish(wallet.seed)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('fail to unlock a Blake2bWallet with no input', async () => {\r
assert.nullish(wallet.mnemonic)\r
assert.nullish(wallet.seed)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('fail to unlock a Blake2bWallet with invalid input', async () => {\r
assert.nullish(wallet.mnemonic)\r
assert.nullish(wallet.seed)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
})\r
])\r
assert.exists(account.representative?.address)
assert.notEqual(account.representative?.address, '')
- await wallet.destroy()
+ await assert.resolves(wallet.destroy())
})
await test('throw when refreshing unopened account', async () => {
await assert.rejects(account.refresh(rpc),
{ message: 'Account not found' })
- await wallet.destroy()
+ await assert.resolves(wallet.destroy())
})
await test('throw when referencing invalid account index', async () => {
await assert.rejects(wallet.account(0x80000000),
{ message: 'Invalid child key index 0x80000000' })
- await wallet.destroy()
+ await assert.resolves(wallet.destroy())
})
await test('throw with invalid node', async () => {
await assert.rejects(account.refresh(invalidNode),
{ message: 'Account not found' })
- await wallet.destroy()
+ await assert.resolves(wallet.destroy())
})
}),
assert.equal(account.address, NANO_TEST_VECTORS.ADDRESS_1)
assert.equal(account.publicKey, NANO_TEST_VECTORS.PUBLIC_1)
- await wallet.destroy()
+ await assert.resolves(wallet.destroy())
})
await test('return successfully for small batch size', async () => {
assert.equal(account.address, NANO_TEST_VECTORS.ADDRESS_1)
assert.equal(account.publicKey, NANO_TEST_VECTORS.PUBLIC_1)
- await wallet.destroy()
+ await assert.resolves(wallet.destroy())
})
await test('return successfully for large batch size', async () => {
assert.equal(account.address, NANO_TEST_VECTORS.ADDRESS_1)
assert.equal(account.publicKey, NANO_TEST_VECTORS.PUBLIC_1)
- await wallet.destroy()
+ await assert.resolves(wallet.destroy())
})
await test('should throw on invalid node URL', async () => {
await assert.rejects(wallet.unopened(''))
await assert.rejects(wallet.unopened('foo'))
- await wallet.destroy()
+ await assert.resolves(wallet.destroy())
})
await test('should throw on invalid batch size', async () => {
await assert.rejects(wallet.unopened(rpc, 'foo'))
await assert.rejects(wallet.unopened(rpc, { 'foo': 'bar' }))
- await wallet.destroy()
+ await assert.resolves(wallet.destroy())
})
}),
assert.exists(account.frontier)
assert.equal(typeof account.frontier, 'string')
- await wallet.destroy()
+ await assert.resolves(wallet.destroy())
})
await test('should get balance, frontier, and representative for multiple accounts', async () => {
assert.equal(accounts.length, 1)
assert.ok(accounts[0] instanceof Account)
- await wallet.destroy()
+ await assert.resolves(wallet.destroy())
})
await test('should handle failure gracefully', async () => {
await assert.resolves(wallet.refresh(rpc, 0, 20))
- await wallet.destroy()
+ await assert.resolves(wallet.destroy())
})
})
])
const valid = await sendBlock.verify(account.publicKey)\r
assert.equal(valid, true)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('should reject a block using the wrong public key', async () => {\r
const valid = await sendBlock.verify(account.publicKey)\r
assert.equal(valid, false)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(sendBlock.account.destroy())\r
+ await assert.resolves(wallet.destroy())\r
})\r
\r
await test('sweeper throws without required parameters', 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
+\r
assert.ok(results)\r
assert.equal(results.length, 1)\r
\r
- await wallet.destroy()\r
+ await assert.resolves(wallet.destroy())\r
})\r
})\r
])\r