trac-msb 0.2.7 → 0.2.9

package/tests/unit/state/apply/removeWriter/removeWriterScenarioHelpers.js

@@ -7,14 +7,15 @@ import {
 	assertValidatorReward,
 	promotePeerToWriter
 } from '../addWriter/addWriterScenarioHelpers.js';
-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 { safeEncodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
 import nodeEntryUtils from '../../../../../src/core/state/utils/nodeEntry.js';
 import addressUtils from '../../../../../src/core/state/utils/address.js';
 import { toBalance, BALANCE_FEE, BALANCE_TO_STAKE } from '../../../../../src/core/state/utils/balance.js';
 import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
 import { safeDecodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
 import { EntryType } from '../../../../../src/utils/constants.js';
+import { config } from '../../../../helpers/config.js';
 
 export async function setupRemoveWriterScenario(t, options = {}) {
 	const context = await setupAddWriterScenario(t, options);
@@ -142,7 +143,7 @@ async function assertWriterStillPromoted(t, base, writerPeer, expected) {
 		'writer stake remains untouched'
 	);
 
-	const writerAddressBuffer = addressUtils.addressToBuffer(writerAddress);
+	const writerAddressBuffer = addressUtils.addressToBuffer(writerAddress, config.addressPrefix);
 	const writingKeyHex = writerPeer.base.local.key.toString('hex');
 	const registryKey = EntryType.WRITER_ADDRESS + writingKeyHex;
 	const registryEntry = await base.view.get(registryKey);
@@ -161,7 +162,7 @@ async function assertPayloadProcessedByValidator(t, payload, expectedValidatorAd
 	const validatorAddressBuffer = decodedOperation?.rao?.va;
 	t.ok(validatorAddressBuffer, 'removeWriter payload carries validator address');
 	if (!validatorAddressBuffer) return;
-	const validatorAddress = addressUtils.bufferToAddress(validatorAddressBuffer);
+	const validatorAddress = addressUtils.bufferToAddress(validatorAddressBuffer, config.addressPrefix);
 	t.ok(validatorAddress, 'removeWriter payload validator address decodes');
 	if (!validatorAddress) return;
 	t.is(
@@ -179,20 +180,23 @@ export async function buildRemoveWriterPayloadWithTxValidity(context, mutatedTxV
 	}
 	const { readerPeer = selectWriterPeer(context), validatorPeer = context.adminBootstrap, writerKeyBuffer = null } = options;
 	const writerKey = writerKeyBuffer ?? readerPeer.base.local.key;
-	const partial = await PartialStateMessageOperations.assembleRemoveWriterMessage(
-		readerPeer.wallet,
-		writerKey.toString('hex'),
-		mutatedTxValidity.toString('hex')
-	);
-	return CompleteStateMessageOperations.assembleRemoveWriterMessage(
-		validatorPeer.wallet,
-		partial.address,
-		b4a.from(partial.rao.tx, 'hex'),
-		mutatedTxValidity,
-		b4a.from(partial.rao.iw, 'hex'),
-		b4a.from(partial.rao.in, 'hex'),
-		b4a.from(partial.rao.is, 'hex')
-	);
+	const partial = await applyStateMessageFactory(readerPeer.wallet, config)
+		.buildPartialRemoveWriterMessage(
+			readerPeer.wallet.address,
+			writerKey.toString('hex'),
+			mutatedTxValidity.toString('hex'),
+			'json'
+		);
+	const payload = await applyStateMessageFactory(validatorPeer.wallet, config)
+		.buildCompleteRemoveWriterMessage(
+			partial.address,
+			b4a.from(partial.rao.tx, 'hex'),
+			mutatedTxValidity,
+			b4a.from(partial.rao.iw, 'hex'),
+			b4a.from(partial.rao.in, 'hex'),
+			b4a.from(partial.rao.is, 'hex')
+		);
+	return safeEncodeApplyOperation(payload);
 }
 
 export async function snapshotDowngradedWriterEntry(context) {
@@ -256,7 +260,7 @@ export async function applyWithWriterRegistryForeignAddress(context, invalidPayl
 		throw new Error('Foreign registry override requires a peer with an address.');
 	}
 	const foreignEntry = {
-		value: addressUtils.addressToBuffer(foreignAddress)
+		value: addressUtils.addressToBuffer(foreignAddress, config.addressPrefix)
 	};
 	await withWriterRegistryOverrideOnApply({
 		context,

package/tests/unit/state/apply/transfer/transferDoubleSpendAcrossValidatorsScenario.js

@@ -1,7 +1,7 @@
 import b4a from 'b4a';
 import { test } from 'brittle';
-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 { safeEncodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
 import { deriveIndexerSequenceState, eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
 import {
 	setupTransferScenario,
@@ -13,6 +13,7 @@ import { promotePeerToWriter } from '../addWriter/addWriterScenarioHelpers.js';
 import transactionUtils from '../../../../../src/core/state/utils/transaction.js';
 import { toBalance } from '../../../../../src/core/state/utils/balance.js';
 import nodeEntryUtils from '../../../../../src/core/state/utils/nodeEntry.js';
+import { config } from '../../../../helpers/config.js';
 
 export default function transferDoubleSpendAcrossValidatorsScenario() {
 	test('State.apply transfer prevents double spend across validators (distinct tx hashes)', async t => {
@@ -49,40 +50,48 @@ export default function transferDoubleSpendAcrossValidatorsScenario() {
 		const txValidityA = await deriveIndexerSequenceState(primaryValidator.base);
 		const txValidityB = await deriveIndexerSequenceState(secondaryValidator.base);
 
-		const partialA = await PartialStateMessageOperations.assembleTransferOperationMessage(
-			senderPeer.wallet,
-			recipientA.wallet.address,
-			b4a.toString(DEFAULT_TRANSFER_AMOUNT, 'hex'),
-			b4a.toString(txValidityA, 'hex')
-		);
-		const partialB = await PartialStateMessageOperations.assembleTransferOperationMessage(
-			senderPeer.wallet,
-			recipientB.wallet.address,
-			b4a.toString(DEFAULT_TRANSFER_AMOUNT, 'hex'),
-			b4a.toString(txValidityB, 'hex')
-		);
-
-		const payloadA = await CompleteStateMessageOperations.assembleCompleteTransferOperationMessage(
-			primaryValidator.wallet,
-			partialA.address,
-			b4a.from(partialA.tro.tx, 'hex'),
-			b4a.from(partialA.tro.txv, 'hex'),
-			b4a.from(partialA.tro.in, 'hex'),
-			partialA.tro.to,
-			b4a.from(partialA.tro.am, 'hex'),
-			b4a.from(partialA.tro.is, 'hex')
-		);
-
-		const payloadB = await CompleteStateMessageOperations.assembleCompleteTransferOperationMessage(
-			secondaryValidator.wallet,
-			partialB.address,
-			b4a.from(partialB.tro.tx, 'hex'),
-			b4a.from(partialB.tro.txv, 'hex'),
-			b4a.from(partialB.tro.in, 'hex'),
-			partialB.tro.to,
-			b4a.from(partialB.tro.am, 'hex'),
-			b4a.from(partialB.tro.is, 'hex')
-		);
+        const partialA = await applyStateMessageFactory(senderPeer.wallet, config)
+            .buildPartialTransferOperationMessage(
+                senderPeer.wallet.address,
+                recipientA.wallet.address,
+                b4a.toString(DEFAULT_TRANSFER_AMOUNT, 'hex'),
+                b4a.toString(txValidityA, 'hex'),
+                'json'
+            );
+        const partialB = await applyStateMessageFactory(senderPeer.wallet, config)
+            .buildPartialTransferOperationMessage(
+                senderPeer.wallet.address,
+                recipientB.wallet.address,
+                b4a.toString(DEFAULT_TRANSFER_AMOUNT, 'hex'),
+                b4a.toString(txValidityB, 'hex'),
+                'json'
+            );
+
+        const payloadA = safeEncodeApplyOperation(
+            await applyStateMessageFactory(primaryValidator.wallet, config)
+                .buildCompleteTransferOperationMessage(
+                    partialA.address,
+                    b4a.from(partialA.tro.tx, 'hex'),
+                    b4a.from(partialA.tro.txv, 'hex'),
+                    b4a.from(partialA.tro.in, 'hex'),
+                    partialA.tro.to,
+                    b4a.from(partialA.tro.am, 'hex'),
+                    b4a.from(partialA.tro.is, 'hex')
+                )
+        );
+
+        const payloadB = safeEncodeApplyOperation(
+            await applyStateMessageFactory(secondaryValidator.wallet, config)
+                .buildCompleteTransferOperationMessage(
+                    partialB.address,
+                    b4a.from(partialB.tro.tx, 'hex'),
+                    b4a.from(partialB.tro.txv, 'hex'),
+                    b4a.from(partialB.tro.in, 'hex'),
+                    partialB.tro.to,
+                    b4a.from(partialB.tro.am, 'hex'),
+                    b4a.from(partialB.tro.is, 'hex')
+                )
+        );
 
 		// Apply first transfer successfully via primary validator.
 		await primaryValidator.base.append(payloadA);

package/tests/unit/state/apply/transfer/transferScenarioHelpers.js

@@ -1,6 +1,6 @@
 import b4a from 'b4a';
-import PartialStateMessageOperations from '../../../../../src/messages/partialStateMessages/PartialStateMessageOperations.js';
-import CompleteStateMessageOperations from '../../../../../src/messages/completeStateMessages/CompleteStateMessageOperations.js';
+import PeerWallet from 'trac-wallet';
+import { applyStateMessageFactory } from '../../../../../src/messages/state/applyStateMessageFactory.js';
 import { deriveIndexerSequenceState, eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
 import {
 	setupAdminNetwork,
@@ -15,10 +15,10 @@ import { toBalance, PERCENT_75, BALANCE_ZERO } from '../../../../../src/core/sta
 import { decimalStringToBigInt, bigIntTo16ByteBuffer } from '../../../../../src/utils/amountSerialization.js';
 import { safeDecodeApplyOperation, safeEncodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
 import { ZERO_WK } from '../../../../../src/utils/buffer.js';
-import { EntryType, OperationType, NETWORK_ID } from '../../../../../src/utils/constants.js';
+import { EntryType, OperationType } from '../../../../../src/utils/constants.js';
 import { createMessage } from '../../../../../src/utils/buffer.js';
-import { blake3Hash } from '../../../../../src/utils/crypto.js';
 import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import { config } from '../../../../helpers/config.js';
 
 export const DEFAULT_INITIAL_BALANCE = bigIntTo16ByteBuffer(decimalStringToBigInt('10'));
 export const DEFAULT_TRANSFER_AMOUNT = bigIntTo16ByteBuffer(decimalStringToBigInt('2'));
@@ -122,23 +122,26 @@ export async function buildTransferPayload(
 	const resolvedTxValidity =
 		txValidity ?? (await deriveIndexerSequenceState(validatorPeer.base));
 
-	const partial = await PartialStateMessageOperations.assembleTransferOperationMessage(
-		senderPeer.wallet,
-		recipientAddress,
-		b4a.toString(amount, 'hex'),
-		b4a.toString(resolvedTxValidity, 'hex')
-	);
-
-	return CompleteStateMessageOperations.assembleCompleteTransferOperationMessage(
-		validatorPeer.wallet,
-		partial.address,
-		b4a.from(partial.tro.tx, 'hex'),
-		b4a.from(partial.tro.txv, 'hex'),
-		b4a.from(partial.tro.in, 'hex'),
-		partial.tro.to,
-		b4a.from(partial.tro.am, 'hex'),
-		b4a.from(partial.tro.is, 'hex')
-	);
+    const partial = await applyStateMessageFactory(senderPeer.wallet, config)
+        .buildPartialTransferOperationMessage(
+            senderPeer.wallet.address,
+            recipientAddress,
+            b4a.toString(amount, 'hex'),
+            b4a.toString(resolvedTxValidity, 'hex'),
+            'json'
+        );
+
+    const payload = await applyStateMessageFactory(validatorPeer.wallet, config)
+        .buildCompleteTransferOperationMessage(
+            partial.address,
+            b4a.from(partial.tro.tx, 'hex'),
+            b4a.from(partial.tro.txv, 'hex'),
+            b4a.from(partial.tro.in, 'hex'),
+            partial.tro.to,
+            b4a.from(partial.tro.am, 'hex'),
+            b4a.from(partial.tro.is, 'hex')
+        );
+    return safeEncodeApplyOperation(payload);
 }
 
 export async function buildTransferPayloadWithTxValidity(
@@ -204,9 +207,9 @@ export async function assertTransferSuccessState(
 	t.ok(decodedPayload?.tro, 'transfer payload decodes');
 	if (!decodedPayload?.tro) return;
 
-	const senderAddress = addressUtils.bufferToAddress(decodedPayload.address);
-	const recipientAddress = addressUtils.bufferToAddress(decodedPayload.tro.to);
-	const validatorAddress = addressUtils.bufferToAddress(decodedPayload.tro.va);
+	const senderAddress = addressUtils.bufferToAddress(decodedPayload.address, config.addressPrefix);
+	const recipientAddress = addressUtils.bufferToAddress(decodedPayload.tro.to, config.addressPrefix);
+	const validatorAddress = addressUtils.bufferToAddress(decodedPayload.tro.va, config.addressPrefix);
 
 	const amount = toBalance(decodedPayload.tro.am);
 	const fee = toBalance(transactionUtils.FEE);
@@ -611,7 +614,7 @@ async function applyTransferSenderEntryOverride(context, invalidPayload, mutateE
 	}
 
 	const senderAddress = senderPeer.wallet.address;
-	const senderBuffer = addressUtils.addressToBuffer(senderAddress);
+	const senderBuffer = addressUtils.addressToBuffer(senderAddress, config.addressPrefix);
 	const base = node.base;
 	const originalApply = base._handlers.apply;
 
@@ -687,8 +690,8 @@ export async function mutateTransferAmountWithRehashedTx(t, validPayload) {
 	mutatedAmount[mutatedAmount.length - 1] ^= 0x01;
 	parent.am = mutatedAmount;
 
-	const message = createMessage(NETWORK_ID, parent.txv, parent.to, parent.am, parent.in, OperationType.TRANSFER);
-	const regeneratedTxHash = await blake3Hash(message);
+	const message = createMessage(config.networkId, parent.txv, parent.to, parent.am, parent.in, OperationType.TRANSFER);
+	const regeneratedTxHash = await PeerWallet.blake3(message);
 	if (regeneratedTxHash?.length === parent.tx?.length) {
 		parent.tx = regeneratedTxHash;
 	}
@@ -735,14 +738,14 @@ export async function mutateTransferAmountInvalidWithRehash(t, validPayload, con
 	parent.am = b4a.alloc(1); // invalid length to break toBalance
 
 	const requesterMessage = createMessage(
-		NETWORK_ID,
+		config.networkId,
 		parent.txv,
 		parent.to,
 		parent.am,
 		parent.in,
 		OperationType.TRANSFER
 	);
-	const regeneratedTxHash = await blake3Hash(requesterMessage);
+	const regeneratedTxHash = await PeerWallet.blake3(requesterMessage);
 	if (regeneratedTxHash?.length === parent.tx?.length) {
 		parent.tx = regeneratedTxHash;
 	}
@@ -751,8 +754,8 @@ export async function mutateTransferAmountInvalidWithRehash(t, validPayload, con
 		parent.is = requesterWallet.sign(regeneratedTxHash);
 	}
 	if (validatorWallet && parent.vn) {
-		const validatorMessage = createMessage(NETWORK_ID, parent.tx, parent.vn, OperationType.TRANSFER);
-		parent.vs = validatorWallet.sign(await blake3Hash(validatorMessage));
+		const validatorMessage = createMessage(config.networkId, parent.tx, parent.vn, OperationType.TRANSFER);
+		parent.vs = validatorWallet.sign(await PeerWallet.blake3(validatorMessage));
 	}
 
 	return safeEncodeApplyOperation(decoded);
@@ -772,8 +775,8 @@ export async function mutateTransferRecipientAddressWithRehash(t, validPayload,
 	}
 	parent.to = mutatedTo;
 
-	const message = createMessage(NETWORK_ID, parent.txv, parent.to, parent.am, parent.in, OperationType.TRANSFER);
-	const regeneratedTxHash = await blake3Hash(message);
+	const message = createMessage(config.networkId, parent.txv, parent.to, parent.am, parent.in, OperationType.TRANSFER);
+	const regeneratedTxHash = await PeerWallet.blake3(message);
 	if (regeneratedTxHash?.length === parent.tx?.length) {
 		parent.tx = regeneratedTxHash;
 	}
@@ -782,8 +785,8 @@ export async function mutateTransferRecipientAddressWithRehash(t, validPayload,
 		parent.is = requesterWallet.sign(regeneratedTxHash);
 	}
 	if (validatorWallet && parent.vn) {
-		const validatorMessage = createMessage(NETWORK_ID, parent.tx, parent.vn, OperationType.TRANSFER);
-		parent.vs = validatorWallet.sign(await blake3Hash(validatorMessage));
+		const validatorMessage = createMessage(config.networkId, parent.tx, parent.vn, OperationType.TRANSFER);
+		parent.vs = validatorWallet.sign(await PeerWallet.blake3(validatorMessage));
 	}
 
 	return safeEncodeApplyOperation(decoded);
@@ -804,8 +807,8 @@ export async function mutateTransferRecipientPublicKeyInvalidWithRehash(t, valid
 	}
 	parent.to = mutatedTo;
 
-	const message = createMessage(NETWORK_ID, parent.txv, parent.to, parent.am, parent.in, OperationType.TRANSFER);
-	const regeneratedTxHash = await blake3Hash(message);
+	const message = createMessage(config.networkId, parent.txv, parent.to, parent.am, parent.in, OperationType.TRANSFER);
+	const regeneratedTxHash = await PeerWallet.blake3(message);
 	if (regeneratedTxHash?.length === parent.tx?.length) {
 		parent.tx = regeneratedTxHash;
 	}
@@ -814,8 +817,8 @@ export async function mutateTransferRecipientPublicKeyInvalidWithRehash(t, valid
 		parent.is = requesterWallet.sign(regeneratedTxHash);
 	}
 	if (validatorWallet && parent.vn) {
-		const validatorMessage = createMessage(NETWORK_ID, parent.tx, parent.vn, OperationType.TRANSFER);
-		parent.vs = validatorWallet.sign(await blake3Hash(validatorMessage));
+		const validatorMessage = createMessage(config.networkId, parent.tx, parent.vn, OperationType.TRANSFER);
+		parent.vs = validatorWallet.sign(await PeerWallet.blake3(validatorMessage));
 	}
 
 	return safeEncodeApplyOperation(decoded);
@@ -841,14 +844,14 @@ export async function mutateTransferAmountToInvalidValue(t, validPayload, contex
 	parent.am = b4a.alloc(1); // forces toBalance(amount).value === null
 
 	const requesterMessage = createMessage(
-		NETWORK_ID,
+		config.networkId,
 		parent.txv,
 		parent.to,
 		parent.am,
 		parent.in,
 		OperationType.TRANSFER
 	);
-	const regeneratedTxHash = await blake3Hash(requesterMessage);
+	const regeneratedTxHash = await PeerWallet.blake3(requesterMessage);
 	if (regeneratedTxHash?.length === parent.tx?.length) {
 		parent.tx = regeneratedTxHash;
 	}
@@ -857,8 +860,8 @@ export async function mutateTransferAmountToInvalidValue(t, validPayload, contex
 		parent.is = requesterWallet.sign(regeneratedTxHash);
 	}
 	if (validatorWallet && parent.vn) {
-		const validatorMessage = createMessage(NETWORK_ID, parent.tx, parent.vn, OperationType.TRANSFER);
-		parent.vs = validatorWallet.sign(await blake3Hash(validatorMessage));
+		const validatorMessage = createMessage(config.networkId, parent.tx, parent.vn, OperationType.TRANSFER);
+		parent.vs = validatorWallet.sign(await PeerWallet.blake3(validatorMessage));
 	}
 
 	return safeEncodeApplyOperation(decoded);
@@ -948,7 +951,7 @@ async function applyTransferRecipientEntryOverride(context, invalidPayload, muta
 	}
 
 	const recipientAddress = recipientPeer.wallet.address;
-	const recipientBuffer = addressUtils.addressToBuffer(recipientAddress);
+	const recipientBuffer = addressUtils.addressToBuffer(recipientAddress, config.addressPrefix);
 	const base = node.base;
 	const originalApply = base._handlers.apply;
 
@@ -992,7 +995,7 @@ async function applyTransferRecipientBalanceDecodeFailure(context, invalidPayloa
 	}
 
 	const targetAddress = recipientPeer.wallet.address;
-	const targetBuffer = addressUtils.addressToBuffer(targetAddress);
+	const targetBuffer = addressUtils.addressToBuffer(targetAddress, config.addressPrefix);
 	const originalDecode = nodeEntryUtils.decode;
 	let shouldMutateNextDecode = false;
 

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
@@ -25,6 +24,7 @@ import {
 	safeDecodeApplyOperation,
 	safeEncodeApplyOperation
 } from '../../../../../src/utils/protobuf/operationHelpers.js';
+import { config } from '../../../../helpers/config.js';
 
 const DEFAULT_FUNDING = bigIntTo16ByteBuffer(decimalStringToBigInt('10'));
 const DEFAULT_CONTENT_HASH = b4a.alloc(32, 0xab);
@@ -138,29 +138,32 @@ export async function buildTxOperationPayload(
 		writerKeyBuffer = broadcasterPeer.base.local.key
 	} = {}
 ) {
-	const resolvedTxValidity = txValidity ?? (await deriveIndexerSequenceState(validatorPeer.base));
-
-	const partial = await PartialStateMessageOperations.assembleTransactionOperationMessage(
-		broadcasterPeer.wallet,
-		writerKeyBuffer.toString('hex'),
-		resolvedTxValidity.toString('hex'),
-		contentHash.toString('hex'),
-		externalBootstrap.toString('hex'),
-		msbBootstrap.toString('hex')
-	);
-
-	return CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-		validatorPeer.wallet,
-		partial.address,
-		b4a.from(partial.txo.tx, 'hex'),
-		b4a.from(partial.txo.txv, 'hex'),
-		b4a.from(partial.txo.iw, 'hex'),
-		b4a.from(partial.txo.in, 'hex'),
-		b4a.from(partial.txo.ch, 'hex'),
-		b4a.from(partial.txo.is, 'hex'),
-		b4a.from(partial.txo.bs, 'hex'),
-		b4a.from(partial.txo.mbs, 'hex')
-	);
+    const resolvedTxValidity = txValidity ?? (await deriveIndexerSequenceState(validatorPeer.base));
+
+    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'),
+            'json'
+        );
+
+    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'),
+            b4a.from(partial.txo.in, 'hex'),
+            b4a.from(partial.txo.ch, 'hex'),
+            b4a.from(partial.txo.is, 'hex'),
+            b4a.from(partial.txo.bs, 'hex'),
+            b4a.from(partial.txo.mbs, 'hex')
+        );
+    return safeEncodeApplyOperation(payload);
 }
 
 export async function buildTxOperationPayloadWithTxValidity(context, txValidity, options = {}) {
@@ -208,8 +211,8 @@ export async function assertTxOperationSuccessState(
 		t.ok(b4a.equals(msbBootstrap, context.txOperation?.msbBootstrap), 'payload MSB bootstrap matches network');
 	}
 
-	const requesterAddress = addressUtils.bufferToAddress(requesterAddressBuffer);
-	const validatorAddress = addressUtils.bufferToAddress(validatorAddressBuffer);
+	const requesterAddress = addressUtils.bufferToAddress(requesterAddressBuffer, config.addressPrefix);
+	const validatorAddress = addressUtils.bufferToAddress(validatorAddressBuffer, config.addressPrefix);
 
 	t.is(requesterAddress, broadcasterPeer.wallet.address, 'requester matches broadcaster');
 	t.is(validatorAddress, validatorPeer.wallet.address, 'validator matches selected peer');
@@ -309,10 +312,10 @@ export async function assertTxOperationSuccessState(
 	const deploymentKey = `${EntryType.DEPLOYMENT}${externalBootstrap.toString('hex')}`;
 	const deploymentEntry = await validatorPeer.base.view.get(deploymentKey);
 	t.ok(deploymentEntry, 'deployment entry remains present after tx');
-	const decodedDeployment = deploymentEntryUtils.decode(deploymentEntry?.value);
+	const decodedDeployment = deploymentEntryUtils.decode(deploymentEntry?.value, config.addressLength);
 	t.ok(decodedDeployment, 'deployment entry decodes after tx');
 	if (decodedDeployment?.address) {
-		const creatorAddress = addressUtils.bufferToAddress(decodedDeployment.address);
+		const creatorAddress = addressUtils.bufferToAddress(decodedDeployment.address, config.addressPrefix);
 		t.is(
 			creatorAddress,
 			creatorPeer.wallet.address,

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

@@ -8,6 +8,7 @@ import {
 	assertTxOperationFailureState
 } from './txOperationScenarioHelpers.js';
 import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import { config } from '../../../../helpers/config.js'
 
 /**
  * Builds a transferFeeTxOperation guard scenario that runs through the full apply path.
@@ -34,7 +35,7 @@ export function createTransferFeeGuardScenario({
 	applyInvalidPayload: async (context, invalidPayload) => {
 		const node = context.txOperation?.validatorPeer ?? context.peers?.[1];
 		const decoded = safeDecodeApplyOperation(invalidPayload);
-		const requesterAddressString = addressUtils.bufferToAddress(decoded?.address);
+		const requesterAddressString = addressUtils.bufferToAddress(decoded?.address, config.addressPrefix);
 
 		const patchResult = await applyPatch({ context, node, decoded, requesterAddressString });
 		const cleanup = typeof patchResult === 'function' ? patchResult : patchResult?.cleanup;

package/tests/unit/state/stateModule.test.js

@@ -8,7 +8,6 @@ async function runStateTests() {
     await import('./utils/adminEntry.test.js');
     await import('./utils/balance.test.js');
     await import('./utils/nodeEntry.test.js');
-    await import('./utils/indexerEntry.test.js');
     await import('./utils/lengthEntry.test.js');
     await import('./utils/roles.test.js');
     // These tests are skipped temoporarily because the mock library sinon does not work with bare.

package/tests/unit/state/stateTestUtils.js

@@ -1,14 +1,18 @@
 import b4a from 'b4a';
 import { bech32m } from 'bech32';
-import { TRAC_NETWORK_MSB_MAINNET_PREFIX } from 'trac-wallet/constants.js';
+import { address as addressApi } from 'trac-crypto-api';
 import { TOKEN_DECIMALS } from '../../../src/utils/constants.js';
 
 export function randomBuffer(size) {
     return b4a.from(Array.from({ length: size }, () => Math.floor(Math.random() * 256)));
 }
 
-export function randomAddress(hrp = TRAC_NETWORK_MSB_MAINNET_PREFIX) {
-    const data = randomBuffer(32);
+export function randomAddress(hrp) {
+    // Compute payload size so final string length equals addressApi.size(hrp)
+    const totalLen = addressApi.size(hrp); // expected address string length
+    const dataWordLen = totalLen - (hrp.length + 1 + 6); // data chars = total - hrp - sep - checksum
+    const dataBytesLen = Math.floor((dataWordLen * 5) / 8); // bytes that yield that many 5-bit words
+    const data = randomBuffer(dataBytesLen);
     return bech32m.encode(hrp, bech32m.toWords(data));
 }
 

package/tests/unit/state/utils/address.test.js

@@ -1,8 +1,8 @@
 import { test } from 'brittle';
 import b4a from 'b4a';
-import { TRAC_ADDRESS_SIZE } from '../../../../src/utils/constants.js';
 import { randomAddress } from '../stateTestUtils.js';
 import addressUtils from '../../../../src/core/state/utils/address.js';
+import { address as addressApi } from 'trac-crypto-api';
 
 test('Convert bech32m address to and from buffer - Happy Path', t => {
     const hrp = 'test';
@@ -14,8 +14,8 @@ test('Convert bech32m address to and from buffer - Happy Path', t => {
     t.ok(b4a.isBuffer(addressBuffer), 'Address buffer should be a Buffer instance');
     t.is(typeof reconstructedAddress, 'string', 'Reconstructed address should be a string');
     t.is(address, reconstructedAddress, 'Reconstructed address should match original');
-    t.is(address.length, TRAC_ADDRESS_SIZE, 'Address length should match expected size');
-    t.is(addressBuffer.length, TRAC_ADDRESS_SIZE, 'Address buffer length should match address length');
+    t.is(address.length, addressApi.size(hrp), 'Address length should match expected size');
+    t.is(addressBuffer.length, addressApi.size(hrp), 'Address buffer length should match address length');
 });
 
 test('isAddressValid returns false for wrong prefix', t => {

package/tests/unit/state/utils/adminEntry.test.js

@@ -1,21 +1,22 @@
 import { test } from 'brittle';
 import b4a from 'b4a';
-import { WRITER_BYTE_LENGTH, TRAC_ADDRESS_SIZE } from '../../../../src/utils/constants.js';
+import { WRITER_BYTE_LENGTH } from '../../../../src/utils/constants.js';
 import { randomAddress, randomBuffer } from '../stateTestUtils.js';
 import addressUtils from '../../../../src/core/state/utils/address.js';
 import adminEntryUtils from '../../../../src/core/state/utils/adminEntry.js';
+import { config } from '../../../helpers/config.js';
 
-const isAddressValid = addressUtils.isAddressValid;
+const isAddressValid = address => addressUtils.isAddressValid(address, config.addressPrefix);
 const addressToBuffer = addressUtils.addressToBuffer;
-const encodeAdminEntry = adminEntryUtils.encode;
-const decodeAdminEntry = adminEntryUtils.decode;
-const ADMIN_ENTRY_SIZE = TRAC_ADDRESS_SIZE + WRITER_BYTE_LENGTH;
+const encodeAdminEntry = (address, wk) => adminEntryUtils.encode(address, wk, config.addressPrefix);
+const decodeAdminEntry = entry => adminEntryUtils.decode(entry, config.addressPrefix);
+const ADMIN_ENTRY_SIZE = config.addressLength + WRITER_BYTE_LENGTH;
 
 test('Admin Entry - Encode and Decode - Happy Path', t => {
-    const address = randomAddress();
+    const address = randomAddress(config.addressPrefix);
     const wk = randomBuffer(WRITER_BYTE_LENGTH);
 
-    const encoded = encodeAdminEntry(addressToBuffer(address), wk);
+    const encoded = encodeAdminEntry(addressToBuffer(address, config.addressPrefix), wk);
     t.is(encoded.length, ADMIN_ENTRY_SIZE, "encoding has valid length");
 
     const decoded = decodeAdminEntry(encoded);
@@ -26,8 +27,8 @@ test('Admin Entry - Encode and Decode - Happy Path', t => {
 });
 
 test('Admin Entry - Encode returns empty buffer on invalid input', t => {
-    const addrString = randomAddress();
-    const validAddress = addressToBuffer(addrString);
+    const addrString = randomAddress(config.addressPrefix);
+    const validAddress = addressToBuffer(addrString, config.addressPrefix);
     const separatorIndex = addrString.indexOf('1');
     const invalidAddress = validAddress.subarray(separatorIndex); // missing HRP
 

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();
 }