trac-msb 0.2.8 → 0.2.9

package/tests/unit/state/apply/txOperation/txOperationScenarioHelpers.js

@@ -1,6 +1,5 @@
 import b4a from 'b4a';
-import PartialStateMessageOperations from '../../../../../src/messages/partialStateMessages/PartialStateMessageOperations.js';
-import CompleteStateMessageOperations from '../../../../../src/messages/completeStateMessages/CompleteStateMessageOperations.js';
+import { applyStateMessageFactory } from '../../../../../src/messages/state/applyStateMessageFactory.js';
 import {
 	deriveIndexerSequenceState,
 	eventFlush
@@ -139,20 +138,22 @@ export async function buildTxOperationPayload(
 		writerKeyBuffer = broadcasterPeer.base.local.key
 	} = {}
 ) {
-	const resolvedTxValidity = txValidity ?? (await deriveIndexerSequenceState(validatorPeer.base));
+    const resolvedTxValidity = txValidity ?? (await deriveIndexerSequenceState(validatorPeer.base));
 
-    const partial = await new PartialStateMessageOperations(broadcasterPeer.wallet, config)
-        .assembleTransactionOperationMessage(
+    const partial = await applyStateMessageFactory(broadcasterPeer.wallet, config)
+        .buildPartialTransactionOperationMessage(
+            broadcasterPeer.wallet.address,
             writerKeyBuffer.toString('hex'),
             resolvedTxValidity.toString('hex'),
             contentHash.toString('hex'),
             externalBootstrap.toString('hex'),
-            msbBootstrap.toString('hex')
+            msbBootstrap.toString('hex'),
+            'json'
         );
 
-    return new CompleteStateMessageOperations(validatorPeer.wallet, config)
-        .assembleCompleteTransactionOperationMessage(
-						partial.address,
+    const payload = await applyStateMessageFactory(validatorPeer.wallet, config)
+        .buildCompleteTransactionOperationMessage(
+            partial.address,
             b4a.from(partial.txo.tx, 'hex'),
             b4a.from(partial.txo.txv, 'hex'),
             b4a.from(partial.txo.iw, 'hex'),
@@ -162,6 +163,7 @@ export async function buildTxOperationPayload(
             b4a.from(partial.txo.bs, 'hex'),
             b4a.from(partial.txo.mbs, 'hex')
         );
+    return safeEncodeApplyOperation(payload);
 }
 
 export async function buildTxOperationPayloadWithTxValidity(context, txValidity, options = {}) {

package/tests/unit/unit.test.js

@@ -7,7 +7,7 @@ async function runTests() {
 	await import('./network/networkModule.test.js')
 	await import('./state/stateModule.test.js');
 	await import('./utils/utils.test.js');
-	// await import('./messageOperations/stateMessageOperations.test.js'); // Broken test - needs fixing
+	await import('./messages/messages.test.js');
 	test.resume();
 }
 

package/tests/unit/utils/buffer/buffer.test.js

@@ -1,6 +1,7 @@
 import test from 'brittle';
 import b4a from 'b4a';
-import {createMessage, isBufferValid, safeWriteUInt32BE, deepCopyBuffer} from '../../../../src/utils/buffer.js';
+import { createMessage, isBufferValid, safeWriteUInt32BE, deepCopyBuffer, encodeCapabilities, timestampToBuffer, idToBuffer } from '../../../../src/utils/buffer.js';
+import { errorMessageIncludes } from "../../../helpers/regexHelper.js";
 
 const invalidDataTypes = [
     null,
@@ -188,3 +189,63 @@ test('deepCopyBuffer - modifying copy does not affect original (is not a referen
     t.is(buf[0], 9, 'original unchanged');
     t.is(copy[0], 1, 'copy modified independently');
 });
+
+test('encodeCapabilities - deterministic ordering and encoding', t => {
+    const caps = ['cap-b', 'cap-a'];
+    const result = encodeCapabilities(caps);
+
+    const capA = b4a.from('cap-a', 'utf8');
+    const capB = b4a.from('cap-b', 'utf8');
+
+    const expected = b4a.concat([
+        b4a.from([0x00, capA.length]),
+        capA,
+        b4a.from([0x00, capB.length]),
+        capB
+    ]);
+
+    t.is(result.length, expected.length, 'length matches');
+    t.ok(b4a.equals(result, expected), 'ordering is sorted and encoding matches');
+});
+
+test('encodeCapabilities - empty array yields empty buffer', t => {
+    const result = encodeCapabilities([]);
+    t.ok(b4a.isBuffer(result), 'returns a buffer');
+    t.is(result.length, 0, 'empty buffer for no caps');
+});
+
+test('encodeCapabilities - throws on invalid input', t => {
+    t.exception(
+        () => encodeCapabilities('not-array'),
+        errorMessageIncludes('Capabilities must be an array')
+    );
+
+    t.exception(
+        () => encodeCapabilities([1, 2]),
+        errorMessageIncludes('must contain only strings')
+    );
+});
+
+test('timestampToBuffer - encodes uint64 BE', t => {
+    const ts = 2n ** 53n; // beyond uint32
+
+    const tsBuf = timestampToBuffer(ts);
+
+    t.is(tsBuf.length, 8);
+    t.is(tsBuf.readBigUInt64BE(0), ts);
+});
+
+test('idToBuffer - encodes utf8 string', t => {
+    const id = 'test-id';
+    const idBuf = idToBuffer(id);
+    t.ok(b4a.isBuffer(idBuf));
+    t.ok(b4a.equals(idBuf, b4a.from(id, 'utf8')));
+});
+
+test('timestampToBuffer and idToBuffer - reject invalid input', t => {
+    t.exception(() => timestampToBuffer(-1), errorMessageIncludes('timestamp'));
+    t.exception(() => timestampToBuffer(1.5), errorMessageIncludes('timestamp'));
+    t.exception(() => timestampToBuffer('1'), errorMessageIncludes('timestamp'));
+    t.exception.all(() => idToBuffer(1));
+    t.exception.all(() => idToBuffer(null));
+});

package/tests/unit/utils/normalizers/normalizers.test.js

@@ -0,0 +1,469 @@
+import { test } from 'brittle';
+import b4a from 'b4a';
+
+import { config } from '../../../helpers/config.js';
+import { randomAddress } from '../../state/stateTestUtils.js';
+import { errorMessageIncludes } from '../../../helpers/regexHelper.js';
+import { OperationType } from '../../../../src/utils/constants.js';
+import {
+    normalizeBootstrapDeploymentOperation,
+    normalizeDecodedPayloadForJson,
+    normalizeRoleAccessOperation,
+    normalizeTransactionOperation,
+    normalizeTransferOperation
+} from '../../../../src/utils/normalizers.js';
+import { addressToBuffer } from '../../../../src/core/state/utils/address.js';
+import { bigIntTo16ByteBuffer } from '../../../../src/utils/amountSerialization.js';
+
+const hex = (value, bytes) => value.repeat(bytes);
+const toBuffer = value => b4a.from(value, 'hex');
+
+test('normalizeTransferOperation normalizes hex strings and addresses', t => {
+    const sender = randomAddress(config.addressPrefix);
+    const recipient = randomAddress(config.addressPrefix);
+    const tx = hex('11', 32);
+    const txv = hex('22', 32);
+    const nonce = hex('33', 32);
+    const amount = hex('44', 16);
+    const signature = hex('55', 64);
+
+    const payload = {
+        type: OperationType.TRANSFER,
+        address: sender,
+        tro: {
+            tx,
+            txv,
+            in: nonce,
+            to: recipient,
+            am: amount,
+            is: signature
+        }
+    };
+
+    const normalized = normalizeTransferOperation(payload, config);
+
+    t.is(normalized.type, OperationType.TRANSFER);
+    t.ok(b4a.equals(normalized.address, addressToBuffer(sender, config.addressPrefix)));
+    t.ok(b4a.equals(normalized.tro.tx, toBuffer(tx)));
+    t.ok(b4a.equals(normalized.tro.txv, toBuffer(txv)));
+    t.ok(b4a.equals(normalized.tro.in, toBuffer(nonce)));
+    t.ok(b4a.equals(normalized.tro.to, addressToBuffer(recipient, config.addressPrefix)));
+    t.ok(b4a.equals(normalized.tro.am, toBuffer(amount)));
+    t.ok(b4a.equals(normalized.tro.is, toBuffer(signature)));
+});
+
+test('normalizeTransferOperation accepts buffer inputs', t => {
+    const sender = randomAddress(config.addressPrefix);
+    const recipient = randomAddress(config.addressPrefix);
+    const tx = toBuffer(hex('aa', 32));
+    const txv = toBuffer(hex('bb', 32));
+    const nonce = toBuffer(hex('cc', 32));
+    const amount = toBuffer(hex('dd', 16));
+    const signature = toBuffer(hex('ee', 64));
+
+    const payload = {
+        type: OperationType.TRANSFER,
+        address: sender,
+        tro: {
+            tx,
+            txv,
+            in: nonce,
+            to: recipient,
+            am: amount,
+            is: signature
+        }
+    };
+
+    const normalized = normalizeTransferOperation(payload, config);
+    t.ok(b4a.equals(normalized.tro.tx, tx));
+    t.ok(b4a.equals(normalized.tro.txv, txv));
+    t.ok(b4a.equals(normalized.tro.in, nonce));
+    t.ok(b4a.equals(normalized.tro.am, amount));
+    t.ok(b4a.equals(normalized.tro.is, signature));
+});
+
+test('normalizeTransferOperation throws on missing payload fields', t => {
+    t.exception(
+        () => normalizeTransferOperation({ type: OperationType.TRANSFER }, config),
+        errorMessageIncludes('Invalid payload for transfer operation normalization.')
+    );
+
+    t.exception(
+        () => normalizeTransferOperation({ type: OperationType.TX, address: 'x', tro: {} }, config),
+        errorMessageIncludes('Missing required fields in transfer operation payload.')
+    );
+
+    const sender = randomAddress(config.addressPrefix);
+    const payload = {
+        type: OperationType.TRANSFER,
+        address: sender,
+        tro: {
+            tx: hex('11', 32),
+            txv: hex('22', 32),
+            in: hex('33', 32),
+            to: randomAddress(config.addressPrefix),
+            am: hex('44', 16)
+        }
+    };
+    t.exception(
+        () => normalizeTransferOperation(payload, config),
+        errorMessageIncludes('Missing required fields in transfer operation payload.')
+    );
+});
+
+test('normalizeTransferOperation throws on invalid hex string', t => {
+    const sender = randomAddress(config.addressPrefix);
+    const payload = {
+        type: OperationType.TRANSFER,
+        address: sender,
+        tro: {
+            tx: 'zz',
+            txv: hex('22', 32),
+            in: hex('33', 32),
+            to: randomAddress(config.addressPrefix),
+            am: hex('44', 16),
+            is: hex('55', 64)
+        }
+    };
+    t.exception(
+        () => normalizeTransferOperation(payload, config),
+        errorMessageIncludes('Invalid hex string')
+    );
+});
+
+test('normalizeTransactionOperation normalizes hex strings and addresses', t => {
+    const sender = randomAddress(config.addressPrefix);
+    const tx = hex('11', 32);
+    const txv = hex('22', 32);
+    const writerKey = hex('33', 32);
+    const contentHash = hex('44', 32);
+    const bootstrap = hex('55', 32);
+    const msbBootstrap = hex('66', 32);
+    const nonce = hex('77', 32);
+    const signature = hex('88', 64);
+
+    const payload = {
+        type: OperationType.TX,
+        address: sender,
+        txo: {
+            tx,
+            txv,
+            iw: writerKey,
+            ch: contentHash,
+            bs: bootstrap,
+            mbs: msbBootstrap,
+            in: nonce,
+            is: signature
+        }
+    };
+
+    const normalized = normalizeTransactionOperation(payload, config);
+    t.is(normalized.type, OperationType.TX);
+    t.ok(b4a.equals(normalized.address, addressToBuffer(sender, config.addressPrefix)));
+    t.ok(b4a.equals(normalized.txo.tx, toBuffer(tx)));
+    t.ok(b4a.equals(normalized.txo.txv, toBuffer(txv)));
+    t.ok(b4a.equals(normalized.txo.iw, toBuffer(writerKey)));
+    t.ok(b4a.equals(normalized.txo.ch, toBuffer(contentHash)));
+    t.ok(b4a.equals(normalized.txo.bs, toBuffer(bootstrap)));
+    t.ok(b4a.equals(normalized.txo.mbs, toBuffer(msbBootstrap)));
+    t.ok(b4a.equals(normalized.txo.in, toBuffer(nonce)));
+    t.ok(b4a.equals(normalized.txo.is, toBuffer(signature)));
+});
+
+test('normalizeTransactionOperation accepts buffer inputs', t => {
+    const sender = randomAddress(config.addressPrefix);
+    const tx = toBuffer(hex('aa', 32));
+    const txv = toBuffer(hex('bb', 32));
+    const writerKey = toBuffer(hex('cc', 32));
+    const contentHash = toBuffer(hex('dd', 32));
+    const bootstrap = toBuffer(hex('ee', 32));
+    const msbBootstrap = toBuffer(hex('ff', 32));
+    const nonce = toBuffer(hex('12', 32));
+    const signature = toBuffer(hex('34', 64));
+
+    const payload = {
+        type: OperationType.TX,
+        address: sender,
+        txo: {
+            tx,
+            txv,
+            iw: writerKey,
+            ch: contentHash,
+            bs: bootstrap,
+            mbs: msbBootstrap,
+            in: nonce,
+            is: signature
+        }
+    };
+
+    const normalized = normalizeTransactionOperation(payload, config);
+    t.ok(b4a.equals(normalized.txo.tx, tx));
+    t.ok(b4a.equals(normalized.txo.txv, txv));
+    t.ok(b4a.equals(normalized.txo.iw, writerKey));
+    t.ok(b4a.equals(normalized.txo.ch, contentHash));
+    t.ok(b4a.equals(normalized.txo.bs, bootstrap));
+    t.ok(b4a.equals(normalized.txo.mbs, msbBootstrap));
+    t.ok(b4a.equals(normalized.txo.in, nonce));
+    t.ok(b4a.equals(normalized.txo.is, signature));
+});
+
+test('normalizeTransactionOperation throws on missing payload fields', t => {
+    t.exception(
+        () => normalizeTransactionOperation({ type: OperationType.TX }, config),
+        errorMessageIncludes('Invalid payload for transaction operation normalization.')
+    );
+
+    t.exception(
+        () => normalizeTransactionOperation({ type: OperationType.TRANSFER, address: 'x', txo: {} }, config),
+        errorMessageIncludes('Missing required fields in transaction operation payload.')
+    );
+
+    const sender = randomAddress(config.addressPrefix);
+    const payload = {
+        type: OperationType.TX,
+        address: sender,
+        txo: {
+            tx: hex('11', 32),
+            txv: hex('22', 32),
+            iw: hex('33', 32),
+            ch: hex('44', 32),
+            bs: hex('55', 32),
+            mbs: hex('66', 32),
+            in: hex('77', 32)
+        }
+    };
+    t.exception(
+        () => normalizeTransactionOperation(payload, config),
+        errorMessageIncludes('Missing required fields in transaction operation payload.')
+    );
+});
+
+test('normalizeTransactionOperation throws on invalid hex string', t => {
+    const sender = randomAddress(config.addressPrefix);
+    const payload = {
+        type: OperationType.TX,
+        address: sender,
+        txo: {
+            tx: 'zz',
+            txv: hex('22', 32),
+            iw: hex('33', 32),
+            ch: hex('44', 32),
+            bs: hex('55', 32),
+            mbs: hex('66', 32),
+            in: hex('77', 32),
+            is: hex('88', 64)
+        }
+    };
+    t.exception(
+        () => normalizeTransactionOperation(payload, config),
+        errorMessageIncludes('Invalid hex string')
+    );
+});
+
+test('normalizeRoleAccessOperation normalizes hex strings and addresses', t => {
+    const sender = randomAddress(config.addressPrefix);
+    const payload = {
+        type: OperationType.ADD_WRITER,
+        address: sender,
+        rao: {
+            tx: hex('11', 32),
+            txv: hex('22', 32),
+            iw: hex('33', 32),
+            in: hex('44', 32),
+            is: hex('55', 64)
+        }
+    };
+
+    const normalized = normalizeRoleAccessOperation(payload, config);
+    t.is(normalized.type, OperationType.ADD_WRITER);
+    t.ok(b4a.equals(normalized.address, addressToBuffer(sender, config.addressPrefix)));
+    t.ok(b4a.equals(normalized.rao.tx, toBuffer(hex('11', 32))));
+    t.ok(b4a.equals(normalized.rao.txv, toBuffer(hex('22', 32))));
+    t.ok(b4a.equals(normalized.rao.iw, toBuffer(hex('33', 32))));
+    t.ok(b4a.equals(normalized.rao.in, toBuffer(hex('44', 32))));
+    t.ok(b4a.equals(normalized.rao.is, toBuffer(hex('55', 64))));
+});
+
+test('normalizeRoleAccessOperation accepts buffer inputs', t => {
+    const sender = randomAddress(config.addressPrefix);
+    const tx = toBuffer(hex('aa', 32));
+    const txv = toBuffer(hex('bb', 32));
+    const writerKey = toBuffer(hex('cc', 32));
+    const nonce = toBuffer(hex('dd', 32));
+    const signature = toBuffer(hex('ee', 64));
+
+    const payload = {
+        type: OperationType.REMOVE_WRITER,
+        address: sender,
+        rao: {
+            tx,
+            txv,
+            iw: writerKey,
+            in: nonce,
+            is: signature
+        }
+    };
+
+    const normalized = normalizeRoleAccessOperation(payload, config);
+    t.ok(b4a.equals(normalized.rao.tx, tx));
+    t.ok(b4a.equals(normalized.rao.txv, txv));
+    t.ok(b4a.equals(normalized.rao.iw, writerKey));
+    t.ok(b4a.equals(normalized.rao.in, nonce));
+    t.ok(b4a.equals(normalized.rao.is, signature));
+});
+
+test('normalizeRoleAccessOperation throws on missing payload fields', t => {
+    t.exception(
+        () => normalizeRoleAccessOperation({ type: OperationType.ADD_WRITER }, config),
+        errorMessageIncludes('Invalid payload for role access normalization.')
+    );
+
+    t.exception(
+        () => normalizeRoleAccessOperation({ type: OperationType.ADD_WRITER, address: 'x', rao: {} }, config),
+        errorMessageIncludes('Missing required fields in role access payload.')
+    );
+});
+
+test('normalizeRoleAccessOperation throws on invalid hex string', t => {
+    const sender = randomAddress(config.addressPrefix);
+    const payload = {
+        type: OperationType.ADD_WRITER,
+        address: sender,
+        rao: {
+            tx: 'zz',
+            txv: hex('22', 32),
+            iw: hex('33', 32),
+            in: hex('44', 32),
+            is: hex('55', 64)
+        }
+    };
+    t.exception(
+        () => normalizeRoleAccessOperation(payload, config),
+        errorMessageIncludes('Invalid hex string')
+    );
+});
+
+test('normalizeBootstrapDeploymentOperation normalizes hex strings and addresses', t => {
+    const sender = randomAddress(config.addressPrefix);
+    const payload = {
+        type: OperationType.BOOTSTRAP_DEPLOYMENT,
+        address: sender,
+        bdo: {
+            tx: hex('11', 32),
+            txv: hex('22', 32),
+            bs: hex('33', 32),
+            ic: hex('44', 32),
+            in: hex('55', 32),
+            is: hex('66', 64)
+        }
+    };
+
+    const normalized = normalizeBootstrapDeploymentOperation(payload, config);
+    t.is(normalized.type, OperationType.BOOTSTRAP_DEPLOYMENT);
+    t.ok(b4a.equals(normalized.address, addressToBuffer(sender, config.addressPrefix)));
+    t.ok(b4a.equals(normalized.bdo.tx, toBuffer(hex('11', 32))));
+    t.ok(b4a.equals(normalized.bdo.txv, toBuffer(hex('22', 32))));
+    t.ok(b4a.equals(normalized.bdo.bs, toBuffer(hex('33', 32))));
+    t.ok(b4a.equals(normalized.bdo.ic, toBuffer(hex('44', 32))));
+    t.ok(b4a.equals(normalized.bdo.in, toBuffer(hex('55', 32))));
+    t.ok(b4a.equals(normalized.bdo.is, toBuffer(hex('66', 64))));
+});
+
+test('normalizeBootstrapDeploymentOperation accepts buffer inputs', t => {
+    const sender = randomAddress(config.addressPrefix);
+    const tx = toBuffer(hex('aa', 32));
+    const txv = toBuffer(hex('bb', 32));
+    const bootstrap = toBuffer(hex('cc', 32));
+    const channel = toBuffer(hex('dd', 32));
+    const nonce = toBuffer(hex('ee', 32));
+    const signature = toBuffer(hex('ff', 64));
+
+    const payload = {
+        type: OperationType.BOOTSTRAP_DEPLOYMENT,
+        address: sender,
+        bdo: {
+            tx,
+            txv,
+            bs: bootstrap,
+            ic: channel,
+            in: nonce,
+            is: signature
+        }
+    };
+
+    const normalized = normalizeBootstrapDeploymentOperation(payload, config);
+    t.ok(b4a.equals(normalized.bdo.tx, tx));
+    t.ok(b4a.equals(normalized.bdo.txv, txv));
+    t.ok(b4a.equals(normalized.bdo.bs, bootstrap));
+    t.ok(b4a.equals(normalized.bdo.ic, channel));
+    t.ok(b4a.equals(normalized.bdo.in, nonce));
+    t.ok(b4a.equals(normalized.bdo.is, signature));
+});
+
+test('normalizeBootstrapDeploymentOperation throws on missing payload fields', t => {
+    t.exception(
+        () => normalizeBootstrapDeploymentOperation({ type: OperationType.BOOTSTRAP_DEPLOYMENT }, config),
+        errorMessageIncludes('Invalid payload for bootstrap deployment normalization.')
+    );
+
+    t.exception(
+        () => normalizeBootstrapDeploymentOperation({ type: OperationType.TX, address: 'x', bdo: {} }, config),
+        errorMessageIncludes('Missing required fields in bootstrap deployment payload.')
+    );
+});
+
+test('normalizeBootstrapDeploymentOperation throws on invalid hex string', t => {
+    const sender = randomAddress(config.addressPrefix);
+    const payload = {
+        type: OperationType.BOOTSTRAP_DEPLOYMENT,
+        address: sender,
+        bdo: {
+            tx: 'zz',
+            txv: hex('22', 32),
+            bs: hex('33', 32),
+            ic: hex('44', 32),
+            in: hex('55', 32),
+            is: hex('66', 64)
+        }
+    };
+    t.exception(
+        () => normalizeBootstrapDeploymentOperation(payload, config),
+        errorMessageIncludes('Invalid hex string')
+    );
+});
+
+test('normalizeDecodedPayloadForJson converts buffers to strings', t => {
+    const address = randomAddress(config.addressPrefix);
+    const addressBuf = addressToBuffer(address, config.addressPrefix);
+    const amountBuf = bigIntTo16ByteBuffer(1234n);
+    const otherBuf = b4a.from('abcd', 'hex');
+
+    const payload = {
+        address: addressBuf,
+        am: amountBuf,
+        nested: {
+            to: addressBuf,
+            amount: amountBuf,
+            other: otherBuf
+        }
+    };
+
+    const normalized = normalizeDecodedPayloadForJson(payload, config);
+    t.is(normalized.address, address);
+    t.is(normalized.am, '1234');
+    t.is(normalized.nested.to, address);
+    t.is(normalized.nested.amount, '1234');
+    t.is(normalized.nested.other, 'abcd');
+});
+
+test('normalizeDecodedPayloadForJson falls back to hex for invalid address buffers', t => {
+    const bad = b4a.from('deadbeef', 'hex');
+    const payload = { address: bad };
+    const normalized = normalizeDecodedPayloadForJson(payload, config);
+    t.is(normalized.address, b4a.toString(bad, 'hex'));
+});
+
+test('normalizeDecodedPayloadForJson returns input for non-objects', t => {
+    t.is(normalizeDecodedPayloadForJson(null, config), null);
+    t.is(normalizeDecodedPayloadForJson('value', config), 'value');
+});