Start updating block calls in tests.

diff --git a/test/perf.block.mjs b/test/perf.block.mjs
index ffadedb07b4e9aa1acbe011392a4a393367a1a97..f1ee95c52440279b8dc42b22fd154ec3ae961608 100644 (file)
--- a/test/perf.block.mjs
+++ b/test/perf.block.mjs
@@ -7,13 +7,13 @@ import { isNode, stats, suite, test } from './GLOBALS.mjs'
 import { NANO_TEST_VECTORS } from './VECTORS.mjs'
 
 /**
-* @type {typeof import('../dist/types.d.ts').SendBlock}
+* @type {typeof import('../dist/types.d.ts').Block}
 */
-let SendBlock
+let Block
 if (isNode) {
-       ({ SendBlock } = await import('../dist/nodejs.min.js'))
+       ({ Block } = await import('../dist/nodejs.min.js'))
 } else {
-       ({ SendBlock } = await import('../dist/browser.min.js'))
+       ({ Block } = await import('../dist/browser.min.js'))
 }
 
 await Promise.all([
@@ -21,15 +21,11 @@ await Promise.all([
                const COUNT = 0x200
 
                await test(`libnemo: Time to calculate proof-of-work for a send block ${COUNT} times`, { skip: true }, async () => {
+                       const { account, balance, previous, representative } = NANO_TEST_VECTORS.SEND_BLOCK
                        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
-                       )
+                       const block = new Block(account, balance, representative, previous)
+                               .send(0)
+                               .to(NANO_TEST_VECTORS.SEND_BLOCK.link)
                        for (let i = 0; i < COUNT; i++) {
                                const start = performance.now()
                                await block.pow()

diff --git a/test/test.blocks.mjs b/test/test.blocks.mjs
index 269ef8a09898bcf8d24816456da6f188b0df9ee0..962ef55c58247549d52d18c2942ded550f045b67 100644 (file)
--- a/test/test.blocks.mjs
+++ b/test/test.blocks.mjs
@@ -7,232 +7,169 @@ import { assert, isNode, suite, test } from './GLOBALS.mjs'
 import { NANO_TEST_VECTORS } from './VECTORS.mjs'\r
 \r
 /**\r
-* @type {typeof import('../dist/types.d.ts').Wallet}\r
-*/\r
-let Wallet\r
-/**\r
-* @type {typeof import('../dist/types.d.ts').ChangeBlock}\r
+* @type {typeof import('../dist/types.d.ts').Block}\r
 */\r
-let ChangeBlock\r
+let Block\r
 /**\r
-* @type {typeof import('../dist/types.d.ts').ReceiveBlock}\r
-*/\r
-let ReceiveBlock\r
-/**\r
-* @type {typeof import('../dist/types.d.ts').SendBlock}\r
+* @type {typeof import('../dist/types.d.ts').Wallet}\r
 */\r
-let SendBlock\r
+let Wallet\r
 if (isNode) {\r
-       ({ Wallet, ChangeBlock, ReceiveBlock, SendBlock } = await import('../dist/nodejs.min.js'))\r
+       ({ Block, Wallet } = await import('../dist/nodejs.min.js'))\r
 } else {\r
-       ({ Wallet, ChangeBlock, ReceiveBlock, SendBlock } = await import('../dist/browser.min.js'))\r
+       ({ Block, Wallet } = await import('../dist/browser.min.js'))\r
 }\r
 \r
 await Promise.all([\r
        suite('Block format', async () => {\r
+               const { ADDRESS_0, ADDRESS_1, ADDRESS_2, RECEIVE_BLOCK } = NANO_TEST_VECTORS\r
 \r
                await test('throw on negative balances', async () => {\r
                        assert.throws(() => {\r
-                               new SendBlock(\r
-                                       NANO_TEST_VECTORS.ADDRESS_0,\r
-                                       '7000000000000000000000000000000',\r
-                                       NANO_TEST_VECTORS.ADDRESS_1,\r
-                                       '12000000000000000000000000000000',\r
-                                       NANO_TEST_VECTORS.ADDRESS_2,\r
-                                       '92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D'\r
-                               )\r
+                               new Block(ADDRESS_0, '7000000000000000000000000000000', '92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D', ADDRESS_2)\r
+                                       .send('12000000000000000000000000000000')\r
+                                       .to(ADDRESS_1)\r
                        }, { message: 'Negative balance' })\r
                })\r
 \r
                await test('allow zero balances', async () => {\r
-                       const block = new SendBlock(\r
-                               NANO_TEST_VECTORS.ADDRESS_0,\r
-                               '9007199254740991',\r
-                               NANO_TEST_VECTORS.ADDRESS_1,\r
-                               '9007199254740991',\r
-                               NANO_TEST_VECTORS.ADDRESS_2,\r
-                               '92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D'\r
-                       )\r
+                       const block = new Block(\r
+                               ADDRESS_0, '9007199254740991', '92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D', ADDRESS_2)\r
+                               .send('9007199254740991')\r
+                               .to(ADDRESS_1)\r
                        assert.notEqual(block.balance, 0)\r
                        assert.equal(block.balance, BigInt(0))\r
                })\r
 \r
                await test('subtract balance from SendBlock correctly', async () => {\r
-                       const block = new SendBlock(\r
-                               NANO_TEST_VECTORS.ADDRESS_0,\r
-                               '3000000000000000000000000000000',\r
-                               NANO_TEST_VECTORS.ADDRESS_1,\r
-                               '2000000000000000000000000000000',\r
-                               NANO_TEST_VECTORS.ADDRESS_2,\r
-                               '92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D'\r
-                       )\r
+                       const block = new Block(\r
+                               ADDRESS_0, '3000000000000000000000000000000', '92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D', ADDRESS_2)\r
+                               .send('2000000000000000000000000000000')\r
+                               .to(ADDRESS_1)\r
                        assert.equal(block.balance, 1000000000000000000000000000000n)\r
                })\r
 \r
                await test('add balance from ReceiveBlock correctly', async () => {\r
-                       const block = new ReceiveBlock(\r
-                               NANO_TEST_VECTORS.ADDRESS_0,\r
-                               '2000000000000000000000000000000',\r
-                               NANO_TEST_VECTORS.ADDRESS_1,\r
-                               '1000000000000000000000000000000',\r
-                               NANO_TEST_VECTORS.ADDRESS_2,\r
-                               '92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D'\r
-                       )\r
+                       const block = new Block(ADDRESS_0, '2000000000000000000000000000000', '92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D', ADDRESS_2)\r
+                               .receive('1000000000000000000000000000000')\r
+                               .from(RECEIVE_BLOCK.link)\r
                        assert.equal(block.balance, 3000000000000000000000000000000n)\r
                })\r
+\r
+               await test('fail to receive from address, link must be block hash', async () => {\r
+                       assert.throws(new Block(ADDRESS_0, '2000000000000000000000000000000', '92BA74A7D6DC7557F3EDA95ADC6341D51AC777A0A6FF0688A5C492AB2B2CB40D', ADDRESS_2)\r
+                               .receive('1000000000000000000000000000000')\r
+                               .from(ADDRESS_1))\r
+               })\r
        }),\r
 \r
        suite('Block signing using official test vectors', async () => {\r
+               const { ADDRESS_0, BIP39_SEED, OPEN_BLOCK, PASSWORD, PRIVATE_0, RECEIVE_BLOCK, SEND_BLOCK } = NANO_TEST_VECTORS\r
 \r
                await test('sign open block with wallet', async () => {\r
-                       const wallet = await Wallet.import('BIP-44', NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)\r
-                       await assert.resolves(wallet.unlock(NANO_TEST_VECTORS.PASSWORD))\r
-\r
-                       const block = new ReceiveBlock(\r
-                               NANO_TEST_VECTORS.ADDRESS_0,\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
-                       const signature = await wallet.sign(0, block)\r
+                       const wallet = await Wallet.import('BIP-44', PASSWORD, BIP39_SEED)\r
+                       await assert.resolves(wallet.unlock(PASSWORD))\r
+\r
+                       const block = new Block(ADDRESS_0, '0', OPEN_BLOCK.previous, OPEN_BLOCK.representative)\r
+                               .receive(OPEN_BLOCK.balance)\r
+                               .from(OPEN_BLOCK.link)\r
+                       const signature = await wallet.sign(0, block, 'hex')\r
                        assert.equal(block.signature, signature)\r
 \r
                        await wallet.destroy()\r
                })\r
 \r
                await test('fail to sign open block with wallet when locked', async () => {\r
-                       const wallet = await Wallet.import('BIP-44', NANO_TEST_VECTORS.PASSWORD, NANO_TEST_VECTORS.BIP39_SEED)\r
-                       const block = new ReceiveBlock(\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
+                       const wallet = await Wallet.import('BIP-44', PASSWORD, BIP39_SEED)\r
+                       const block = new Block(OPEN_BLOCK.account, '0', OPEN_BLOCK.previous, OPEN_BLOCK.representative)\r
+                               .receive(OPEN_BLOCK.balance)\r
+                               .from(OPEN_BLOCK.link)\r
+\r
                        await assert.rejects(wallet.sign(0, block))\r
-                       assert.equal(block.hash, NANO_TEST_VECTORS.OPEN_BLOCK.hash)\r
+                       assert.equal(block.hash, OPEN_BLOCK.hash)\r
                        assert.ok(block.signature === undefined)\r
 \r
                        await wallet.destroy()\r
                })\r
 \r
                await test('sign open block with private key', async () => {\r
-                       const block = new ReceiveBlock(\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.equal(block.hash, NANO_TEST_VECTORS.OPEN_BLOCK.hash)\r
-                       assert.equal(block.signature, NANO_TEST_VECTORS.OPEN_BLOCK.signature)\r
+                       const block = await (new Block(OPEN_BLOCK.account, '0', OPEN_BLOCK.previous, OPEN_BLOCK.representative)\r
+                               .receive(OPEN_BLOCK.balance)\r
+                               .from(OPEN_BLOCK.link))\r
+                               .pow(OPEN_BLOCK.work)\r
+                       await block.sign(OPEN_BLOCK.key)\r
+                       assert.equal(block.hash, OPEN_BLOCK.hash)\r
+                       assert.equal(block.signature, OPEN_BLOCK.signature)\r
                })\r
 \r
                await test('sign 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(NANO_TEST_VECTORS.RECEIVE_BLOCK.key)\r
-                       assert.equal(block.hash, NANO_TEST_VECTORS.RECEIVE_BLOCK.hash)\r
-                       assert.equal(block.signature, NANO_TEST_VECTORS.RECEIVE_BLOCK.signature)\r
+                       const block = await (new Block(RECEIVE_BLOCK.account, RECEIVE_BLOCK.balance, RECEIVE_BLOCK.previous, RECEIVE_BLOCK.representative)\r
+                               .receive(0)\r
+                               .from(RECEIVE_BLOCK.link))\r
+                               .pow(RECEIVE_BLOCK.work)\r
+                       await block.sign(RECEIVE_BLOCK.key)\r
+                       assert.equal(block.hash, RECEIVE_BLOCK.hash)\r
+                       assert.equal(block.signature, RECEIVE_BLOCK.signature)\r
                })\r
 \r
                await test('sign receive block without work', 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
-                       )\r
-                       await block.sign(NANO_TEST_VECTORS.RECEIVE_BLOCK.key)\r
-                       assert.equal(block.hash, NANO_TEST_VECTORS.RECEIVE_BLOCK.hash)\r
-                       assert.equal(block.signature, NANO_TEST_VECTORS.RECEIVE_BLOCK.signature)\r
+                       const block = new Block(RECEIVE_BLOCK.account, RECEIVE_BLOCK.balance, RECEIVE_BLOCK.previous, RECEIVE_BLOCK.representative)\r
+                               .receive('0')\r
+                               .from(RECEIVE_BLOCK.link)\r
+                       await block.sign(RECEIVE_BLOCK.key)\r
+                       assert.equal(block.hash, RECEIVE_BLOCK.hash)\r
+                       assert.equal(block.signature, RECEIVE_BLOCK.signature)\r
                        assert.equal(block.work, '')\r
                })\r
 \r
                await test('sign send block', 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
-                               NANO_TEST_VECTORS.SEND_BLOCK.work\r
-                       )\r
-                       await block.sign(NANO_TEST_VECTORS.SEND_BLOCK.key)\r
-                       assert.equal(block.hash, NANO_TEST_VECTORS.SEND_BLOCK.hash)\r
-                       assert.equal(block.signature, NANO_TEST_VECTORS.SEND_BLOCK.signature)\r
+                       const block = await (new Block(SEND_BLOCK.account, SEND_BLOCK.balance, SEND_BLOCK.previous, SEND_BLOCK.representative)\r
+                               .send('0')\r
+                               .to(SEND_BLOCK.link))\r
+                               .pow(SEND_BLOCK.work)\r
+                       await block.sign(SEND_BLOCK.key)\r
+                       assert.equal(block.hash, SEND_BLOCK.hash)\r
+                       assert.equal(block.signature, SEND_BLOCK.signature)\r
                })\r
 \r
                await test('sign send block without work', 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.sign(NANO_TEST_VECTORS.SEND_BLOCK.key)\r
-                       assert.equal(block.hash, NANO_TEST_VECTORS.SEND_BLOCK.hash)\r
-                       assert.equal(block.signature, NANO_TEST_VECTORS.SEND_BLOCK.signature)\r
+                       const block = new Block(SEND_BLOCK.account, SEND_BLOCK.balance, SEND_BLOCK.previous, SEND_BLOCK.representative)\r
+                               .send(0n)\r
+                               .to(SEND_BLOCK.link)\r
+                       await block.sign(SEND_BLOCK.key)\r
+                       //@ts-expect-error\r
+                       assert.equal(block.hash.map(b => b.toString(16).padStart(2, '0')).join(''), SEND_BLOCK.hash)\r
+                       assert.equal(block.signature, SEND_BLOCK.signature)\r
                        assert.equal(block.work, '')\r
                })\r
 \r
                await test('sign change rep block', async () => {\r
                        const work = '0000000000000000'\r
-                       const block = new ChangeBlock(\r
-                               'nano_3igf8hd4sjshoibbbkeitmgkp1o6ug4xads43j6e4gqkj5xk5o83j8ja9php',\r
-                               '3000000000000000000000000000000',\r
-                               'nano_1anrzcuwe64rwxzcco8dkhpyxpi8kd7zsjc1oeimpc3ppca4mrjtwnqposrs',\r
-                               '128106287002E595F479ACD615C818117FCB3860EC112670557A2467386249D4',\r
-                               work,\r
-                       )\r
+                       const block = await (new Block('nano_3igf8hd4sjshoibbbkeitmgkp1o6ug4xads43j6e4gqkj5xk5o83j8ja9php', '3000000000000000000000000000000', '128106287002E595F479ACD615C818117FCB3860EC112670557A2467386249D4')\r
+                               .change()\r
+                               .to('nano_1anrzcuwe64rwxzcco8dkhpyxpi8kd7zsjc1oeimpc3ppca4mrjtwnqposrs'))\r
+                               .pow(work)\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
                })\r
 \r
                await test('sign change rep block without work', async () => {\r
-                       const block = new ChangeBlock(\r
-                               NANO_TEST_VECTORS.ADDRESS_0,\r
-                               '0',\r
-                               'nano_34amtofxstsfyqcgphp8piij9u33widykq9wbz6ysjpxhbgmqu8btu1eexer',\r
-                               'F3C1D7B6EE97DA09D4C00538CEA93CBA5F74D78FD3FBE71347D2DFE7E53DF327'\r
-                       )\r
-                       await block.sign(NANO_TEST_VECTORS.PRIVATE_0)\r
+                       const block = new Block(ADDRESS_0, '0', 'F3C1D7B6EE97DA09D4C00538CEA93CBA5F74D78FD3FBE71347D2DFE7E53DF327')\r
+                               .change()\r
+                               .to('nano_34amtofxstsfyqcgphp8piij9u33widykq9wbz6ysjpxhbgmqu8btu1eexer')\r
+                       await block.sign(PRIVATE_0)\r
                        assert.equal(block.signature?.toUpperCase(), '2BD2F905E74B5BEE3E2277CED1D1E3F7535E5286B6E22F7B08A814AA9E5C4E1FEA69B61D60B435ADC2CE756E6EE5F5BE7EC691FE87E024A0B22A3D980CA5B305')\r
                        assert.equal(block.work, '')\r
                })\r
 \r
                await test('fail to sign open block without key', async () => {\r
-                       const block = new ReceiveBlock(\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
+                       const block = await (new Block(OPEN_BLOCK.account, '0', OPEN_BLOCK.previous, OPEN_BLOCK.representative)\r
+                               .receive(OPEN_BLOCK.balance)\r
+                               .from(OPEN_BLOCK.link))\r
+                               .pow(OPEN_BLOCK.work)\r
 \r
+                       //@ts-expect-error\r
                        await assert.rejects(block.sign())\r
                        assert.nullish(block.signature)\r
                        //@ts-expect-error\r