trac-msb 0.2.7 → 0.2.9

package/tests/unit/messages/state/applyStateMessageBuilder.partial.test.js

@@ -0,0 +1,233 @@
+import { test } from 'brittle';
+import b4a from 'b4a';
+import PeerWallet from 'trac-wallet';
+
+import ApplyStateMessageBuilder from '../../../../src/messages/state/ApplyStateMessageBuilder.js';
+import { OperationType } from '../../../../src/utils/constants.js';
+import { isHexString } from '../../../../src/utils/helpers.js';
+import { config } from '../../../helpers/config.js';
+import { testKeyPair1, testKeyPair2 } from '../../../fixtures/apply.fixtures.js';
+import { isAddressValid } from '../../../../src/core/state/utils/address.js';
+
+const hex = (value, bytes) => value.repeat(bytes);
+
+async function createWallet(mnemonic) {
+    const wallet = new PeerWallet({ mnemonic, networkPrefix: config.addressPrefix });
+    await wallet.ready;
+    return wallet;
+}
+
+function expectHexField(t, value, bytes, label) {
+    t.is(typeof value, 'string', `${label} type`);
+    t.is(value.length, bytes * 2, `${label} length`);
+    t.ok(isHexString(value), `${label} hex`);
+}
+
+function expectAddressField(t, value, label) {
+    t.is(typeof value, 'string', `${label} type`);
+    t.is(value.length, config.addressLength, `${label} length`);
+    t.ok(isAddressValid(value, config.addressPrefix), `${label} valid`);
+}
+
+function expectKeys(t, value, keys, label) {
+    t.alike(Object.keys(value).sort(), keys.slice().sort(), `${label} keys`);
+}
+
+function expectPayloadKeys(t, payload, bodyKey) {
+    expectKeys(t, payload, ['type', 'address', bodyKey], 'payload');
+}
+
+test('ApplyStateMessageBuilder partial add writer (rao)', async t => {
+    const wallet = await createWallet(testKeyPair1.mnemonic);
+    const txValidity = hex('11', 32);
+    const writingKey = hex('22', 32);
+
+    const builder = new ApplyStateMessageBuilder(wallet, config);
+    await builder
+        .setPhase('partial')
+        .setOutput('json')
+        .setOperationType(OperationType.ADD_WRITER)
+        .setAddress(wallet.address)
+        .setTxValidity(txValidity)
+        .setWriterKey(writingKey)
+        .build();
+
+    const payload = builder.getPayload();
+    t.is(payload.type, OperationType.ADD_WRITER);
+    t.is(payload.address, wallet.address);
+    expectAddressField(t, payload.address, 'address');
+    expectPayloadKeys(t, payload, 'rao');
+    expectKeys(t, payload.rao, ['tx', 'txv', 'iw', 'in', 'is'], 'rao');
+    expectHexField(t, payload.rao.tx, 32, 'rao.tx');
+    expectHexField(t, payload.rao.txv, 32, 'rao.txv');
+    expectHexField(t, payload.rao.iw, 32, 'rao.iw');
+    expectHexField(t, payload.rao.in, 32, 'rao.in');
+    expectHexField(t, payload.rao.is, 64, 'rao.is');
+    t.is(payload.rao.txv, txValidity);
+    t.is(payload.rao.iw, writingKey);
+});
+
+test('ApplyStateMessageBuilder partial remove writer (rao)', async t => {
+    const wallet = await createWallet(testKeyPair1.mnemonic);
+    const txValidity = hex('33', 32);
+    const writingKey = hex('44', 32);
+
+    const builder = new ApplyStateMessageBuilder(wallet, config);
+    await builder
+        .setPhase('partial')
+        .setOutput('json')
+        .setOperationType(OperationType.REMOVE_WRITER)
+        .setAddress(wallet.address)
+        .setTxValidity(txValidity)
+        .setWriterKey(writingKey)
+        .build();
+
+    const payload = builder.getPayload();
+    t.is(payload.type, OperationType.REMOVE_WRITER);
+    t.is(payload.address, wallet.address);
+    expectPayloadKeys(t, payload, 'rao');
+    expectKeys(t, payload.rao, ['tx', 'txv', 'iw', 'in', 'is'], 'rao');
+    expectHexField(t, payload.rao.tx, 32, 'rao.tx');
+    expectHexField(t, payload.rao.txv, 32, 'rao.txv');
+    expectHexField(t, payload.rao.iw, 32, 'rao.iw');
+    expectHexField(t, payload.rao.in, 32, 'rao.in');
+    expectHexField(t, payload.rao.is, 64, 'rao.is');
+    t.is(payload.rao.txv, txValidity);
+    t.is(payload.rao.iw, writingKey);
+});
+
+test('ApplyStateMessageBuilder partial admin recovery (rao)', async t => {
+    const wallet = await createWallet(testKeyPair1.mnemonic);
+    const txValidity = hex('55', 32);
+    const writingKey = hex('66', 32);
+
+    const builder = new ApplyStateMessageBuilder(wallet, config);
+    await builder
+        .setPhase('partial')
+        .setOutput('json')
+        .setOperationType(OperationType.ADMIN_RECOVERY)
+        .setAddress(wallet.address)
+        .setTxValidity(txValidity)
+        .setWriterKey(writingKey)
+        .build();
+
+    const payload = builder.getPayload();
+    t.is(payload.type, OperationType.ADMIN_RECOVERY);
+    t.is(payload.address, wallet.address);
+    expectPayloadKeys(t, payload, 'rao');
+    expectKeys(t, payload.rao, ['tx', 'txv', 'iw', 'in', 'is'], 'rao');
+    expectHexField(t, payload.rao.tx, 32, 'rao.tx');
+    expectHexField(t, payload.rao.txv, 32, 'rao.txv');
+    expectHexField(t, payload.rao.iw, 32, 'rao.iw');
+    expectHexField(t, payload.rao.in, 32, 'rao.in');
+    expectHexField(t, payload.rao.is, 64, 'rao.is');
+    t.is(payload.rao.txv, txValidity);
+    t.is(payload.rao.iw, writingKey);
+});
+
+test('ApplyStateMessageBuilder partial bootstrap deployment (bdo)', async t => {
+    const wallet = await createWallet(testKeyPair1.mnemonic);
+    const txValidity = hex('77', 32);
+    const externalBootstrap = hex('88', 32);
+    const channel = hex('99', 32);
+
+    const builder = new ApplyStateMessageBuilder(wallet, config);
+    await builder
+        .setPhase('partial')
+        .setOutput('json')
+        .setOperationType(OperationType.BOOTSTRAP_DEPLOYMENT)
+        .setAddress(wallet.address)
+        .setTxValidity(txValidity)
+        .setExternalBootstrap(externalBootstrap)
+        .setChannel(channel)
+        .build();
+
+    const payload = builder.getPayload();
+    t.is(payload.type, OperationType.BOOTSTRAP_DEPLOYMENT);
+    t.is(payload.address, wallet.address);
+    expectPayloadKeys(t, payload, 'bdo');
+    expectKeys(t, payload.bdo, ['tx', 'txv', 'bs', 'ic', 'in', 'is'], 'bdo');
+    expectHexField(t, payload.bdo.tx, 32, 'bdo.tx');
+    expectHexField(t, payload.bdo.txv, 32, 'bdo.txv');
+    expectHexField(t, payload.bdo.bs, 32, 'bdo.bs');
+    expectHexField(t, payload.bdo.ic, 32, 'bdo.ic');
+    expectHexField(t, payload.bdo.in, 32, 'bdo.in');
+    expectHexField(t, payload.bdo.is, 64, 'bdo.is');
+    t.is(payload.bdo.txv, txValidity);
+    t.is(payload.bdo.bs, externalBootstrap);
+    t.is(payload.bdo.ic, channel);
+});
+
+test('ApplyStateMessageBuilder partial transaction operation (txo)', async t => {
+    const wallet = await createWallet(testKeyPair1.mnemonic);
+    const txValidity = hex('aa', 32);
+    const writingKey = hex('bb', 32);
+    const contentHash = hex('cc', 32);
+    const externalBootstrap = hex('dd', 32);
+    const msbBootstrap = hex('ee', 32);
+
+    const builder = new ApplyStateMessageBuilder(wallet, config);
+    await builder
+        .setPhase('partial')
+        .setOutput('json')
+        .setOperationType(OperationType.TX)
+        .setAddress(wallet.address)
+        .setTxValidity(txValidity)
+        .setWriterKey(writingKey)
+        .setContentHash(contentHash)
+        .setExternalBootstrap(externalBootstrap)
+        .setMsbBootstrap(msbBootstrap)
+        .build();
+
+    const payload = builder.getPayload();
+    t.is(payload.type, OperationType.TX);
+    t.is(payload.address, wallet.address);
+    expectPayloadKeys(t, payload, 'txo');
+    expectKeys(t, payload.txo, ['tx', 'txv', 'iw', 'ch', 'bs', 'mbs', 'in', 'is'], 'txo');
+    expectHexField(t, payload.txo.tx, 32, 'txo.tx');
+    expectHexField(t, payload.txo.txv, 32, 'txo.txv');
+    expectHexField(t, payload.txo.iw, 32, 'txo.iw');
+    expectHexField(t, payload.txo.ch, 32, 'txo.ch');
+    expectHexField(t, payload.txo.bs, 32, 'txo.bs');
+    expectHexField(t, payload.txo.mbs, 32, 'txo.mbs');
+    expectHexField(t, payload.txo.in, 32, 'txo.in');
+    expectHexField(t, payload.txo.is, 64, 'txo.is');
+    t.is(payload.txo.txv, txValidity);
+    t.is(payload.txo.iw, writingKey);
+    t.is(payload.txo.ch, contentHash);
+    t.is(payload.txo.bs, externalBootstrap);
+    t.is(payload.txo.mbs, msbBootstrap);
+});
+
+test('ApplyStateMessageBuilder partial transfer operation (tro)', async t => {
+    const wallet = await createWallet(testKeyPair1.mnemonic);
+    const otherWallet = await createWallet(testKeyPair2.mnemonic);
+    const txValidity = hex('ab', 32);
+    const amount = hex('cd', 16);
+
+    const builder = new ApplyStateMessageBuilder(wallet, config);
+    await builder
+        .setPhase('partial')
+        .setOutput('json')
+        .setOperationType(OperationType.TRANSFER)
+        .setAddress(wallet.address)
+        .setTxValidity(txValidity)
+        .setIncomingAddress(otherWallet.address)
+        .setAmount(amount)
+        .build();
+
+    const payload = builder.getPayload();
+    t.is(payload.type, OperationType.TRANSFER);
+    t.is(payload.address, wallet.address);
+    expectPayloadKeys(t, payload, 'tro');
+    expectKeys(t, payload.tro, ['tx', 'txv', 'to', 'am', 'in', 'is'], 'tro');
+    expectHexField(t, payload.tro.tx, 32, 'tro.tx');
+    expectHexField(t, payload.tro.txv, 32, 'tro.txv');
+    expectAddressField(t, payload.tro.to, 'tro.to');
+    expectHexField(t, payload.tro.am, 16, 'tro.am');
+    expectHexField(t, payload.tro.in, 32, 'tro.in');
+    expectHexField(t, payload.tro.is, 64, 'tro.is');
+    t.is(payload.tro.txv, txValidity);
+    t.is(payload.tro.to, otherWallet.address);
+    t.is(payload.tro.am, amount);
+});

package/tests/unit/network/ConnectionManager.test.js

@@ -5,12 +5,14 @@ import { testKeyPair1, testKeyPair2, testKeyPair3, testKeyPair4, testKeyPair5, t
 import ConnectionManager from "../../../src/core/network/services/ConnectionManager.js";
 import { tick } from "../../helpers/setupApplyTests.js";
 import b4a from 'b4a'
+import { createConfig, ENV } from "../../../src/config/env.js";
 
 const createConnection = (key) => {
     const emitter = new EventEmitter()
-    emitter.messenger = {
+    emitter.protocolSession = {
+        has: (name) => name === 'legacy',
         send: sinon.stub().resolves(),
-    }
+    };
     emitter.connected = true
     emitter.remotePublicKey = b4a.from(key, 'hex')
     
@@ -18,7 +20,8 @@ const createConnection = (key) => {
 }
 
 const makeManager = (maxValidators = 6, conns = connections) => {
-    const connectionManager = new ConnectionManager({ maxValidators })
+    const merged = createConfig(ENV.DEVELOPMENT, { maxValidators })
+    const connectionManager = new ConnectionManager(merged)
 
     conns.forEach(({ key, connection }) => {
         connectionManager.addValidator(key, connection)
@@ -30,7 +33,7 @@ const makeManager = (maxValidators = 6, conns = connections) => {
 const reset = () => {
     sinon.restore()
     connections.forEach(connection => {
-        connection.connection.messenger.send.resetHistory()
+        connection.connection.protocolSession.send.resetHistory()
     })
 }
 
@@ -78,7 +81,7 @@ test('ConnectionManager', () => {
                 createConnection(testKeyPair2.publicKey),
             ]
 
-            const connectionManager = new ConnectionManager({ maxValidators: maxConnections })
+            const connectionManager = makeManager(maxConnections)
             localConnections.forEach(({ key, connection }) => {
                 connectionManager.addValidator(key, connection)
             })
@@ -119,7 +122,7 @@ test('ConnectionManager', () => {
 
             const target = connectionManager.send([1,2,3,4])
 
-            const totalCalls = connections.reduce((sum, con) => sum + con.connection.messenger.send.callCount, 0)
+            const totalCalls = connections.reduce((sum, con) => sum + con.connection.protocolSession.send.callCount, 0)
             t.is(totalCalls, 1, 'should send to exactly one validator')
             t.ok(target, 'should return a target public key')
         })
@@ -132,7 +135,7 @@ test('ConnectionManager', () => {
             ]
 
             errorConnections.forEach(con => {
-                con.connection.messenger.send = sinon.stub().throws(new Error())
+                con.connection.protocolSession.send = sinon.stub().throws(new Error())
             })
 
             const connectionManager = makeManager(5, errorConnections)

package/tests/unit/network/NetworkWalletFactory.test.js

@@ -3,15 +3,14 @@ import sinon from 'sinon';
 import b4a from 'b4a';
 
 import PeerWallet from 'trac-wallet';
-import { TRAC_NETWORK_MSB_MAINNET_PREFIX } from 'trac-wallet/constants.js';
-
 import NetworkWalletFactory, { EphemeralWallet } from '../../../src/core/network/identity/NetworkWalletFactory.js';
 import { errorMessageIncludes } from '../../helpers/regexHelper.js';
 import { testKeyPair1, testKeyPair2 } from '../../fixtures/apply.fixtures.js';
+import { config } from '../../helpers/config.js';
 
 test('NetworkWalletFactory.provide returns wallet when enabled', async t => {
     const publicKey = b4a.from(testKeyPair2.publicKey, 'hex');
-    const address = PeerWallet.encodeBech32m(TRAC_NETWORK_MSB_MAINNET_PREFIX, publicKey);
+    const address = PeerWallet.encodeBech32m(config.addressPrefix, publicKey);
     const signResult = b4a.from('abcd', 'hex');
     const wallet = {
         publicKey,
@@ -20,7 +19,7 @@ test('NetworkWalletFactory.provide returns wallet when enabled', async t => {
         verify: sinon.stub().returns(true)
     };
 
-    const provider = NetworkWalletFactory.provide({ wallet, enableWallet: true });
+    const provider = NetworkWalletFactory.provide({ wallet, enableWallet: true, networkPrefix: config.addressPrefix });
     const message = b4a.from('00112233', 'hex');
     const signature = provider.sign(message);
 
@@ -39,7 +38,7 @@ test('NetworkWalletFactory.provide returns wallet when enabled', async t => {
 test('NetworkWalletFactory.provide requires both public and secret keys when wallet disabled', async t => {
     const publicKey = b4a.from(testKeyPair1.publicKey, 'hex');
     await t.exception(
-        () => NetworkWalletFactory.provide({ enableWallet: false, keyPair: { publicKey } }),
+        () => NetworkWalletFactory.provide({ enableWallet: false, keyPair: { publicKey }, networkPrefix: config.addressPrefix }),
         errorMessageIncludes('keyPair with publicKey and secretKey is required')
     );
 });
@@ -50,7 +49,8 @@ test('NetworkWalletFactory.provide rejects non-buffer inputs', async t => {
         () =>
             NetworkWalletFactory.provide({
                 enableWallet: false,
-                keyPair: { publicKey: 'not-a-buffer', secretKey }
+                keyPair: { publicKey: 'not-a-buffer', secretKey },
+                networkPrefix: config.addressPrefix
             }),
         errorMessageIncludes('must be a Buffer')
     );
@@ -65,7 +65,7 @@ test('NetworkWalletFactory.provide propagates invalid public key length errors',
             NetworkWalletFactory.provide({
                 enableWallet: false,
                 keyPair: { publicKey: invalidPublicKey, secretKey },
-                networkPrefix: TRAC_NETWORK_MSB_MAINNET_PREFIX
+                networkPrefix: config.addressPrefix
             }),
         errorMessageIncludes('Invalid public key')
     );
@@ -79,14 +79,14 @@ test('NetworkWalletFactory.provide derives address and signs payloads from keyPa
     const provider = NetworkWalletFactory.provide({
         enableWallet: false,
         keyPair,
-        networkPrefix: TRAC_NETWORK_MSB_MAINNET_PREFIX
+        networkPrefix: config.addressPrefix
     });
     const message = b4a.from('123455555', 'hex');
     const signature = provider.sign(message);
 
     t.is(
         provider.address,
-        PeerWallet.encodeBech32m(TRAC_NETWORK_MSB_MAINNET_PREFIX, provider.publicKey)
+        PeerWallet.encodeBech32m(config.addressPrefix, provider.publicKey)
     );
     t.ok(PeerWallet.verify(signature, message, provider.publicKey));
     t.ok(provider.verify(signature, message));
@@ -104,7 +104,7 @@ test('NetworkWalletFactory handles falsy address derivation results', async t =>
             NetworkWalletFactory.provide({
                 enableWallet: false,
                 keyPair,
-                networkPrefix: TRAC_NETWORK_MSB_MAINNET_PREFIX
+                networkPrefix: config.addressPrefix
             }),
         errorMessageIncludes('failed to derive address')
     );
@@ -124,7 +124,7 @@ test('NetworkWalletFactory propagates encoder exceptions', async t => {
             NetworkWalletFactory.provide({
                 enableWallet: false,
                 keyPair,
-                networkPrefix: TRAC_NETWORK_MSB_MAINNET_PREFIX
+                networkPrefix: config.addressPrefix
             }),
         errorMessageIncludes('test exception')
     );
@@ -137,12 +137,12 @@ test('EphemeralWallet exposes wallet like interface', async t => {
         publicKey: b4a.from(testKeyPair1.publicKey, 'hex'),
         secretKey: b4a.from(testKeyPair1.secretKey, 'hex')
     };
-    const wallet = new EphemeralWallet(keyPair, TRAC_NETWORK_MSB_MAINNET_PREFIX);
+    const wallet = new EphemeralWallet(keyPair, config.addressPrefix);
     const message = b4a.from('feedface', 'hex');
     const signature = wallet.sign(message);
 
     t.alike(wallet.publicKey, keyPair.publicKey);
-    t.is(wallet.address, PeerWallet.encodeBech32m(TRAC_NETWORK_MSB_MAINNET_PREFIX, keyPair.publicKey));
+    t.is(wallet.address, PeerWallet.encodeBech32m(config.addressPrefix, keyPair.publicKey));
     t.ok(PeerWallet.verify(signature, message, wallet.publicKey));
     t.ok(wallet.verify(signature, message));
 });
@@ -150,7 +150,7 @@ test('EphemeralWallet exposes wallet like interface', async t => {
 test('EphemeralWallet requires both public and secret keys', async t => {
     const publicKey = b4a.from(testKeyPair1.publicKey, 'hex');
     await t.exception(
-        () => new EphemeralWallet({ publicKey }, TRAC_NETWORK_MSB_MAINNET_PREFIX),
+        () => new EphemeralWallet({ publicKey }, config.addressPrefix),
         errorMessageIncludes('keyPair with publicKey and secretKey is required')
     );
 });

package/tests/unit/network/networkModule.test.js

@@ -1,9 +1,10 @@
 import { default as test } from 'brittle';
 
-async function runConnectionManagerTests() {
+async function runNetworkModuleTests() {
     test.pause();
     await import('./ConnectionManager.test.js');
+    await import('./NetworkWalletFactory.test.js');
     test.resume();
 }
 
-runConnectionManagerTests();
+await runNetworkModuleTests();

package/tests/unit/state/apply/addAdmin/addAdminHappyPathScenario.js

@@ -5,9 +5,10 @@ import {
 } from '../../../../helpers/autobaseTestHelpers.js';
 import nodeEntryUtils from '../../../../../src/core/state/utils/nodeEntry.js';
 import { toTerm } from '../../../../../src/core/state/utils/balance.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 { setupAddAdminScenario, assertAdminState } from './addAdminScenarioHelpers.js';
+import { config } from '../../../../helpers/config.js';
 
 export default function addAdminHappyPathScenario() {
 	test('State.apply addAdmin bootstraps admin node - happy path', async t => {
@@ -17,10 +18,13 @@ export default function addAdminHappyPathScenario() {
 		const reader = readerNodes[0];
 
 		const txValidity = await deriveIndexerSequenceState(adminNode.base);
-		const addAdminPayload = await CompleteStateMessageOperations.assembleAddAdminMessage(
-			adminNode.wallet,
-			adminNode.base.local.key,
-			txValidity
+		const addAdminPayload = safeEncodeApplyOperation(
+			await applyStateMessageFactory(adminNode.wallet, config)
+				.buildCompleteAddAdminMessage(
+					adminNode.wallet.address,
+					adminNode.base.local.key,
+					txValidity
+				)
 		);
 
 		await adminNode.base.append(addAdminPayload);

package/tests/unit/state/apply/addAdmin/addAdminScenarioHelpers.js

@@ -6,7 +6,7 @@ import {
 	deriveIndexerSequenceState,
 	eventFlush
 } from '../../../../helpers/autobaseTestHelpers.js';
-import CompleteStateMessageOperations from '../../../../../src/messages/completeStateMessages/CompleteStateMessageOperations.js';
+import { applyStateMessageFactory } from '../../../../../src/messages/state/applyStateMessageFactory.js';
 import {
 	safeDecodeApplyOperation,
 	safeEncodeApplyOperation
@@ -17,12 +17,12 @@ import {
 	ADMIN_INITIAL_BALANCE,
 	ADMIN_INITIAL_STAKED_BALANCE
 } from '../../../../../src/utils/constants.js';
-import { createSignature } from '../../../../helpers/createTestSignature.js';
 import adminEntryUtils from '../../../../../src/core/state/utils/adminEntry.js';
 import nodeEntryUtils from '../../../../../src/core/state/utils/nodeEntry.js';
 import lengthEntryUtils from '../../../../../src/core/state/utils/lengthEntry.js';
 import addressUtils from '../../../../../src/core/state/utils/address.js';
 import { safeWriteUInt32BE } from '../../../../../src/utils/buffer.js';
+import { config } from '../../../../helpers/config.js';
 
 export async function setupAddAdminScenario(t) {
 	const context = await setupStateNetwork({
@@ -42,10 +42,13 @@ export async function setupAddAdminScenario(t) {
 export async function buildAddAdminRequesterPayload(context) {
 	const adminNode = context.adminBootstrap;
 	const txValidity = await deriveIndexerSequenceState(adminNode.base);
-	return CompleteStateMessageOperations.assembleAddAdminMessage(
-		adminNode.wallet,
-		adminNode.base.local.key,
-		txValidity
+	return safeEncodeApplyOperation(
+		await applyStateMessageFactory(adminNode.wallet, config)
+			.buildCompleteAddAdminMessage(
+				adminNode.wallet.address,
+				adminNode.base.local.key,
+				txValidity
+			)
 	);
 }
 
@@ -103,7 +106,7 @@ export async function assertAdminState(t, base, wallet, writingKey, payload) {
 	const adminEntryRecord = await base.view.get(EntryType.ADMIN);
 	t.ok(adminEntryRecord, 'admin entry should exist');
 
-	const decodedAdminEntry = adminEntryUtils.decode(adminEntryRecord.value);
+	const decodedAdminEntry = adminEntryUtils.decode(adminEntryRecord.value, config.addressPrefix);
 	t.ok(decodedAdminEntry, 'admin entry decodes');
 	t.is(decodedAdminEntry.address, wallet.address, 'admin entry stores wallet address');
 	t.ok(b4a.equals(decodedAdminEntry.wk, writingKey), 'admin entry stores writing key');
@@ -126,7 +129,7 @@ export async function assertAdminState(t, base, wallet, writingKey, payload) {
 		'admin license id assigned'
 	);
 
-	const adminAddressBuffer = addressUtils.addressToBuffer(wallet.address);
+	const adminAddressBuffer = addressUtils.addressToBuffer(wallet.address, config.addressPrefix);
 	t.ok(adminAddressBuffer.length > 0, 'admin address encoded as buffer');
 	const writerRegistry = await base.view.get(EntryType.WRITER_ADDRESS + writingKey.toString('hex'));
 	t.ok(writerRegistry, 'writer registry entry exists');

package/tests/unit/state/apply/addAdmin/state.apply.addAdmin.test.js

@@ -18,11 +18,13 @@ import WriterKeyExistsValidationScenario from '../common/writerKeyExistsValidati
 import OperationAlreadyAppliedScenario from '../common/operationAlreadyAppliedScenario.js';
 import TransactionValidityMismatchScenario from '../common/transactionValidityMismatchScenario.js';
 import IndexerSequenceStateInvalidScenario from '../common/indexer/indexerSequenceStateInvalidScenario.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 addAdminEntryExistsScenario from './adminEntryExistsScenario.js';
 import addAdminNonBootstrapNodeScenario from './nonBootstrapNodeScenario.js';
 import addAdminNodeEntryInitializationFailureScenario from './nodeEntryInitializationFailureScenario.js';
 import addAdminEntryEncodingFailureScenario from './adminEntryEncodingFailureScenario.js';
+import { config } from '../../../../helpers/config.js';
 
 // happy path
 addAdminHappyPathScenario();
@@ -126,13 +128,15 @@ new TransactionValidityMismatchScenario({
 	setupScenario: setupAddAdminScenario,
 	buildValidPayload: buildAddAdminRequesterPayload,
 	assertStateUnchanged: assertAddAdminRequesterFailureState,
-	rebuildPayloadWithTxValidity: ({ context, mutatedTxValidity }) => {
+	rebuildPayloadWithTxValidity: async ({ context, mutatedTxValidity }) => {
 		const adminNode = context.adminBootstrap;
-		return CompleteStateMessageOperations.assembleAddAdminMessage(
-			adminNode.wallet,
-			adminNode.base.local.key,
-			mutatedTxValidity
-		);
+		const payload = await applyStateMessageFactory(adminNode.wallet, config)
+			.buildCompleteAddAdminMessage(
+				adminNode.wallet.address,
+				adminNode.base.local.key,
+				mutatedTxValidity
+			);
+		return safeEncodeApplyOperation(payload);
 },
 	expectedLogs: ['Transaction was not executed.']
 }).performScenario();

package/tests/unit/state/apply/addIndexer/addIndexerScenarioHelpers.js

@@ -1,5 +1,6 @@
 import b4a from 'b4a';
-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 {
 	setupAddWriterScenario,
@@ -12,6 +13,7 @@ import transactionUtils from '../../../../../src/core/state/utils/transaction.js
 import addressUtils from '../../../../../src/core/state/utils/address.js';
 import { safeDecodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
 import nodeRoleUtils from '../../../../../src/core/state/utils/roles.js';
+import { config } from '../../../../helpers/config.js';
 
 export function selectIndexerCandidatePeer(context, offset = 0) {
 	return selectWriterPeer(context, offset);
@@ -50,10 +52,9 @@ export async function buildAddIndexerPayload(
 	}
 
 	const txValidity = await deriveIndexerSequenceState(adminPeer.base);
-	return CompleteStateMessageOperations.assembleAddIndexerMessage(
-		adminPeer.wallet,
-		writerPeer.wallet.address,
-		txValidity
+	return safeEncodeApplyOperation(
+		await applyStateMessageFactory(adminPeer.wallet, config)
+			.buildCompleteAddIndexerMessage(adminPeer.wallet.address, writerPeer.wallet.address, txValidity)
 	);
 }
 
@@ -98,10 +99,9 @@ export async function buildAddIndexerPayloadWithTxValidity(
 		throw new Error('buildAddIndexerPayloadWithTxValidity requires an admin peer.');
 	}
 
-	return CompleteStateMessageOperations.assembleAddIndexerMessage(
-		adminPeer.wallet,
-		writerPeer.wallet.address,
-		mutatedTxValidity
+	return safeEncodeApplyOperation(
+		await applyStateMessageFactory(adminPeer.wallet, config)
+			.buildCompleteAddIndexerMessage(adminPeer.wallet.address, writerPeer.wallet.address, mutatedTxValidity)
 	);
 }
 
@@ -146,10 +146,9 @@ export async function buildRemoveIndexerPayload(
 	}
 
 	const txValidity = await deriveIndexerSequenceState(adminPeer.base);
-	return CompleteStateMessageOperations.assembleRemoveIndexerMessage(
-		adminPeer.wallet,
-		indexerPeer.wallet.address,
-		txValidity
+	return safeEncodeApplyOperation(
+		await applyStateMessageFactory(adminPeer.wallet, config)
+			.buildCompleteRemoveIndexerMessage(adminPeer.wallet.address, indexerPeer.wallet.address, txValidity)
 	);
 }
 
@@ -168,10 +167,9 @@ export async function buildRemoveIndexerPayloadWithTxValidity(
 		throw new Error('buildRemoveIndexerPayloadWithTxValidity requires an admin peer.');
 	}
 
-	return CompleteStateMessageOperations.assembleRemoveIndexerMessage(
-		adminPeer.wallet,
-		indexerPeer.wallet.address,
-		mutatedTxValidity
+	return safeEncodeApplyOperation(
+		await applyStateMessageFactory(adminPeer.wallet, config)
+			.buildCompleteRemoveIndexerMessage(adminPeer.wallet.address, indexerPeer.wallet.address, mutatedTxValidity)
 	);
 }
 
@@ -299,7 +297,7 @@ async function assertAddIndexerPayloadMetadata(t, base, payload, expectedAdminAd
 
 	const requesterAddressBuffer = decodedOperation.address;
 	t.ok(requesterAddressBuffer, 'addIndexer payload contains requester address');
-	const requesterAddress = addressUtils.bufferToAddress(requesterAddressBuffer);
+	const requesterAddress = addressUtils.bufferToAddress(requesterAddressBuffer, config.addressPrefix);
 	t.ok(requesterAddress, 'addIndexer requester address decodes');
 	if (requesterAddress) {
 		t.is(requesterAddress, expectedAdminAddress, 'addIndexer payload signed by admin');
@@ -307,7 +305,7 @@ async function assertAddIndexerPayloadMetadata(t, base, payload, expectedAdminAd
 
 	const candidateAddressBuffer = decodedOperation?.aco?.ia;
 	t.ok(candidateAddressBuffer, 'addIndexer payload contains candidate address');
-	const candidateAddress = addressUtils.bufferToAddress(candidateAddressBuffer);
+	const candidateAddress = addressUtils.bufferToAddress(candidateAddressBuffer, config.addressPrefix);
 	t.ok(candidateAddress, 'addIndexer candidate address decodes');
 	if (candidateAddress) {
 		t.is(candidateAddress, expectedCandidate, 'addIndexer payload nominates expected writer');
@@ -403,7 +401,7 @@ export async function applyWithPretenderRoleMutation(context, invalidPayload, ro
 				if (typeof key === 'string' ? key !== address : true) {
 					// string path comparison; buffer path is unlikely for address entries here
 					if (b4a.isBuffer(key)) {
-						const addrBuf = addressUtils.addressToBuffer(address);
+						const addrBuf = addressUtils.addressToBuffer(address, config.addressPrefix);
 						if (!addrBuf || !b4a.equals(addrBuf, key)) {
 							return originalGet(key);
 						}