trac-msb 0.2.4 → 0.2.6

package/tests/unit/state/apply/bootstrapDeployment/bootstrapDeploymentIncompleteOperationScenario.js

@@ -0,0 +1,94 @@
+import b4a from 'b4a';
+import {
+	setupBootstrapDeploymentScenario,
+	buildBootstrapDeploymentPayload,
+	assertBootstrapDeploymentFailureState
+} from './bootstrapDeploymentScenarioHelpers.js';
+import { safeDecodeApplyOperation, safeEncodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+
+function removeValidatorFields(t, validPayload) {
+	const decoded = safeDecodeApplyOperation(validPayload);
+	t.ok(decoded, 'valid payload decodes before mutation');
+	if (!decoded?.bdo) return validPayload;
+	const mutated = safeEncodeApplyOperation({
+		type: decoded.type,
+		address: decoded.address,
+		bdo: {
+			tx: decoded.bdo.tx,
+			txv: decoded.bdo.txv,
+			bs: decoded.bdo.bs,
+			ic: decoded.bdo.ic,
+			in: decoded.bdo.in,
+			is: decoded.bdo.is
+		}
+	});
+	const roundtrip = safeDecodeApplyOperation(mutated);
+	t.ok(roundtrip, 'mutated payload decodes');
+	return mutated;
+}
+
+async function assertStateUnchanged(t, context, validPayload) {
+	const decoded = safeDecodeApplyOperation(validPayload);
+	t.ok(decoded, 'valid payload decodes for assertions');
+	if (!decoded) return;
+
+	const { validatorEntryBefore, deployerEntryBefore, externalBootstrap } = context.bootstrapDeployment ?? {};
+	const validatorPeer = context.bootstrapDeployment?.validatorPeer ?? context.peers?.[1];
+	const deployerPeer = context.bootstrapDeployment?.deployerPeer ?? context.peers?.[2];
+
+	const validatorEntryAfter = await validatorPeer.base.view.get(validatorPeer.wallet.address);
+	t.ok(validatorEntryAfter, 'validator entry still exists after rejected incomplete op');
+	if (validatorEntryBefore?.value && validatorEntryAfter?.value) {
+		t.ok(
+			b4a.equals(validatorEntryAfter.value, validatorEntryBefore.value),
+			'validator entry remains unchanged after incomplete op'
+		);
+	}
+
+	const deployerEntryAfter = await validatorPeer.base.view.get(deployerPeer.wallet.address);
+	t.ok(deployerEntryAfter, 'deployer entry still exists after rejected incomplete op');
+	if (deployerEntryBefore?.value && deployerEntryAfter?.value) {
+		const before = nodeEntryUtils.decode(deployerEntryBefore.value);
+		const after = nodeEntryUtils.decode(deployerEntryAfter.value);
+		t.ok(before, 'deployer entry before decodes');
+		t.ok(after, 'deployer entry after decodes');
+		if (before && after) {
+			t.ok(b4a.equals(after.balance, before.balance), 'deployer balance unchanged after incomplete op');
+			t.ok(
+				b4a.equals(after.stakedBalance, before.stakedBalance),
+				'deployer stake unchanged after incomplete op'
+			);
+		}
+	}
+
+	const bootstrapBuffer = externalBootstrap ?? decoded?.bdo?.bs;
+	if (bootstrapBuffer) {
+		const deploymentKey = `${EntryType.DEPLOYMENT}${bootstrapBuffer.toString('hex')}`;
+		const deploymentEntry = await validatorPeer.base.view.get(deploymentKey);
+		t.is(deploymentEntry, null, 'deployment entry not created after incomplete op');
+	}
+
+	const txHashBuffer = decoded?.bdo?.tx;
+	if (txHashBuffer) {
+		const txEntry = await validatorPeer.base.view.get(txHashBuffer.toString('hex'));
+		t.is(txEntry, null, 'tx hash not recorded after incomplete op');
+	}
+}
+
+export default function bootstrapDeploymentIncompleteOperationScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply bootstrapDeployment rejects operations missing validator cosignature',
+		setupScenario: setupBootstrapDeploymentScenario,
+		buildValidPayload: buildBootstrapDeploymentPayload,
+		mutatePayload: removeValidatorFields,
+		applyInvalidPayload: async (context, invalidPayload) => {
+			const { bootstrap } = context;
+			await bootstrap.base.append(invalidPayload);
+			await bootstrap.base.update();
+		},
+		assertStateUnchanged: (t, context, _validPayload, invalidPayload) =>
+			assertBootstrapDeploymentFailureState(t, context, { payload: invalidPayload }),
+		expectedLogs: ['Contract schema validation failed.']
+	}).performScenario();
+}

package/tests/unit/state/apply/bootstrapDeployment/bootstrapDeploymentInvalidDeploymentEntryScenario.js

@@ -0,0 +1,37 @@
+import b4a from 'b4a';
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import {
+	setupBootstrapDeploymentScenario,
+	buildBootstrapDeploymentPayload,
+	assertBootstrapDeploymentFailureState
+} from './bootstrapDeploymentScenarioHelpers.js';
+import deploymentEntryUtils from '../../../../../src/core/state/utils/deploymentEntry.js';
+
+async function applyPayloadWithEncodeFailure(context, invalidPayload) {
+	const node = context.bootstrapDeployment?.validatorPeer ?? context.bootstrap ?? context.peers?.[0];
+	const originalEncode = deploymentEntryUtils.encode;
+	deploymentEntryUtils.encode = () => b4a.alloc(0);
+
+	try {
+		await node.base.append(invalidPayload);
+		await node.base.update();
+	} finally {
+		deploymentEntryUtils.encode = originalEncode;
+	}
+}
+
+export default function bootstrapDeploymentInvalidDeploymentEntryScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply bootstrapDeployment rejects payloads when deployment entry cannot be encoded',
+		setupScenario: setupBootstrapDeploymentScenario,
+		buildValidPayload: buildBootstrapDeploymentPayload,
+		mutatePayload: (_t, validPayload) => validPayload,
+		applyInvalidPayload: applyPayloadWithEncodeFailure,
+		assertStateUnchanged: (t, context, _valid, invalidPayload) =>
+			assertBootstrapDeploymentFailureState(t, context, {
+				payload: invalidPayload,
+				skipValidatorEquality: true
+			}),
+		expectedLogs: ['Invalid deployment entry.']
+	}).performScenario();
+}

package/tests/unit/state/apply/bootstrapDeployment/bootstrapDeploymentMultipleBootstrapScenario.js

@@ -0,0 +1,86 @@
+import { test } from 'brittle';
+import b4a from 'b4a';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import {
+	setupBootstrapDeploymentScenario,
+	buildBootstrapDeploymentPayload,
+	assertBootstrapDeploymentSuccessState
+} from './bootstrapDeploymentScenarioHelpers.js';
+import { EntryType } from '../../../../../src/utils/constants.js';
+import { decimalStringToBigInt, bigIntTo16ByteBuffer } from '../../../../../src/utils/amountSerialization.js';
+
+const DOUBLE_FUNDING = bigIntTo16ByteBuffer(decimalStringToBigInt('20'));
+
+export default function bootstrapDeploymentMultipleBootstrapScenario() {
+	test(
+		'State.apply bootstrapDeployment allows a requester to register multiple external bootstraps',
+		async t => {
+			const context = await setupBootstrapDeploymentScenario(t, {
+				nodes: 4,
+				deployerInitialBalance: DOUBLE_FUNDING,
+				validatorInitialBalance: DOUBLE_FUNDING
+			});
+
+			const validatorPeer = context.bootstrapDeployment?.validatorPeer ?? context.peers[1];
+			const deployerPeer = context.bootstrapDeployment?.deployerPeer ?? context.peers[2];
+			const extraPeer = context.peers.at(-1);
+
+			const firstBootstrap = context.bootstrapDeployment?.externalBootstrap ?? b4a.from(deployerPeer.base.local.key);
+			const secondBootstrap = extraPeer ? b4a.from(extraPeer.base.local.key) : b4a.alloc(firstBootstrap.length, 0x02);
+			const secondChannel = extraPeer ? b4a.from(extraPeer.base.local.key) : b4a.alloc(firstBootstrap.length, 0x03);
+
+			const validatorEntryBefore1 = await validatorPeer.base.view.get(validatorPeer.wallet.address);
+			const deployerEntryBefore1 = await validatorPeer.base.view.get(deployerPeer.wallet.address);
+
+			const firstPayload = await buildBootstrapDeploymentPayload(context, {
+				externalBootstrap: firstBootstrap
+			});
+
+			await validatorPeer.base.append(firstPayload);
+			await validatorPeer.base.update();
+			await eventFlush();
+
+			await assertBootstrapDeploymentSuccessState(t, context, {
+				payload: firstPayload,
+				externalBootstrap: firstBootstrap,
+				validatorEntryBefore: validatorEntryBefore1?.value,
+				deployerEntryBefore: deployerEntryBefore1?.value
+			});
+
+			const validatorEntryBefore2 = await validatorPeer.base.view.get(validatorPeer.wallet.address);
+			const deployerEntryBefore2 = await validatorPeer.base.view.get(deployerPeer.wallet.address);
+
+			const secondPayload = await buildBootstrapDeploymentPayload(context, {
+				externalBootstrap: secondBootstrap,
+				channel: secondChannel
+			});
+
+			await validatorPeer.base.append(secondPayload);
+			await validatorPeer.base.update();
+			await eventFlush();
+
+			await assertBootstrapDeploymentSuccessState(t, context, {
+				payload: secondPayload,
+				externalBootstrap: secondBootstrap,
+				channel: secondChannel,
+				validatorEntryBefore: validatorEntryBefore2?.value,
+				deployerEntryBefore: deployerEntryBefore2?.value
+			});
+
+			const firstKey = `${EntryType.DEPLOYMENT}${firstBootstrap.toString('hex')}`;
+			const secondKey = `${EntryType.DEPLOYMENT}${secondBootstrap.toString('hex')}`;
+
+			const firstEntry = await validatorPeer.base.view.get(firstKey);
+			const secondEntry = await validatorPeer.base.view.get(secondKey);
+			t.ok(firstEntry, 'first deployment entry stored on validator view');
+			t.ok(secondEntry, 'second deployment entry stored on validator view');
+
+			await context.sync();
+
+			const firstEntryReplica = await deployerPeer.base.view.get(firstKey);
+			const secondEntryReplica = await deployerPeer.base.view.get(secondKey);
+			t.ok(firstEntryReplica, 'first deployment entry replicated to deployer view');
+			t.ok(secondEntryReplica, 'second deployment entry replicated to deployer view');
+		}
+	);
+}

package/tests/unit/state/apply/bootstrapDeployment/bootstrapDeploymentScenarioHelpers.js

@@ -0,0 +1,344 @@
+import b4a from 'b4a';
+import PartialStateMessageOperations from '../../../../../src/messages/partialStateMessages/PartialStateMessageOperations.js';
+import CompleteStateMessageOperations from '../../../../../src/messages/completeStateMessages/CompleteStateMessageOperations.js';
+import { deriveIndexerSequenceState } from '../../../../helpers/autobaseTestHelpers.js';
+import {
+	setupAdminNetwork,
+	initializeBalances,
+	whitelistAddress
+} from '../common/commonScenarioHelper.js';
+import {
+	promotePeerToWriter,
+	assertValidatorReward
+} from '../addWriter/addWriterScenarioHelpers.js';
+import nodeEntryUtils from '../../../../../src/core/state/utils/nodeEntry.js';
+import deploymentEntryUtils from '../../../../../src/core/state/utils/deploymentEntry.js';
+import transactionUtils from '../../../../../src/core/state/utils/transaction.js';
+import addressUtils from '../../../../../src/core/state/utils/address.js';
+import { toBalance } from '../../../../../src/core/state/utils/balance.js';
+import { EntryType } from '../../../../../src/utils/constants.js';
+import { decimalStringToBigInt, bigIntTo16ByteBuffer } from '../../../../../src/utils/amountSerialization.js';
+import { safeDecodeApplyOperation, safeEncodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
+
+const DEFAULT_FUNDING = bigIntTo16ByteBuffer(decimalStringToBigInt('10'));
+
+export function selectBootstrapValidatorPeer(context, offset = 0) {
+	const peers = context.peers.slice(1);
+	if (!peers.length) {
+		throw new Error('Bootstrap deployment scenarios require a validator peer.');
+	}
+	return peers[Math.min(offset, peers.length - 1)];
+}
+
+export function selectBootstrapDeployerPeer(context, offset = 1) {
+	const peers = context.peers.slice(1);
+	if (peers.length < 2) {
+		throw new Error('Bootstrap deployment scenarios require a deployer peer.');
+	}
+	return peers[Math.min(offset, peers.length - 1)];
+}
+
+export async function setupBootstrapDeploymentScenario(
+	t,
+	{
+		nodes = 3,
+		validatorInitialBalance = DEFAULT_FUNDING,
+		deployerInitialBalance = DEFAULT_FUNDING,
+		externalBootstrap = null,
+		channel = null
+	} = {}
+) {
+	const context = await setupAdminNetwork(t, { nodes: Math.max(nodes, 3) });
+	const validatorPeer = selectBootstrapValidatorPeer(context);
+	const deployerPeer = selectBootstrapDeployerPeer(context);
+
+	context.addWriterScenario = { writerInitialBalance: validatorInitialBalance };
+
+	await initializeBalances(context, [
+		[validatorPeer.wallet.address, validatorInitialBalance],
+		[deployerPeer.wallet.address, deployerInitialBalance]
+	]);
+
+	await whitelistAddress(context, validatorPeer.wallet.address);
+	await whitelistAddress(context, deployerPeer.wallet.address);
+
+	await promotePeerToWriter(t, context, { readerPeer: validatorPeer });
+	await context.sync();
+
+	const txValidity = await deriveIndexerSequenceState(validatorPeer.base);
+	const resolvedExternalBootstrap = externalBootstrap ?? b4a.from(deployerPeer.base.local.key);
+	const resolvedChannel = channel ?? b4a.from(validatorPeer.base.local.key);
+
+	const validatorEntryBefore = await validatorPeer.base.view.get(validatorPeer.wallet.address);
+	const deployerEntryBefore = await validatorPeer.base.view.get(deployerPeer.wallet.address);
+
+	context.bootstrapDeployment = {
+		validatorPeer,
+		deployerPeer,
+		externalBootstrap: resolvedExternalBootstrap,
+		channel: resolvedChannel,
+		txValidity,
+		validatorEntryBefore: validatorEntryBefore
+			? { value: b4a.from(validatorEntryBefore.value) }
+			: null,
+		deployerEntryBefore: deployerEntryBefore ? { value: b4a.from(deployerEntryBefore.value) } : null
+	};
+
+	return context;
+}
+
+export async function buildBootstrapDeploymentPayload(context, options = {}) {
+	const validatorPeer =
+		options.validatorPeer ??
+		context.bootstrapDeployment?.validatorPeer ??
+		selectBootstrapValidatorPeer(context);
+	const deployerPeer =
+		options.deployerPeer ??
+		context.bootstrapDeployment?.deployerPeer ??
+		selectBootstrapDeployerPeer(context);
+
+	const externalBootstrap =
+		options.externalBootstrap ??
+		context.bootstrapDeployment?.externalBootstrap ??
+		b4a.from(deployerPeer.base.local.key);
+	const channel =
+		options.channel ?? context.bootstrapDeployment?.channel ?? b4a.from(validatorPeer.base.local.key);
+	const txValidity =
+		options.txValidity ??
+		context.bootstrapDeployment?.txValidity ??
+		(await deriveIndexerSequenceState(validatorPeer.base));
+
+	const partial = await PartialStateMessageOperations.assembleBootstrapDeploymentMessage(
+		deployerPeer.wallet,
+		externalBootstrap.toString('hex'),
+		channel.toString('hex'),
+		txValidity.toString('hex')
+	);
+
+	return CompleteStateMessageOperations.assembleCompleteBootstrapDeployment(
+		validatorPeer.wallet,
+		partial.address,
+		b4a.from(partial.bdo.tx, 'hex'),
+		b4a.from(partial.bdo.txv, 'hex'),
+		b4a.from(partial.bdo.bs, 'hex'),
+		b4a.from(partial.bdo.ic, 'hex'),
+		b4a.from(partial.bdo.in, 'hex'),
+		b4a.from(partial.bdo.is, 'hex')
+	);
+}
+
+export async function buildBootstrapDeploymentPayloadWithTxValidity(context, txValidity, options = {}) {
+	return buildBootstrapDeploymentPayload(context, {
+		...options,
+		txValidity
+	});
+}
+
+export async function assertBootstrapDeploymentSuccessState(
+	t,
+	context,
+	{
+		payload = null,
+		validatorPeer = context.bootstrapDeployment?.validatorPeer ?? selectBootstrapValidatorPeer(context),
+		deployerPeer = context.bootstrapDeployment?.deployerPeer ?? selectBootstrapDeployerPeer(context),
+		externalBootstrap = context.bootstrapDeployment?.externalBootstrap ?? null,
+		channel = context.bootstrapDeployment?.channel ?? null,
+		validatorEntryBefore = context.bootstrapDeployment?.validatorEntryBefore?.value ?? null,
+		deployerEntryBefore = context.bootstrapDeployment?.deployerEntryBefore?.value ?? null,
+		txValidity = context.bootstrapDeployment?.txValidity ?? null,
+		skipSync = false
+	} = {}
+) {
+	if (!payload) throw new Error('assertBootstrapDeploymentSuccessState requires the processed payload.');
+	if (!validatorEntryBefore) {
+		throw new Error('assertBootstrapDeploymentSuccessState requires the validator entry before execution.');
+	}
+	if (!deployerEntryBefore) {
+		throw new Error('assertBootstrapDeploymentSuccessState requires the deployer entry before execution.');
+	}
+
+	const bootstrapBuffer = externalBootstrap ?? b4a.from(deployerPeer.base.local.key);
+	const channelBuffer = channel ?? b4a.from(validatorPeer.base.local.key);
+	const decodedOperation = safeDecodeApplyOperation(payload);
+	t.ok(decodedOperation, 'bootstrapDeployment payload decodes');
+
+	const requesterAddressBuffer = decodedOperation?.address;
+	const validatorAddressBuffer = decodedOperation?.bdo?.va;
+	const txHashBuffer = decodedOperation?.bdo?.tx;
+	const txValidityBuffer = decodedOperation?.bdo?.txv;
+	const channelFromPayload = decodedOperation?.bdo?.ic;
+	const bootstrapFromPayload = decodedOperation?.bdo?.bs;
+
+	t.ok(requesterAddressBuffer, 'payload carries requester address');
+	t.ok(validatorAddressBuffer, 'payload carries validator address');
+	t.ok(txHashBuffer, 'payload exposes tx hash');
+
+	const requesterAddress = addressUtils.bufferToAddress(requesterAddressBuffer);
+	const validatorAddress = addressUtils.bufferToAddress(validatorAddressBuffer);
+
+	if (requesterAddress) {
+		t.is(requesterAddress, deployerPeer.wallet.address, 'payload signed by expected requester');
+	}
+	if (validatorAddress) {
+		t.is(validatorAddress, validatorPeer.wallet.address, 'payload signed by expected validator');
+	}
+
+	if (bootstrapFromPayload) {
+		t.ok(b4a.equals(bootstrapFromPayload, bootstrapBuffer), 'payload carries external bootstrap');
+	}
+	if (channelFromPayload) {
+		t.ok(b4a.equals(channelFromPayload, channelBuffer), 'payload carries expected channel');
+	}
+	if (txValidity && txValidityBuffer) {
+		t.ok(b4a.equals(txValidityBuffer, txValidity), 'payload tx validity matches current indexer state');
+	}
+
+	const decodedValidatorBefore = nodeEntryUtils.decode(validatorEntryBefore);
+	t.ok(decodedValidatorBefore, 'validator entry before bootstrapDeployment decodes');
+	if (!decodedValidatorBefore) return;
+
+	await assertRequesterPaidFee(t, validatorPeer.base, deployerPeer.wallet.address, deployerEntryBefore);
+	await assertValidatorReward(t, validatorPeer, b4a.from(decodedValidatorBefore.balance));
+	await assertDeploymentEntry(t, validatorPeer.base, {
+		bootstrapBuffer,
+		txHashBuffer,
+		requesterAddressBuffer
+	});
+
+	if (!skipSync) {
+		await context.sync();
+		await assertRequesterPaidFee(t, deployerPeer.base, deployerPeer.wallet.address, deployerEntryBefore);
+		await assertDeploymentEntry(t, deployerPeer.base, {
+			bootstrapBuffer,
+			txHashBuffer,
+			requesterAddressBuffer
+		});
+	}
+}
+
+export async function assertBootstrapDeploymentFailureState(
+	t,
+	context,
+	{ payload, bootstrapBufferOverride = null, skipValidatorEquality = false } = {}
+) {
+	if (!payload) throw new Error('assertBootstrapDeploymentFailureState requires a payload.');
+
+	const decoded = safeDecodeApplyOperation(payload);
+	t.ok(decoded, 'invalid payload decodes for assertions');
+	if (!decoded) return;
+
+	const validatorPeer = context.bootstrapDeployment?.validatorPeer ?? context.peers?.[1];
+	const deployerPeer = context.bootstrapDeployment?.deployerPeer ?? context.peers?.[2];
+	const validatorEntryBefore = context.bootstrapDeployment?.validatorEntryBefore?.value ?? null;
+	const deployerEntryBefore = context.bootstrapDeployment?.deployerEntryBefore?.value ?? null;
+
+	if (validatorPeer) {
+		const after = await validatorPeer.base.view.get(validatorPeer.wallet.address);
+		t.ok(after, 'validator entry still exists after rejection');
+		if (!skipValidatorEquality && validatorEntryBefore && after?.value) {
+			t.ok(b4a.equals(after.value, validatorEntryBefore), 'validator entry remains unchanged');
+		}
+	}
+
+	if (deployerPeer) {
+		const after = await validatorPeer.base.view.get(deployerPeer.wallet.address);
+		t.ok(after, 'deployer entry still exists after rejection');
+		if (deployerEntryBefore && after?.value) {
+			const beforeDecoded = nodeEntryUtils.decode(deployerEntryBefore);
+			const afterDecoded = nodeEntryUtils.decode(after.value);
+			t.ok(beforeDecoded, 'deployer entry before decodes');
+			t.ok(afterDecoded, 'deployer entry after decodes');
+			if (beforeDecoded && afterDecoded) {
+				t.ok(b4a.equals(afterDecoded.balance, beforeDecoded.balance), 'deployer balance unchanged');
+				t.ok(
+					b4a.equals(afterDecoded.stakedBalance, beforeDecoded.stakedBalance),
+					'deployer stake unchanged'
+				);
+			}
+		}
+	}
+
+	const bootstrapBuffer = bootstrapBufferOverride ?? decoded?.bdo?.bs ?? context.bootstrapDeployment?.externalBootstrap;
+	if (bootstrapBuffer && validatorPeer) {
+		const deploymentKey = `${EntryType.DEPLOYMENT}${bootstrapBuffer.toString('hex')}`;
+		const deploymentEntry = await validatorPeer.base.view.get(deploymentKey);
+		t.is(deploymentEntry, null, 'deployment entry not created after rejection');
+	}
+
+	const txHashBuffer = decoded?.bdo?.tx;
+	if (txHashBuffer && validatorPeer) {
+		const txEntry = await validatorPeer.base.view.get(txHashBuffer.toString('hex'));
+		t.is(txEntry, null, 'tx hash not recorded after rejection');
+	}
+}
+
+export function mutateToNetworkBootstrap(t, payload, context) {
+	const decoded = safeDecodeApplyOperation(payload);
+	t.ok(decoded, 'valid payload decodes before mutation');
+	if (!decoded?.bdo) return payload;
+	const bootstrapKey = context.bootstrap?.base?.local?.key;
+	t.ok(bootstrapKey, 'network bootstrap key available');
+	if (!bootstrapKey) return payload;
+	decoded.bdo.bs = bootstrapKey;
+	return safeEncodeApplyOperation(decoded);
+}
+
+export async function appendInvalidPayload(context, invalidPayload) {
+	const node = context.bootstrap ?? context.adminBootstrap ?? context.peers?.[0];
+	await node.base.append(invalidPayload);
+	await node.base.update();
+}
+
+async function assertRequesterPaidFee(t, base, address, entryBeforeValue) {
+	const beforeEntry = nodeEntryUtils.decode(entryBeforeValue);
+	t.ok(beforeEntry, 'deployer entry before bootstrapDeployment decodes');
+	if (!beforeEntry) return;
+
+	const beforeBalance = toBalance(beforeEntry.balance);
+	t.ok(beforeBalance, 'deployer balance before bootstrapDeployment decodes');
+	if (!beforeBalance) return;
+
+	const expectedBalance = beforeBalance.sub(toBalance(transactionUtils.FEE));
+	t.ok(expectedBalance, 'deployer balance after fee computation succeeds');
+	if (!expectedBalance) return;
+
+	const entry = await base.view.get(address);
+	t.ok(entry, 'deployer entry exists after bootstrapDeployment');
+	const decoded = nodeEntryUtils.decode(entry?.value);
+	t.ok(decoded, 'deployer entry decodes after bootstrapDeployment');
+	if (!decoded) return;
+
+	t.is(decoded.isWhitelisted, true, 'deployer remains whitelisted');
+	t.is(decoded.isWriter, false, 'deployer not promoted to writer');
+	t.is(decoded.isIndexer, false, 'deployer not promoted to indexer');
+	t.ok(
+		b4a.equals(decoded.balance, expectedBalance.value),
+		'deployer balance reduced by bootstrapDeployment fee'
+	);
+}
+
+async function assertDeploymentEntry(
+	t,
+	base,
+	{ bootstrapBuffer, txHashBuffer, requesterAddressBuffer }
+) {
+	if (!txHashBuffer) {
+		t.fail('bootstrapDeployment tx hash missing');
+		return;
+	}
+	const deploymentKey = `${EntryType.DEPLOYMENT}${bootstrapBuffer.toString('hex')}`;
+	const deploymentEntry = await base.view.get(deploymentKey);
+	t.ok(deploymentEntry, 'deployment entry stored');
+	const decodedDeployment = deploymentEntryUtils.decode(deploymentEntry?.value);
+	t.ok(decodedDeployment?.txHash, 'deployment entry decodes');
+	if (!decodedDeployment || !decodedDeployment.txHash) return;
+
+	t.ok(b4a.equals(decodedDeployment.txHash, txHashBuffer), 'deployment entry stores tx hash');
+	t.ok(
+		b4a.equals(decodedDeployment.address, requesterAddressBuffer),
+		'deployment entry binds bootstrap to requester address'
+	);
+
+	const txEntry = await base.view.get(txHashBuffer.toString('hex'));
+	t.ok(txEntry, 'bootstrapDeployment transaction recorded for replay protection');
+}

package/tests/unit/state/apply/bootstrapDeployment/invalidValidatorNodeEntryScenario.js

@@ -0,0 +1,57 @@
+import b4a from 'b4a';
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import nodeEntryUtils from '../../../../../src/core/state/utils/nodeEntry.js';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import {
+	setupBootstrapDeploymentScenario,
+	buildBootstrapDeploymentPayload,
+	assertBootstrapDeploymentFailureState
+} from './bootstrapDeploymentScenarioHelpers.js';
+
+export default function bootstrapDeploymentInvalidValidatorNodeEntryScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply bootstrapDeployment rejects payloads when validator node entry becomes invalid',
+		setupScenario: setupBootstrapDeploymentScenario,
+		buildValidPayload: buildBootstrapDeploymentPayload,
+		mutatePayload: (_t, payload) => payload,
+		applyInvalidPayload: applyWithValidatorDecodeFailureOnSecondRead,
+		assertStateUnchanged: (t, context, _valid, invalidPayload) =>
+			assertBootstrapDeploymentFailureState(t, context, {
+				payload: invalidPayload,
+				skipValidatorEquality: true
+			}),
+		expectedLogs: ['Invalid validator node entry.']
+	}).performScenario();
+}
+
+async function applyWithValidatorDecodeFailureOnSecondRead(context, payload) {
+	const node = context.bootstrapDeployment?.validatorPeer ?? context.bootstrap ?? context.adminBootstrap;
+	const validatorPeer = context.bootstrapDeployment?.validatorPeer ?? context.peers?.[1];
+	if (!node?.base || !validatorPeer?.base?.local?.key) {
+		throw new Error('Validator node entry invalidation scenario requires validator peer and writable base.');
+	}
+
+	const validatorWk = validatorPeer.base.local.key;
+	const originalDecode = nodeEntryUtils.decode;
+	let hasReturnedValid = false;
+
+	nodeEntryUtils.decode = function patchedDecode(buffer) {
+		const decoded = originalDecode(buffer);
+		if (decoded && b4a.equals(decoded.wk, validatorWk)) {
+			if (!hasReturnedValid) {
+				hasReturnedValid = true;
+				return decoded;
+			}
+			return null;
+		}
+		return decoded;
+	};
+
+	try {
+		await node.base.append(payload);
+		await node.base.update();
+		await eventFlush();
+	} finally {
+		nodeEntryUtils.decode = originalDecode;
+	}
+}