trac-msb 0.2.6 → 0.2.8

package/tests/unit/state/apply/removeIndexer/removeIndexerScenarioHelpers.js

@@ -14,6 +14,7 @@ import {
 	buildRemoveIndexerPayloadWithTxValidity as buildRemoveIndexerPayloadWithTxValidityFromAddHelper,
 	assertAddIndexerSuccessState
 } from '../addIndexer/addIndexerScenarioHelpers.js';
+import { config } from '../../../../helpers/config.js';
 
 export async function setupRemoveIndexerScenario(t, options = {}) {
 	const context = await setupAddIndexerScenario(t, options);
@@ -102,7 +103,7 @@ export async function applyWithoutIndexerMembership(context, invalidPayload) {
 	}
 
 	const targetAddress = indexerPeer.wallet.address;
-	const targetAddressBuffer = addressUtils.addressToBuffer(targetAddress);
+	const targetAddressBuffer = addressUtils.addressToBuffer(targetAddress, config.addressPrefix);
 	if (!targetAddressBuffer) {
 		throw new Error('RemoveIndexer missing indexer membership scenario requires a decodable indexer address.');
 	}
@@ -277,7 +278,7 @@ async function assertWriterRegistry(t, base, writingKey, expectedAddress) {
 	const registryKey = EntryType.WRITER_ADDRESS + writingKey.toString('hex');
 	const entry = await base.view.get(registryKey);
 	t.ok(entry, 'writer registry entry exists after removeIndexer');
-	const addressBuffer = addressUtils.addressToBuffer(expectedAddress);
+	const addressBuffer = addressUtils.addressToBuffer(expectedAddress, config.addressPrefix);
 	t.ok(addressBuffer, 'indexer address encodes to buffer');
 	if (!entry?.value || !addressBuffer) return;
 	t.ok(
@@ -292,7 +293,7 @@ async function assertWriterIndexUpdates(t, base, lengthBefore, expectedAddress)
 
 	const indexEntry = await base.view.get(EntryType.WRITERS_INDEX + lengthBefore);
 	t.ok(indexEntry, 'writers index entry stored after removeIndexer');
-	const addressBuffer = addressUtils.addressToBuffer(expectedAddress);
+	const addressBuffer = addressUtils.addressToBuffer(expectedAddress, config.addressPrefix);
 	if (!indexEntry?.value || !addressBuffer) return;
 	t.ok(
 		b4a.equals(indexEntry.value, addressBuffer),
@@ -340,7 +341,7 @@ async function assertRemoveIndexerPayloadMetadata(t, base, payload, expectedAdmi
 
 	const requesterAddressBuffer = decodedOperation.address;
 	t.ok(requesterAddressBuffer, 'removeIndexer payload contains requester address');
-	const requesterAddress = addressUtils.bufferToAddress(requesterAddressBuffer);
+	const requesterAddress = addressUtils.bufferToAddress(requesterAddressBuffer, config.addressPrefix);
 	t.ok(requesterAddress, 'removeIndexer requester address decodes');
 	if (requesterAddress) {
 		t.is(requesterAddress, expectedAdmin, 'removeIndexer payload signed by admin');
@@ -348,7 +349,7 @@ async function assertRemoveIndexerPayloadMetadata(t, base, payload, expectedAdmi
 
 	const targetAddressBuffer = decodedOperation?.aco?.ia;
 	t.ok(targetAddressBuffer, 'removeIndexer payload contains target indexer address');
-	const targetAddress = addressUtils.bufferToAddress(targetAddressBuffer);
+	const targetAddress = addressUtils.bufferToAddress(targetAddressBuffer, config.addressPrefix);
 	t.ok(targetAddress, 'removeIndexer target address decodes');
 	if (targetAddress) {
 		t.is(targetAddress, expectedTarget, 'removeIndexer payload nominates expected indexer');

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

@@ -15,6 +15,7 @@ import { toBalance, BALANCE_FEE, BALANCE_TO_STAKE } from '../../../../../src/cor
 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,13 +180,11 @@ 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,
+	const partial = await new PartialStateMessageOperations(readerPeer.wallet, config).assembleRemoveWriterMessage(
 		writerKey.toString('hex'),
 		mutatedTxValidity.toString('hex')
 	);
-	return CompleteStateMessageOperations.assembleRemoveWriterMessage(
-		validatorPeer.wallet,
+	return new CompleteStateMessageOperations(validatorPeer.wallet, config).assembleRemoveWriterMessage(
 		partial.address,
 		b4a.from(partial.rao.tx, 'hex'),
 		mutatedTxValidity,
@@ -256,7 +255,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

@@ -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,40 @@ 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 new PartialStateMessageOperations(senderPeer.wallet, config)
+            .assembleTransferOperationMessage(
+                recipientA.wallet.address,
+                b4a.toString(DEFAULT_TRANSFER_AMOUNT, 'hex'),
+                b4a.toString(txValidityA, 'hex')
+            );
+        const partialB = await new PartialStateMessageOperations(senderPeer.wallet, config)
+            .assembleTransferOperationMessage(
+                recipientB.wallet.address,
+                b4a.toString(DEFAULT_TRANSFER_AMOUNT, 'hex'),
+                b4a.toString(txValidityB, 'hex')
+            );
+
+        const payloadA = await new CompleteStateMessageOperations(primaryValidator.wallet, config)
+            .assembleCompleteTransferOperationMessage(
+                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 new CompleteStateMessageOperations(secondaryValidator.wallet, config)
+            .assembleCompleteTransferOperationMessage(
+                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,4 +1,5 @@
 import b4a from 'b4a';
+import PeerWallet from 'trac-wallet';
 import PartialStateMessageOperations from '../../../../../src/messages/partialStateMessages/PartialStateMessageOperations.js';
 import CompleteStateMessageOperations from '../../../../../src/messages/completeStateMessages/CompleteStateMessageOperations.js';
 import { deriveIndexerSequenceState, eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
@@ -15,10 +16,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 +123,23 @@ 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 new PartialStateMessageOperations(senderPeer.wallet, config)
+        .assembleTransferOperationMessage(
+            recipientAddress,
+            b4a.toString(amount, 'hex'),
+            b4a.toString(resolvedTxValidity, 'hex')
+        );
+
+    return new CompleteStateMessageOperations(validatorPeer.wallet, config)
+        .assembleCompleteTransferOperationMessage(
+            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')
+        );
 }
 
 export async function buildTransferPayloadWithTxValidity(
@@ -204,9 +205,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 +612,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 +688,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 +736,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 +752,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 +773,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 +783,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 +805,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 +815,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 +842,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 +858,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 +949,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 +993,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

@@ -25,6 +25,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);
@@ -140,27 +141,27 @@ export async function buildTxOperationPayload(
 ) {
 	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 partial = await new PartialStateMessageOperations(broadcasterPeer.wallet, config)
+        .assembleTransactionOperationMessage(
+            writerKeyBuffer.toString('hex'),
+            resolvedTxValidity.toString('hex'),
+            contentHash.toString('hex'),
+            externalBootstrap.toString('hex'),
+            msbBootstrap.toString('hex')
+        );
+
+    return new CompleteStateMessageOperations(validatorPeer.wallet, config)
+        .assembleCompleteTransactionOperationMessage(
+						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')
+        );
 }
 
 export async function buildTxOperationPayloadWithTxValidity(context, txValidity, options = {}) {
@@ -208,8 +209,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 +310,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/utils/check/adminControlOperation.test.js

@@ -1,10 +1,10 @@
 import test from 'brittle'
-
 import Check from '../../../../src/utils/check.js'
-import {ACO, not_allowed_data_types} from '../../../fixtures/check.fixtures.js'
+import { ACO, not_allowed_data_types } from '../../../fixtures/check.fixtures.js'
 import { topLevelValidationTests, valueLevelValidationTest, addressBufferLengthTest, fieldsBufferLengthTest } from './common.test.js';
+import { config } from '../../../helpers/config.js';
 
-const check = new Check()
+const check = new Check(config)
 
 test('validateAdminControlOperation- happy paths for all operation types', t => {
     const validInputs = [

package/tests/unit/utils/check/balanceInitializationOperation.test.js

@@ -1,10 +1,10 @@
 import test from 'brittle'
-
 import Check from '../../../../src/utils/check.js'
 import { BIO, not_allowed_data_types } from '../../../fixtures/check.fixtures.js'
 import { topLevelValidationTests, valueLevelValidationTest, addressBufferLengthTest, fieldsBufferLengthTest } from './common.test.js';
+import { config } from '../../../helpers/config.js';
 
-const check = new Check()
+const check = new Check(config)
 
 test('validateBalanceInitialization - happy path', t => {
 

package/tests/unit/utils/check/bootstrapDeploymentOperation.test.js

@@ -1,11 +1,10 @@
 import test from 'brittle'
-
 import Check from '../../../../src/utils/check.js';
 import {BDO, not_allowed_data_types} from '../../../fixtures/check.fixtures.js';
-
 import { topLevelValidationTests, valueLevelValidationTest, addressBufferLengthTest, fieldsBufferLengthTest, partialTypeCommonTests } from './common.test.js';
+import { config } from '../../../helpers/config.js';
 
-const check = new Check();
+const check = new Check(config)
 
 test('validateBootstrapDeployment - happy-path case', t => {
     const partial_result = check.validateBootstrapDeploymentOperation(BDO.valid_partial_bootstrap_deployment)