trac-msb 0.2.8 → 0.2.10

package/tests/helpers/setupApplyTests.js

@@ -3,16 +3,13 @@ import {generateMnemonic, mnemonicToSeed} from 'bip39-mnemonic';
 import b4a from 'b4a'
 import PeerWallet from "trac-wallet"
 import path from 'path';
-import CompleteStateMessageOperations from '../../src/messages/completeStateMessages/CompleteStateMessageOperations.js'
-import PartialStateMessageOperations from '../../src/messages/partialStateMessages/PartialStateMessageOperations.js';
 import {MainSettlementBus} from '../../src/index.js'
 import { createConfig, ENV } from '../../src/config/env.js'
 import fileUtils from '../../src/utils/fileUtils.js'
 import {EntryType} from '../../src/utils/constants.js';
 import {sleep} from '../../src/utils/helpers.js'
 import {formatIndexersEntry} from '../../src/utils/helpers.js';
-import CompleteStateMessageBuilder from '../../src/messages/completeStateMessages/CompleteStateMessageBuilder.js'
-import CompleteStateMessageDirector from '../../src/messages/completeStateMessages/CompleteStateMessageDirector.js'
+import { applyStateMessageFactory } from "../../src/messages/state/applyStateMessageFactory.js";
 import { safeEncodeApplyOperation } from "../../src/utils/protobuf/operationHelpers.js"
 import { $TNK } from '../../src/core/state/utils/balance.js';
 import { EventType } from '../../src/utils/constants.js';
@@ -69,14 +66,13 @@ export const tick = () => new Promise(resolve => setImmediate(resolve));
 
 export async function fundPeer(admin, toFund, amount) {
     const txValidity = await admin.msb.state.getIndexerSequenceState()
-    const director = new CompleteStateMessageDirector();
-    director.builder = new CompleteStateMessageBuilder(admin.wallet, admin.config);
-    const payload = await director.buildBalanceInitializationMessage(
-        admin.wallet.address,
-        toFund.wallet.address,
-        amount,
-        txValidity
-    );
+    const payload = await applyStateMessageFactory(admin.wallet, admin.config)
+        .buildCompleteBalanceInitializationMessage(
+            admin.wallet.address,
+            toFund.wallet.address,
+            amount,
+            txValidity
+        );
 
     await admin.msb.state.append(safeEncodeApplyOperation(payload));
     await tick()
@@ -86,11 +82,10 @@ export async function fundPeer(admin, toFund, amount) {
 }
 
 export async function initMsbPeer(peerName, peerKeyPair, temporaryDirectory, options = {}) {
-    const peer = await initDirectoryStructure(peerName, peerKeyPair, temporaryDirectory);
-    peer.options = options
-    peer.options.storesDirectory = peer.storesDirectory;
-    peer.options.storeName = peer.storeName;
-    peer.config = createConfig(ENV.DEVELOPMENT, peer.options)
+    const config = createConfig(ENV.DEVELOPMENT, { ...options, storesDirectory: `${temporaryDirectory}/${peerName}` })
+    const peer = await initDirectoryStructure(peerName, peerKeyPair, config.storesFullPath);
+    peer.options = { ...options, storesDirectory: config.storesDirectory }
+    peer.config = config
     const msb = new MainSettlementBus(peer.config);
 
     peer.msb = msb;
@@ -124,10 +119,10 @@ export async function initMsbAdmin(keyPair, temporaryDirectory, options = {}) {
 export async function setupMsbAdmin(keyPair, temporaryDirectory, options = {}) {
     const admin = await initMsbAdmin(keyPair, temporaryDirectory, options);
     const txValidity = await admin.msb.state.getIndexerSequenceState();
-    const addAdminMessage = await new CompleteStateMessageOperations(admin.wallet, admin.config)
-        .assembleAddAdminMessage(admin.msb.state.writingKey, txValidity);
+    const payload = await applyStateMessageFactory(admin.wallet, admin.config)
+        .buildCompleteAddAdminMessage(admin.wallet.address, admin.msb.state.writingKey, txValidity);
 
-    await admin.msb.state.append(addAdminMessage);
+    await admin.msb.state.append(safeEncodeApplyOperation(payload));
     await tick();
     return admin;
 }
@@ -137,22 +132,25 @@ export async function setupNodeAsWriter(admin, writerCandidate) {
         await setupWhitelist(admin, [writerCandidate.wallet.address]); // ensure if is whitelisted
 
         const validity = await admin.msb.getIndexerSequenceState()
-        const req = await new PartialStateMessageOperations(writerCandidate.wallet, admin.config)
-            .assembleAddWriterMessage(
+        const req = await applyStateMessageFactory(writerCandidate.wallet, admin.config)
+            .buildPartialAddWriterMessage(
+                writerCandidate.wallet.address,
                 b4a.toString(writerCandidate.msb.state.writingKey, 'hex'),
-                b4a.toString(validity, 'hex'));
+                b4a.toString(validity, 'hex'),
+                'json'
+            );
 
         await waitWritable(admin, writerCandidate, async () => {
-            const raw = await new CompleteStateMessageOperations(admin.wallet, admin.config)
-                .assembleAddWriterMessage(
+            const payload = await applyStateMessageFactory(admin.wallet, admin.config)
+                .buildCompleteAddWriterMessage(
                     admin.wallet.address,
                     b4a.from(req.rao.tx, 'hex'),
                     b4a.from(req.rao.txv, 'hex'),
                     b4a.from(req.rao.iw, 'hex'),
                     b4a.from(req.rao.in, 'hex'),
                     b4a.from(req.rao.is, 'hex')
-                )
-            await admin.msb.state.append(raw)
+                );
+            await admin.msb.state.append(safeEncodeApplyOperation(payload))
         })
 
         return writerCandidate;
@@ -172,22 +170,25 @@ export async function promoteToWriter(admin, writerCandidate) {
             isIndexer: false,
         })
     const validity = await admin.msb.state.getIndexerSequenceState()
-    const req = await new PartialStateMessageOperations(writerCandidate.wallet, writerCandidate.config)
-        .assembleAddWriterMessage(
+    const req = await applyStateMessageFactory(writerCandidate.wallet, writerCandidate.config)
+        .buildPartialAddWriterMessage(
+            writerCandidate.wallet.address,
             b4a.toString(writerCandidate.msb.state.writingKey, 'hex'),
-            b4a.toString(validity, 'hex'));
+            b4a.toString(validity, 'hex'),
+            'json'
+        );
 
     await waitWritable(writerCandidate, writerCandidate, async () => {
-        const raw = await new CompleteStateMessageOperations(admin.wallet, admin.config)
-            .assembleAddWriterMessage(
+        const payload = await applyStateMessageFactory(admin.wallet, admin.config)
+            .buildCompleteAddWriterMessage(
                 req.address,
                 b4a.from(req.rao.tx, 'hex'),
                 b4a.from(req.rao.txv, 'hex'),
                 b4a.from(req.rao.iw, 'hex'),
                 b4a.from(req.rao.in, 'hex'),
                 b4a.from(req.rao.is, 'hex')
-            )
-        await admin.msb.state.append(raw)
+            );
+        await admin.msb.state.append(safeEncodeApplyOperation(payload))
     })
 
     return writerCandidate;
@@ -206,10 +207,10 @@ export async function setupMsbWriter(admin, peerName, peerKeyPair, temporaryDire
 export async function setupMsbIndexer(indexerCandidate, admin) {
     try {
     const validity = await admin.msb.state.getIndexerSequenceState()
-    const req = await new CompleteStateMessageOperations(admin.wallet, admin.config)
-        .assembleAddIndexerMessage(indexerCandidate.wallet.address, validity);
+    const payload = await applyStateMessageFactory(admin.wallet, admin.config)
+        .buildCompleteAddIndexerMessage(admin.wallet.address, indexerCandidate.wallet.address, validity);
 
-        await admin.msb.state.append(req);
+        await admin.msb.state.append(safeEncodeApplyOperation(payload));
         await tick(); // wait for the request to be processed
 
         const isIndexer = async () => {
@@ -260,10 +261,10 @@ export async function setupWhitelist(admin, whitelistAddresses) {
     fileUtils.readAddressesFromWhitelistFile = async () => whitelistAddresses;
     const validity = await admin.msb.state.getIndexerSequenceState()
     for (const address of whitelistAddresses) {
-        const msg = await new CompleteStateMessageOperations(admin.wallet, admin.config)
-            .assembleAppendWhitelistMessages(validity, address);
+        const payload = await applyStateMessageFactory(admin.wallet, admin.config)
+            .buildCompleteAppendWhitelistMessage(admin.wallet.address, address, validity);
 
-        await admin.msb.state.append(msg);
+        await admin.msb.state.append(safeEncodeApplyOperation(payload));
         await sleep(100)
     }
 
@@ -288,9 +289,7 @@ export async function removeTemporaryDirectory(temporaryDirectory) {
 export async function initDirectoryStructure(peerName, keyPair, temporaryDirectory) {
     try {
         await ensureEnvReady();
-        const storesDirectory = temporaryDirectory + '/stores/';
-        const storeName = peerName + '/';
-        const corestoreDbDirectory = path.join(storesDirectory, storeName, 'db');
+        const corestoreDbDirectory = path.join(temporaryDirectory, 'db');
         await fsp.mkdir(corestoreDbDirectory, {recursive: true});
 
         const keypath = path.join(corestoreDbDirectory, 'keypair.json');
@@ -301,8 +300,7 @@ export async function initDirectoryStructure(peerName, keyPair, temporaryDirecto
         await wallet.ready
         await wallet.exportToFile(keypath)
         return {
-            storesDirectory,
-            storeName,
+            storesDirectory: temporaryDirectory,
             corestoreDbDirectory,
             keypath,
         }
@@ -314,15 +312,17 @@ export async function initDirectoryStructure(peerName, keyPair, temporaryDirecto
 export const deployExternalBootstrap = async (writer, externalNode) => {
     const externalBootstrap = randomBytes(32).toString('hex');
     const txValidity = await writer.msb.state.getIndexerSequenceState();
-    const payload = await new PartialStateMessageOperations(externalNode.msb.wallet, admin.config)
-        .assembleBootstrapDeploymentMessage(
+    const payload = await applyStateMessageFactory(externalNode.msb.wallet, admin.config)
+        .buildPartialBootstrapDeploymentMessage(
+            externalNode.msb.wallet.address,
             externalBootstrap,
             randomBytes(32).toString('hex'),
-            txValidity.toString('hex')
+            txValidity.toString('hex'),
+            'json'
         );
 
-    const raw = await new CompleteStateMessageOperations(writer.msb.wallet, admin.config)
-        .assembleCompleteBootstrapDeployment(
+    const rawPayload = await applyStateMessageFactory(writer.msb.wallet, admin.config)
+        .buildCompleteBootstrapDeploymentMessage(
             payload.address,
             b4a.from(payload.bdo.tx, 'hex'),
             b4a.from(payload.bdo.txv, 'hex'),
@@ -331,7 +331,7 @@ export const deployExternalBootstrap = async (writer, externalNode) => {
             b4a.from(payload.bdo.in, 'hex'),
             b4a.from(payload.bdo.is, 'hex'),
         )
-    await writer.msb.state.base.append(raw)
+    await writer.msb.state.base.append(safeEncodeApplyOperation(rawPayload))
     await tick()
     await waitForHash(writer, payload.bdo.tx)
     return externalBootstrap
@@ -353,17 +353,19 @@ export const generatePostTx = async (writer, externalNode, externalContractBoots
 
     const contentHash = await PeerWallet.blake3(JSON.stringify(testObj));
     const validity = await writer.msb.state.getIndexerSequenceState()
-    const tx = await new PartialStateMessageOperations(externalNode.wallet, admin.config)
-        .assembleTransactionOperationMessage(
+    const tx = await applyStateMessageFactory(externalNode.wallet, admin.config)
+        .buildPartialTransactionOperationMessage(
+            externalNode.wallet.address,
             peerWriterKey,
             b4a.toString(validity, 'hex'),
             b4a.toString(contentHash, 'hex'),
             externalContractBootstrap,
-            b4a.toString(writer.msb.bootstrap, 'hex')
+            b4a.toString(writer.msb.bootstrap, 'hex'),
+            'json'
         )
 
-    const postTx = await new CompleteStateMessageOperations(writer.wallet, admin.config)
-        .assembleCompleteTransactionOperationMessage(
+    const postTxPayload = await applyStateMessageFactory(writer.wallet, admin.config)
+        .buildCompleteTransactionOperationMessage(
             tx.address,
             b4a.from(tx.txo.tx, 'hex'),
             b4a.from(tx.txo.txv, 'hex'),
@@ -375,6 +377,7 @@ export const generatePostTx = async (writer, externalNode, externalContractBoots
             b4a.from(tx.txo.mbs, 'hex')
         );
 
+    const postTx = safeEncodeApplyOperation(postTxPayload);
     return { postTx, txHash: tx.txo.tx };
 }
 

package/tests/unit/messages/messages.test.js

@@ -0,0 +1,12 @@
+import { default as test } from 'brittle';
+
+async function runMsgUtilsTests() {
+    test.pause();
+    await import('./network/NetworkMessageBuilder.test.js');
+    await import('./network/NetworkMessageDirector.test.js');
+    await import('./state/applyStateMessageBuilder.complete.test.js');
+    await import('./state/applyStateMessageBuilder.partial.test.js');
+    test.resume();
+}
+
+await runMsgUtilsTests();

package/tests/unit/messages/network/NetworkMessageBuilder.test.js

@@ -0,0 +1,276 @@
+import { test } from 'brittle';
+import b4a from 'b4a';
+import PeerWallet from 'trac-wallet';
+import { v7 as uuidv7 } from 'uuid';
+import NetworkWalletFactory from '../../../../src/core/network/identity/NetworkWalletFactory.js';
+import NetworkMessageBuilder from '../../../../src/messages/network/v1/NetworkMessageBuilder.js';
+import {
+    NetworkOperationType,
+    ResultCode as NetworkResultCode
+} from '../../../../src/utils/constants.js';
+import { decodeV1networkOperation, encodeV1networkOperation } from '../../../../src/utils/protobuf/operationHelpers.js';
+import { errorMessageIncludes } from '../../../helpers/regexHelper.js';
+import {
+    createMessage,
+    encodeCapabilities,
+    safeWriteUInt32BE,
+    idToBuffer,
+    timestampToBuffer
+} from '../../../../src/utils/buffer.js';
+import { addressToBuffer } from '../../../../src/core/state/utils/address.js';
+import { config } from '../../../helpers/config.js';
+import { asAddress } from '../../../helpers/address.js';
+import { testKeyPair1 } from '../../../fixtures/apply.fixtures.js';
+
+function createWallet() {
+    const keyPair = {
+        publicKey: b4a.from(testKeyPair1.publicKey, 'hex'),
+        secretKey: b4a.from(testKeyPair1.secretKey, 'hex')
+    };
+    return NetworkWalletFactory.provide({
+        enableWallet: false,
+        keyPair,
+        networkPrefix: config.addressPrefix
+    });
+}
+
+function uniqueResultCodes() {
+    return [...new Set(Object.values(NetworkResultCode))].sort((a, b) => a - b);
+}
+
+test('NetworkMessageBuilder builds validator connection request and verifies signature', async t => {
+    const wallet = createWallet();
+    const builder = new NetworkMessageBuilder(wallet, config);
+
+    const id = uuidv7();
+    const caps = ['cap:b', 'cap:a'];
+
+    await builder
+        .setType(NetworkOperationType.VALIDATOR_CONNECTION_REQUEST)
+        .setId(id)
+        .setTimestamp()
+        .setIssuerAddress(wallet.address)
+        .setCapabilities(caps)
+        .buildPayload();
+
+    const payload = builder.getResult();
+    t.is(payload.type, NetworkOperationType.VALIDATOR_CONNECTION_REQUEST);
+    t.is(payload.id, id);
+    t.alike(payload.capabilities, caps);
+    t.ok(b4a.isBuffer(payload.validator_connection_request.nonce));
+    t.ok(b4a.isBuffer(payload.validator_connection_request.signature));
+
+    const message = createMessage(
+        payload.type,
+        idToBuffer(id),
+        timestampToBuffer(payload.timestamp),
+        addressToBuffer(wallet.address, config.addressPrefix),
+        payload.validator_connection_request.nonce,
+        encodeCapabilities(caps)
+    );
+    const hash = await PeerWallet.blake3(message);
+    t.ok(wallet.verify(payload.validator_connection_request.signature, hash, wallet.publicKey));
+
+    const roundTrip = decodeV1networkOperation(encodeV1networkOperation(payload));
+    t.is(roundTrip.type, NetworkOperationType.VALIDATOR_CONNECTION_REQUEST);
+});
+
+test('NetworkMessageBuilder iterates validator connection response ResultCode values', async t => {
+    const wallet = createWallet();
+    const builder = new NetworkMessageBuilder(wallet, config);
+    const id = uuidv7();
+    const otherAddress = asAddress('36fdaf941de4afe602cbb1e2f56dc582466ef23fad1da55c09fd6dd841cbd117');
+    const caps = ['cap:b', 'cap:a'];
+
+    for (const code of uniqueResultCodes()) {
+        await builder
+            .setType(NetworkOperationType.VALIDATOR_CONNECTION_RESPONSE)
+            .setId(id)
+            .setTimestamp()
+            .setIssuerAddress(otherAddress)
+            .setCapabilities(caps)
+            .setResultCode(code)
+            .buildPayload();
+
+        const payload = builder.getResult();
+        t.is(payload.type, NetworkOperationType.VALIDATOR_CONNECTION_RESPONSE);
+        t.is(payload.validator_connection_response.result, code);
+
+        const msg = createMessage(
+            payload.type,
+            idToBuffer(payload.id),
+            timestampToBuffer(payload.timestamp),
+            addressToBuffer(otherAddress, config.addressPrefix),
+            payload.validator_connection_response.nonce,
+            safeWriteUInt32BE(code, 0),
+            encodeCapabilities(caps)
+        );
+        const hash = await PeerWallet.blake3(msg);
+        t.ok(wallet.verify(payload.validator_connection_response.signature, hash, wallet.publicKey));
+
+        const decoded = decodeV1networkOperation(encodeV1networkOperation(payload));
+        t.is(decoded.validator_connection_response.result, code);
+    }
+});
+
+test('NetworkMessageBuilder iterates liveness response ResultCode values', async t => {
+    const wallet = createWallet();
+    const builder = new NetworkMessageBuilder(wallet, config);
+    const id = uuidv7();
+    const caps = ['cap:b', 'cap:a'];
+    const data = b4a.from('ping', 'utf8');
+
+    for (const code of uniqueResultCodes()) {
+        await builder
+            .setType(NetworkOperationType.LIVENESS_RESPONSE)
+            .setId(id)
+            .setTimestamp()
+            .setData(data)
+            .setCapabilities(caps)
+            .setResultCode(code)
+            .buildPayload();
+
+        const payload = builder.getResult();
+        t.is(payload.type, NetworkOperationType.LIVENESS_RESPONSE);
+        t.is(payload.liveness_response.result, code);
+
+        const msg = createMessage(
+            payload.type,
+            idToBuffer(payload.id),
+            timestampToBuffer(payload.timestamp),
+            payload.liveness_response.nonce,
+            safeWriteUInt32BE(code, 0),
+            encodeCapabilities(caps)
+        );
+        const hash = await PeerWallet.blake3(msg);
+        t.ok(wallet.verify(payload.liveness_response.signature, hash, wallet.publicKey));
+
+        const decoded = decodeV1networkOperation(encodeV1networkOperation(payload));
+        t.is(decoded.liveness_response.result, code);
+    }
+});
+
+test('NetworkMessageBuilder builds liveness request and verifies signature (data not signed)', async t => {
+    const wallet = createWallet();
+    const builder = new NetworkMessageBuilder(wallet, config);
+
+    const id = uuidv7();
+    const caps = ['cap:b', 'cap:a'];
+    const data = b4a.from('ping', 'utf8');
+
+    await builder
+        .setType(NetworkOperationType.LIVENESS_REQUEST)
+        .setId(id)
+        .setTimestamp()
+        .setData(data)
+        .setCapabilities(caps)
+        .buildPayload();
+
+    const payload = builder.getResult();
+    t.is(payload.type, NetworkOperationType.LIVENESS_REQUEST);
+    t.ok(b4a.isBuffer(payload.liveness_request.nonce));
+    t.ok(b4a.isBuffer(payload.liveness_request.signature));
+
+    const msg = createMessage(
+        payload.type,
+        idToBuffer(payload.id),
+        timestampToBuffer(payload.timestamp),
+        payload.liveness_request.nonce,
+        encodeCapabilities(caps)
+    );
+    const hash = await PeerWallet.blake3(msg);
+    t.ok(wallet.verify(payload.liveness_request.signature, hash, wallet.publicKey));
+});
+
+test('NetworkMessageBuilder iterates broadcast transaction response ResultCode values', async t => {
+    const wallet = createWallet();
+    const builder = new NetworkMessageBuilder(wallet, config);
+    const id = uuidv7();
+    const caps = ['cap:b', 'cap:a'];
+
+    for (const code of uniqueResultCodes()) {
+        await builder
+            .setType(NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE)
+            .setId(id)
+            .setTimestamp()
+            .setCapabilities(caps)
+            .setResultCode(code)
+            .buildPayload();
+
+        const payload = builder.getResult();
+        t.is(payload.type, NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE);
+        t.is(payload.broadcast_transaction_response.result, code);
+
+        const msg = createMessage(
+            payload.type,
+            idToBuffer(payload.id),
+            timestampToBuffer(payload.timestamp),
+            payload.broadcast_transaction_response.nonce,
+            safeWriteUInt32BE(code, 0),
+            encodeCapabilities(caps)
+        );
+        const hash = await PeerWallet.blake3(msg);
+        t.ok(wallet.verify(payload.broadcast_transaction_response.signature, hash, wallet.publicKey));
+
+        const decoded = decodeV1networkOperation(encodeV1networkOperation(payload));
+        t.is(decoded.broadcast_transaction_response.result, code);
+    }
+});
+
+test('NetworkMessageBuilder builds broadcast transaction request and verifies signature', async t => {
+    const wallet = createWallet();
+    const builder = new NetworkMessageBuilder(wallet, config);
+
+    const id = uuidv7();
+    const caps = ['cap:b', 'cap:a'];
+    const data = b4a.from('deadbeef', 'hex');
+
+    await builder
+        .setType(NetworkOperationType.BROADCAST_TRANSACTION_REQUEST)
+        .setId(id)
+        .setTimestamp()
+        .setData(data)
+        .setCapabilities(caps)
+        .buildPayload();
+
+    const payload = builder.getResult();
+    t.is(payload.type, NetworkOperationType.BROADCAST_TRANSACTION_REQUEST);
+    t.alike(payload.broadcast_transaction_request.data, data);
+
+    const msg = createMessage(
+        payload.type,
+        idToBuffer(payload.id),
+        timestampToBuffer(payload.timestamp),
+        data,
+        payload.broadcast_transaction_request.nonce,
+        encodeCapabilities(caps)
+    );
+    const hash = await PeerWallet.blake3(msg);
+    t.ok(wallet.verify(payload.broadcast_transaction_request.signature, hash, wallet.publicKey));
+});
+
+test('NetworkMessageBuilder validates required inputs', async t => {
+    const wallet = createWallet();
+    const builder = new NetworkMessageBuilder(wallet, config);
+    const id = uuidv7();
+    await t.exception(
+        () => builder.setType(undefined),
+        errorMessageIncludes('Invalid operation type')
+    );
+
+    await t.exception(
+        () => builder.setCapabilities('not-an-array'),
+        errorMessageIncludes('Capabilities must be a string array.')
+    );
+
+    await t.exception(
+        () =>
+            builder
+                .setType(NetworkOperationType.BROADCAST_TRANSACTION_REQUEST)
+                .setId(id)
+                .setTimestamp()
+                .setCapabilities([])
+                .buildPayload(),
+        errorMessageIncludes('Data must be set before building broadcast transaction request')
+    );
+});