trac-msb 0.2.8 → 0.2.10

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

@@ -9,9 +9,10 @@ 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')
     
@@ -32,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()
     })
 }
 
@@ -121,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')
         })
@@ -134,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/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,7 +5,8 @@ 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';
 
@@ -17,11 +18,14 @@ export default function addAdminHappyPathScenario() {
 		const reader = readerNodes[0];
 
 		const txValidity = await deriveIndexerSequenceState(adminNode.base);
-        const addAdminPayload = await new CompleteStateMessageOperations(adminNode.wallet, config)
-            .assembleAddAdminMessage(
-                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);
 		await adminNode.base.update();

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
@@ -42,11 +42,14 @@ export async function setupAddAdminScenario(t) {
 export async function buildAddAdminRequesterPayload(context) {
 	const adminNode = context.adminBootstrap;
 	const txValidity = await deriveIndexerSequenceState(adminNode.base);
-    return new CompleteStateMessageOperations(adminNode.wallet, config)
-        .assembleAddAdminMessage(
-            adminNode.base.local.key,
-            txValidity
-        );
+	return safeEncodeApplyOperation(
+		await applyStateMessageFactory(adminNode.wallet, config)
+			.buildCompleteAddAdminMessage(
+				adminNode.wallet.address,
+				adminNode.base.local.key,
+				txValidity
+			)
+	);
 }
 
 export async function assertAddAdminRequesterFailureState(t, context) {

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

@@ -18,7 +18,8 @@ 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';
@@ -127,13 +128,15 @@ new TransactionValidityMismatchScenario({
 	setupScenario: setupAddAdminScenario,
 	buildValidPayload: buildAddAdminRequesterPayload,
 	assertStateUnchanged: assertAddAdminRequesterFailureState,
-	rebuildPayloadWithTxValidity: ({ context, mutatedTxValidity }) => {
+	rebuildPayloadWithTxValidity: async ({ context, mutatedTxValidity }) => {
 		const adminNode = context.adminBootstrap;
-        return new CompleteStateMessageOperations(adminNode.wallet, config)
-            .assembleAddAdminMessage(
-                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,
@@ -51,11 +52,10 @@ export async function buildAddIndexerPayload(
 	}
 
 	const txValidity = await deriveIndexerSequenceState(adminPeer.base);
-    return new CompleteStateMessageOperations(adminPeer.wallet, config)
-        .assembleAddIndexerMessage(
-            writerPeer.wallet.address,
-            txValidity
-        );
+	return safeEncodeApplyOperation(
+		await applyStateMessageFactory(adminPeer.wallet, config)
+			.buildCompleteAddIndexerMessage(adminPeer.wallet.address, writerPeer.wallet.address, txValidity)
+	);
 }
 
 export async function applyWithIndexerRoleUpdateFailure(context, invalidPayload) {
@@ -99,11 +99,10 @@ export async function buildAddIndexerPayloadWithTxValidity(
 		throw new Error('buildAddIndexerPayloadWithTxValidity requires an admin peer.');
 	}
 
-    return new CompleteStateMessageOperations(adminPeer.wallet, config)
-        .assembleAddIndexerMessage(
-            writerPeer.wallet.address,
-            mutatedTxValidity
-        );
+	return safeEncodeApplyOperation(
+		await applyStateMessageFactory(adminPeer.wallet, config)
+			.buildCompleteAddIndexerMessage(adminPeer.wallet.address, writerPeer.wallet.address, mutatedTxValidity)
+	);
 }
 
 export function ensureIndexerRegistration(base, writingKey) {
@@ -147,11 +146,10 @@ export async function buildRemoveIndexerPayload(
 	}
 
 	const txValidity = await deriveIndexerSequenceState(adminPeer.base);
-    return new CompleteStateMessageOperations(adminPeer.wallet, config)
-        .assembleRemoveIndexerMessage(
-            indexerPeer.wallet.address,
-            txValidity
-        );
+	return safeEncodeApplyOperation(
+		await applyStateMessageFactory(adminPeer.wallet, config)
+			.buildCompleteRemoveIndexerMessage(adminPeer.wallet.address, indexerPeer.wallet.address, txValidity)
+	);
 }
 
 export async function buildRemoveIndexerPayloadWithTxValidity(
@@ -169,11 +167,10 @@ export async function buildRemoveIndexerPayloadWithTxValidity(
 		throw new Error('buildRemoveIndexerPayloadWithTxValidity requires an admin peer.');
 	}
 
-    return new CompleteStateMessageOperations(adminPeer.wallet, config)
-        .assembleRemoveIndexerMessage(
-            indexerPeer.wallet.address,
-            mutatedTxValidity
-        );
+	return safeEncodeApplyOperation(
+		await applyStateMessageFactory(adminPeer.wallet, config)
+			.buildCompleteRemoveIndexerMessage(adminPeer.wallet.address, indexerPeer.wallet.address, mutatedTxValidity)
+	);
 }
 
 export async function assertAddIndexerSuccessState(

package/tests/unit/state/apply/addWriter/addWriterScenarioHelpers.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 { applyStateMessageFactory } from '../../../../../src/messages/state/applyStateMessageFactory.js';
+import { safeEncodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
 import { deriveIndexerSequenceState, eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
 import { safeDecodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
 import nodeEntryUtils, { ZERO_LICENSE } from '../../../../../src/core/state/utils/nodeEntry.js';
@@ -105,19 +105,24 @@ export async function buildAddWriterPayload(
 ) {
 	const txValidity = await deriveIndexerSequenceState(validatorPeer.base);
 	const writingKey = writerKeyBuffer ?? readerPeer.base.local.key;
-	const partial = await new PartialStateMessageOperations(readerPeer.wallet, config).assembleAddWriterMessage(
-		writingKey.toString('hex'),
-		txValidity.toString('hex')
-	);
+	const partial = await applyStateMessageFactory(readerPeer.wallet, config)
+		.buildPartialAddWriterMessage(
+			readerPeer.wallet.address,
+			writingKey.toString('hex'),
+			txValidity.toString('hex'),
+			'json'
+		);
 
-	return new CompleteStateMessageOperations(validatorPeer.wallet, config).assembleAddWriterMessage(
-		partial.address,
-		b4a.from(partial.rao.tx, 'hex'),
-		b4a.from(partial.rao.txv, 'hex'),
-		b4a.from(partial.rao.iw, 'hex'),
-		b4a.from(partial.rao.in, 'hex'),
-		b4a.from(partial.rao.is, 'hex')
-	);
+	const payload = await applyStateMessageFactory(validatorPeer.wallet, config)
+		.buildCompleteAddWriterMessage(
+			partial.address,
+			b4a.from(partial.rao.tx, 'hex'),
+			b4a.from(partial.rao.txv, 'hex'),
+			b4a.from(partial.rao.iw, 'hex'),
+			b4a.from(partial.rao.in, 'hex'),
+			b4a.from(partial.rao.is, 'hex')
+		);
+	return safeEncodeApplyOperation(payload);
 }
 
 export async function buildAddWriterPayloadWithTxValidity(
@@ -134,19 +139,24 @@ export async function buildAddWriterPayloadWithTxValidity(
 	}
 
 	const writingKey = writerKeyBuffer ?? readerPeer.base.local.key;
-	const partial = await new PartialStateMessageOperations(readerPeer.wallet, config).assembleAddWriterMessage(
-		writingKey.toString('hex'),
-		mutatedTxValidity.toString('hex')
-	);
+	const partial = await applyStateMessageFactory(readerPeer.wallet, config)
+		.buildPartialAddWriterMessage(
+			readerPeer.wallet.address,
+			writingKey.toString('hex'),
+			mutatedTxValidity.toString('hex'),
+			'json'
+		);
 
-	return new CompleteStateMessageOperations(validatorPeer.wallet, config).assembleAddWriterMessage(
-		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 payload = await applyStateMessageFactory(validatorPeer.wallet, config)
+		.buildCompleteAddWriterMessage(
+			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 buildRemoveWriterPayload(
@@ -159,19 +169,24 @@ export async function buildRemoveWriterPayload(
 ) {
 	const txValidity = await deriveIndexerSequenceState(validatorPeer.base);
 	const writerKey = writerKeyBuffer ?? readerPeer.base.local.key;
-	const partial = await new PartialStateMessageOperations(readerPeer.wallet, config).assembleRemoveWriterMessage(
-		writerKey.toString('hex'),
-		txValidity.toString('hex')
-	);
+	const partial = await applyStateMessageFactory(readerPeer.wallet, config)
+		.buildPartialRemoveWriterMessage(
+			readerPeer.wallet.address,
+			writerKey.toString('hex'),
+			txValidity.toString('hex'),
+			'json'
+		);
 
-	return new CompleteStateMessageOperations(validatorPeer.wallet, config).assembleRemoveWriterMessage(
-		partial.address,
-		b4a.from(partial.rao.tx, 'hex'),
-		b4a.from(partial.rao.txv, 'hex'),
-		b4a.from(partial.rao.iw, 'hex'),
-		b4a.from(partial.rao.in, 'hex'),
-		b4a.from(partial.rao.is, 'hex')
-	);
+	const payload = await applyStateMessageFactory(validatorPeer.wallet, config)
+		.buildCompleteRemoveWriterMessage(
+			partial.address,
+			b4a.from(partial.rao.tx, 'hex'),
+			b4a.from(partial.rao.txv, 'hex'),
+			b4a.from(partial.rao.iw, 'hex'),
+			b4a.from(partial.rao.in, 'hex'),
+			b4a.from(partial.rao.is, 'hex')
+		);
+	return safeEncodeApplyOperation(payload);
 }
 
 export async function assertAddWriterSuccessState(