trac-msb 0.2.4 → 0.2.6

package/tests/unit/state/apply/banValidator/banValidatorTargetNodeEntryMissingScenario.js

@@ -0,0 +1,19 @@
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import {
+	setupBanValidatorScenario,
+	buildBanValidatorPayload,
+	assertBanValidatorFailureState,
+	applyWithTargetNodeEntryRemoval
+} from './banValidatorScenarioHelpers.js';
+
+export default function banValidatorTargetNodeEntryMissingScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply banValidator rejects payloads when target node entry is missing',
+		setupScenario: setupBanValidatorScenario,
+		buildValidPayload: context => buildBanValidatorPayload(context),
+		mutatePayload: (_t, payload) => payload,
+		applyInvalidPayload: applyWithTargetNodeEntryRemoval,
+		assertStateUnchanged: (t, context) => assertBanValidatorFailureState(t, context, { skipSync: true }),
+		expectedLogs: ['Failed to verify target node entry.']
+	}).performScenario();
+}

package/tests/unit/state/apply/banValidator/banValidatorTargetRoleUpdateFailureScenario.js

@@ -0,0 +1,19 @@
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import {
+	setupBanValidatorScenario,
+	buildBanValidatorPayload,
+	assertBanValidatorFailureState,
+	applyWithBanValidatorRoleUpdateFailure
+} from './banValidatorScenarioHelpers.js';
+
+export default function banValidatorTargetRoleUpdateFailureScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply banValidator rejects payloads when target node role update fails',
+		setupScenario: setupBanValidatorScenario,
+		buildValidPayload: context => buildBanValidatorPayload(context),
+		mutatePayload: (_t, payload) => payload,
+		applyInvalidPayload: applyWithBanValidatorRoleUpdateFailure,
+		assertStateUnchanged: (t, context) => assertBanValidatorFailureState(t, context, { skipSync: true }),
+		expectedLogs: ['Failed to update target node role.']
+	}).performScenario();
+}

package/tests/unit/state/apply/banValidator/banValidatorWhitelistedNonWriterScenario.js

@@ -0,0 +1,38 @@
+import { test } from 'brittle';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import { selectWriterPeer } from '../addWriter/addWriterScenarioHelpers.js';
+import {
+	setupBanValidatorScenario,
+	buildBanValidatorPayload,
+	assertBanValidatorSuccessState
+} from './banValidatorScenarioHelpers.js';
+
+export default function banValidatorWhitelistedNonWriterScenario() {
+	test('State.apply banValidator removes privileges for whitelisted non-writer - happy path', async t => {
+		const context = await setupBanValidatorScenario(t, { promoteToWriter: false });
+		const adminPeer = context.adminBootstrap;
+		const validatorPeer = context.banValidatorScenario?.validatorPeer ?? selectWriterPeer(context);
+
+		const validatorEntryBefore = await adminPeer.base.view.get(validatorPeer.wallet.address);
+		t.ok(validatorEntryBefore, 'whitelisted node entry exists before banValidator');
+
+		const adminEntryBefore = await adminPeer.base.view.get(adminPeer.wallet.address);
+		t.ok(adminEntryBefore, 'admin entry exists before banValidator');
+
+		const payload = await buildBanValidatorPayload(context, { adminPeer, validatorPeer });
+
+		await adminPeer.base.append(payload);
+		await adminPeer.base.update();
+		await eventFlush();
+
+		await assertBanValidatorSuccessState(t, context, {
+			validatorPeer,
+			adminPeer,
+			validatorEntryBefore,
+			adminEntryBefore,
+			payload,
+			expectedInitialRoles: { isWhitelisted: true, isWriter: false, isIndexer: false },
+			expectWriterRegistry: false
+		});
+	});
+}

package/tests/unit/state/apply/banValidator/banValidatorWhitelistedZeroBalanceScenario.js

@@ -0,0 +1,91 @@
+import { test } from 'brittle';
+import b4a from 'b4a';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import { selectWriterPeer } from '../addWriter/addWriterScenarioHelpers.js';
+import {
+	setupBanValidatorScenario,
+	buildBanValidatorPayload,
+	assertBanValidatorSuccessState
+} from './banValidatorScenarioHelpers.js';
+import nodeEntryUtils, { ZERO_LICENSE } from '../../../../../src/core/state/utils/nodeEntry.js';
+import { BALANCE_ZERO, toBalance } from '../../../../../src/core/state/utils/balance.js';
+
+export default function banValidatorWhitelistedZeroBalanceScenario() {
+	test('State.apply banValidator handles zero-balance whitelisted non-writer without unstake', async t => {
+		const context = await setupBanValidatorScenario(t, { promoteToWriter: false });
+		const adminPeer = context.adminBootstrap;
+		const targetPeer = context.banValidatorScenario?.validatorPeer ?? selectWriterPeer(context);
+
+		const entryBefore = await adminPeer.base.view.get(targetPeer.wallet.address);
+		t.ok(entryBefore, 'whitelisted node entry exists before banValidator');
+		const decodedBefore = nodeEntryUtils.decode(entryBefore?.value);
+		t.ok(decodedBefore, 'whitelisted node entry decodes before banValidator');
+		if (!decodedBefore) return;
+
+		const balanceBefore = toBalance(decodedBefore.balance);
+		const stakedBefore = toBalance(decodedBefore.stakedBalance);
+		t.ok(balanceBefore, 'balance before banValidator decodes');
+		t.ok(stakedBefore, 'staked balance before banValidator decodes');
+		t.ok(b4a.equals(balanceBefore.value, BALANCE_ZERO.value), 'balance is zero before ban');
+		t.ok(b4a.equals(stakedBefore.value, BALANCE_ZERO.value), 'staked balance is zero before ban');
+		t.ok(!b4a.equals(decodedBefore.license, ZERO_LICENSE), 'license present before ban');
+
+		const adminEntryBefore = await adminPeer.base.view.get(adminPeer.wallet.address);
+		t.ok(adminEntryBefore, 'admin entry exists before banValidator');
+
+		const payload = await buildBanValidatorPayload(context, { adminPeer, validatorPeer: targetPeer });
+
+		await adminPeer.base.append(payload);
+		await adminPeer.base.update();
+		await eventFlush();
+
+		await assertBanValidatorSuccessState(t, context, {
+			validatorPeer: targetPeer,
+			adminPeer,
+			validatorEntryBefore: entryBefore,
+			adminEntryBefore,
+			payload,
+			expectedInitialRoles: { isWhitelisted: true, isWriter: false, isIndexer: false },
+			expectWriterRegistry: false
+		});
+
+		const entryAfter = await adminPeer.base.view.get(targetPeer.wallet.address);
+		t.ok(entryAfter, 'node entry exists after banValidator');
+		const decodedAfter = nodeEntryUtils.decode(entryAfter?.value);
+		t.ok(decodedAfter, 'node entry decodes after banValidator');
+		if (decodedAfter) {
+			t.ok(
+				b4a.equals(decodedAfter.balance, BALANCE_ZERO.value),
+				'balance remains zero after banValidator'
+			);
+			t.ok(
+				b4a.equals(decodedAfter.stakedBalance, BALANCE_ZERO.value),
+				'staked balance remains zero after banValidator'
+			);
+			t.ok(
+				b4a.equals(decodedAfter.license, decodedBefore.license),
+				'license preserved after banValidator'
+			);
+		}
+
+		await context.sync();
+		const replicated = await targetPeer.base.view.get(targetPeer.wallet.address);
+		t.ok(replicated, 'replicated entry exists after banValidator');
+		const decodedReplicated = nodeEntryUtils.decode(replicated?.value);
+		t.ok(decodedReplicated, 'replicated entry decodes after banValidator');
+		if (decodedReplicated) {
+			t.ok(
+				b4a.equals(decodedReplicated.balance, BALANCE_ZERO.value),
+				'replicated balance remains zero'
+			);
+			t.ok(
+				b4a.equals(decodedReplicated.stakedBalance, BALANCE_ZERO.value),
+				'replicated staked balance remains zero'
+			);
+			t.ok(
+				b4a.equals(decodedReplicated.license, decodedBefore.license),
+				'replicated license unchanged'
+			);
+		}
+	});
+}

package/tests/unit/state/apply/banValidator/banValidatorWithdrawFailureScenario.js

@@ -0,0 +1,19 @@
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import {
+	setupBanValidatorScenario,
+	buildBanValidatorPayload,
+	assertBanValidatorFailureState,
+	applyWithBanValidatorWithdrawFailure
+} from './banValidatorScenarioHelpers.js';
+
+export default function banValidatorWithdrawFailureScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply banValidator rejects payloads when staked balance cannot be withdrawn',
+		setupScenario: setupBanValidatorScenario,
+		buildValidPayload: context => buildBanValidatorPayload(context),
+		mutatePayload: (_t, payload) => payload,
+		applyInvalidPayload: applyWithBanValidatorWithdrawFailure,
+		assertStateUnchanged: (t, context) => assertBanValidatorFailureState(t, context, { skipSync: true }),
+		expectedLogs: ['Failed to withdraw staked balance.']
+	}).performScenario();
+}

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

@@ -0,0 +1,266 @@
+import banValidatorHappyPathScenario from './banValidatorHappyPathScenario.js';
+import banValidatorWhitelistedNonWriterScenario from './banValidatorWhitelistedNonWriterScenario.js';
+import banValidatorWhitelistedZeroBalanceScenario from './banValidatorWhitelistedZeroBalanceScenario.js';
+import banValidatorSequentialBansScenario from './banValidatorSequentialBansScenario.js';
+import banValidatorBanAndReWhitelistScenario from './banValidatorBanAndReWhitelistScenario.js';
+import b4a from 'b4a';
+import AdminControlOperationValidationScenario from '../common/adminControlOperationValidationScenario.js';
+import RequesterAddressValidationScenario from '../common/requesterAddressValidationScenario.js';
+import createRequesterPublicKeyValidationScenario from '../common/requesterPublicKeyValidationScenario.js';
+import AdminEntryMissingScenario from '../common/access-control/adminEntryMissingScenario.js';
+import AdminEntryDecodeFailureScenario from '../common/access-control/adminEntryDecodeFailureScenario.js';
+import AdminOnlyGuardScenario from '../common/access-control/adminOnlyGuardScenario.js';
+import AdminPublicKeyDecodeFailureScenario from '../common/access-control/adminPublicKeyDecodeFailureScenario.js';
+import AdminConsistencyMismatchScenario from '../common/access-control/adminConsistencyMismatchScenario.js';
+import InvalidHashValidationScenario from '../common/payload-structure/invalidHashValidationScenario.js';
+import InvalidAddressValidationScenario from '../common/payload-structure/invalidAddressValidationScenario.js';
+import InvalidSignatureValidationScenario, {
+	SignatureMutationStrategy
+} from '../common/payload-structure/invalidSignatureValidationScenario.js';
+import IndexerSequenceStateInvalidScenario from '../common/indexer/indexerSequenceStateInvalidScenario.js';
+import TransactionValidityMismatchScenario from '../common/transactionValidityMismatchScenario.js';
+import OperationAlreadyAppliedScenario from '../common/operationAlreadyAppliedScenario.js';
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import FeeDecodeFailureScenario from '../common/balances/feeDecodeFailureScenario.js';
+import RequesterNodeEntryMissingScenario from '../common/requester/requesterNodeEntryMissingScenario.js';
+import RequesterBalanceScenarioBase from '../common/balances/base/requesterBalanceScenarioBase.js';
+import {
+	setupBanValidatorScenario,
+	buildBanValidatorPayload,
+	buildBanValidatorPayloadWithTxValidity,
+	assertBanValidatorFailureState,
+	applyInvalidTargetAddressPayload
+} from './banValidatorScenarioHelpers.js';
+import banValidatorTargetNodeEntryMissingScenario from './banValidatorTargetNodeEntryMissingScenario.js';
+import banValidatorTargetIndexerScenario from './banValidatorTargetIndexerScenario.js';
+import banValidatorTargetRoleUpdateFailureScenario from './banValidatorTargetRoleUpdateFailureScenario.js';
+import banValidatorTargetDecodeFailureScenario from './banValidatorTargetDecodeFailureScenario.js';
+import banValidatorWithdrawFailureScenario from './banValidatorWithdrawFailureScenario.js';
+import { applyWithRequesterEntryCorruption } from '../addWriter/addWriterScenarioHelpers.js';
+
+banValidatorHappyPathScenario();
+banValidatorWhitelistedNonWriterScenario();
+banValidatorWhitelistedZeroBalanceScenario();
+banValidatorSequentialBansScenario();
+banValidatorBanAndReWhitelistScenario();
+
+// Handler validation order
+new AdminControlOperationValidationScenario({
+	title: 'State.apply banValidator rejects payloads when contract schema validation fails',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: assertBanValidatorFailureState,
+	expectedLogs: ['Contract schema validation failed.']
+}).performScenario();
+
+new RequesterAddressValidationScenario({
+	title: 'State.apply banValidator rejects payloads when requester address is invalid',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: assertBanValidatorFailureState,
+	expectedLogs: ['Requester address is invalid.']
+}).performScenario();
+
+createRequesterPublicKeyValidationScenario({
+	title: 'State.apply banValidator rejects payloads when requester public key is invalid',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: assertBanValidatorFailureState,
+	expectedLogs: ['Error while decoding requester public key.']
+}).performScenario();
+
+new AdminEntryMissingScenario({
+	title: 'State.apply banValidator rejects payloads when admin entry is missing',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: (t, context) => assertBanValidatorFailureState(t, context, { skipSync: true }),
+	expectedLogs: ['Invalid admin entry.']
+}).performScenario();
+
+new AdminEntryDecodeFailureScenario({
+	title: 'State.apply banValidator rejects payloads when admin entry cannot be decoded',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: (t, context) => assertBanValidatorFailureState(t, context, { skipSync: true }),
+	expectedLogs: ['Failed to decode admin node entry.']
+}).performScenario();
+
+new AdminPublicKeyDecodeFailureScenario({
+	title: 'State.apply banValidator rejects payloads when admin public key cannot be decoded',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: (t, context) => assertBanValidatorFailureState(t, context, { skipSync: true }),
+	expectedLogs: ['Failed to decode admin public key.']
+}).performScenario();
+
+new AdminOnlyGuardScenario({
+	title: 'State.apply banValidator rejects non-admin nodes',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: (t, context) =>
+		assertBanValidatorFailureState(t, context, {
+			expectedRoles: { isWhitelisted: true, isWriter: false, isIndexer: false },
+			allowEntryMutation: true,
+			skipSync: true
+		}),
+	expectedLogs: ['Node is not allowed to perform this operation. (ADMIN ONLY)']
+}).performScenario();
+
+new AdminConsistencyMismatchScenario({
+	title: 'State.apply banValidator rejects payloads when admin public key mismatches requester',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: (t, context) => assertBanValidatorFailureState(t, context, { skipSync: true }),
+	expectedLogs: ['System admin and node public keys do not match.']
+}).performScenario();
+
+new InvalidHashValidationScenario({
+	title: 'State.apply banValidator rejects payloads when message hash mismatches tx hash',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: assertBanValidatorFailureState,
+	expectedLogs: ['Message hash does not match the tx_hash.']
+}).performScenario();
+
+new InvalidSignatureValidationScenario({
+	title: 'State.apply banValidator rejects payloads when admin signature is invalid (foreign signature)',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: assertBanValidatorFailureState,
+	expectedLogs: ['Failed to verify message signature.']
+}).performScenario();
+
+new InvalidSignatureValidationScenario({
+	title: 'State.apply banValidator rejects payloads when admin signature is invalid (zero fill)',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: assertBanValidatorFailureState,
+	strategy: SignatureMutationStrategy.ZERO_FILL,
+	expectedLogs: ['Failed to verify message signature.']
+}).performScenario();
+
+new InvalidSignatureValidationScenario({
+	title: 'State.apply banValidator rejects payloads when admin signature is invalid (type mismatch)',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: assertBanValidatorFailureState,
+	strategy: SignatureMutationStrategy.TYPE_MISMATCH,
+	expectedLogs: ['Failed to verify message signature.']
+}).performScenario();
+
+new IndexerSequenceStateInvalidScenario({
+	title: 'State.apply banValidator rejects payloads when indexer sequence state is invalid',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: (t, context) => assertBanValidatorFailureState(t, context, { skipSync: true }),
+	expectedLogs: ['Indexer sequence state is invalid.']
+}).performScenario();
+
+new TransactionValidityMismatchScenario({
+	title: 'State.apply banValidator rejects payloads when transaction validity mismatches indexer state',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: assertBanValidatorFailureState,
+	txValidityPath: ['aco', 'txv'],
+	rebuildPayloadWithTxValidity: ({ context, mutatedTxValidity }) =>
+		buildBanValidatorPayloadWithTxValidity(context, mutatedTxValidity),
+	expectedLogs: ['Transaction was not executed.']
+}).performScenario();
+
+new OperationAlreadyAppliedScenario({
+	title: 'State.apply banValidator rejects payloads when operation was already applied',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: (t, context) =>
+		assertBanValidatorFailureState(t, context, {
+			expectedRoles: { isWhitelisted: false, isWriter: false, isIndexer: false },
+			allowEntryMutation: true,
+			skipSync: true
+		}),
+	expectedLogs: ['Operation has already been applied.']
+}).performScenario();
+
+new InvalidAddressValidationScenario({
+	title: 'State.apply banValidator rejects payloads when target node address is invalid',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: assertBanValidatorFailureState,
+	addressPath: ['aco', 'ia'],
+	expectedLogs: ['Failed to verify target node address.'],
+	applyInvalidPayload: applyInvalidTargetAddressPayload
+}).performScenario();
+
+banValidatorTargetNodeEntryMissingScenario();
+banValidatorTargetIndexerScenario();
+banValidatorTargetRoleUpdateFailureScenario();
+banValidatorTargetDecodeFailureScenario();
+
+new FeeDecodeFailureScenario({
+	title: 'State.apply banValidator rejects payloads when fee amount is invalid',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: (t, context) => assertBanValidatorFailureState(t, context, { skipSync: true }),
+	expectedLogs: ['Invalid fee amount.']
+}).performScenario();
+
+new RequesterNodeEntryMissingScenario({
+	title: 'State.apply banValidator rejects payloads when admin node entry is missing',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: (t, context) => assertBanValidatorFailureState(t, context, { skipSync: true }),
+	selectPeer: context => context.adminBootstrap,
+	expectedLogs: ['Invalid admin node entry buffer.']
+}).performScenario();
+
+new OperationValidationScenarioBase({
+	title: 'State.apply banValidator rejects payloads when admin node entry cannot be decoded',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	mutatePayload: (_t, payload) => payload,
+	applyInvalidPayload: (context, invalidPayload) =>
+		applyWithRequesterEntryCorruption(context, invalidPayload, { peer: context.adminBootstrap }),
+	assertStateUnchanged: (t, context) => assertBanValidatorFailureState(t, context, { skipSync: true }),
+	expectedLogs: ['Failed to verify admin node entry.']
+}).performScenario();
+
+new RequesterBalanceScenarioBase({
+	title: 'State.apply banValidator rejects payloads when admin balance cannot be decoded',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: (t, context) => assertBanValidatorFailureState(t, context, { skipSync: true }),
+	mutateDecodedEntry: decoded => ({ ...decoded, balance: decoded.balance ? decoded.balance.subarray(0, 1) : null }),
+	selectPeer: context => context.adminBootstrap,
+	expectedLogs: ['Invalid admin balance']
+}).performScenario();
+
+new RequesterBalanceScenarioBase({
+	title: 'State.apply banValidator rejects payloads when admin balance is insufficient',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: (t, context) => assertBanValidatorFailureState(t, context, { skipSync: true }),
+	mutateDecodedEntry: decoded => ({ ...decoded, balance: b4a.alloc(decoded.balance.length) }),
+	selectPeer: context => context.adminBootstrap,
+	expectedLogs: ['Insufficient admin balance.']
+}).performScenario();
+
+new RequesterBalanceScenarioBase({
+	title: 'State.apply banValidator rejects payloads when admin fee cannot be applied',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: (t, context) => assertBanValidatorFailureState(t, context, { skipSync: true }),
+	selectPeer: context => context.adminBootstrap,
+	failNextBalanceSub: true,
+	expectedLogs: ['Failed to apply fee to admin balance.']
+}).performScenario();
+
+new RequesterBalanceScenarioBase({
+	title: 'State.apply banValidator rejects payloads when admin balance update fails',
+	setupScenario: setupBanValidatorScenario,
+	buildValidPayload: context => buildBanValidatorPayload(context),
+	assertStateUnchanged: (t, context) => assertBanValidatorFailureState(t, context, { skipSync: true }),
+	selectPeer: context => context.adminBootstrap,
+	failNextBalanceUpdate: true,
+	expectedLogs: ['Failed to update admin node balance.']
+}).performScenario();
+
+banValidatorWithdrawFailureScenario();

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

@@ -0,0 +1,142 @@
+import b4a from 'b4a';
+import { test } from 'brittle';
+import {
+	setupBootstrapDeploymentScenario,
+	buildBootstrapDeploymentPayload,
+	assertBootstrapDeploymentSuccessState
+} from './bootstrapDeploymentScenarioHelpers.js';
+import { initializeBalances, whitelistAddress } from '../common/commonScenarioHelper.js';
+import nodeEntryUtils from '../../../../../src/core/state/utils/nodeEntry.js';
+import deploymentEntryUtils from '../../../../../src/core/state/utils/deploymentEntry.js';
+import { safeDecodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
+
+async function setupDuplicateBootstrapScenario(t) {
+	const context = await setupBootstrapDeploymentScenario(t, { nodes: 4 });
+	const validatorPeer = context.bootstrapDeployment?.validatorPeer ?? context.peers?.[1];
+	const primaryDeployer = context.bootstrapDeployment?.deployerPeer ?? context.peers?.[2];
+	const secondaryDeployer = context.peers?.[3];
+
+	if (!validatorPeer || !primaryDeployer || !secondaryDeployer) {
+		throw new Error('Duplicate bootstrap scenario requires a validator and two deployers.');
+	}
+
+	const primaryEntry = await validatorPeer.base.view.get(primaryDeployer.wallet.address);
+	const primaryDecoded = primaryEntry ? nodeEntryUtils.decode(primaryEntry.value) : null;
+	const initialBalance = primaryDecoded?.balance ?? null;
+
+	if (initialBalance) {
+		await initializeBalances(context, [[secondaryDeployer.wallet.address, initialBalance]]);
+	}
+	await whitelistAddress(context, secondaryDeployer.wallet.address);
+	await context.sync();
+
+	const secondaryEntryBefore = await validatorPeer.base.view.get(secondaryDeployer.wallet.address);
+
+	context.bootstrapDeployment.secondaryDeployer = secondaryDeployer;
+	context.bootstrapDeployment.secondaryDeployerEntryBefore = secondaryEntryBefore
+		? { value: b4a.from(secondaryEntryBefore.value) }
+		: null;
+
+	return context;
+}
+
+function buildDuplicatePayload(validPayload, context) {
+	const decoded = safeDecodeApplyOperation(validPayload);
+	if (!decoded?.bdo) return validPayload;
+
+	const secondaryDeployer = context.bootstrapDeployment?.secondaryDeployer ?? context.peers?.[3];
+	if (!secondaryDeployer) return validPayload;
+
+	return buildBootstrapDeploymentPayload(context, {
+		deployerPeer: secondaryDeployer,
+		externalBootstrap: decoded.bdo.bs,
+		channel: decoded.bdo.ic,
+		txValidity: decoded.bdo.txv
+	});
+}
+
+async function assertDuplicateBootstrapState(t, context, validPayload, invalidPayload) {
+	const validatorPeer = context.bootstrapDeployment?.validatorPeer ?? context.peers?.[1];
+	const secondaryDeployer = context.bootstrapDeployment?.secondaryDeployer ?? context.peers?.[3];
+	const secondaryBefore = context.bootstrapDeployment?.secondaryDeployerEntryBefore?.value ?? null;
+
+	const validDecoded = safeDecodeApplyOperation(validPayload);
+	const invalidDecoded = safeDecodeApplyOperation(invalidPayload);
+	t.ok(validDecoded, 'valid payload decodes for assertions');
+	t.ok(invalidDecoded, 'invalid payload decodes for assertions');
+	if (!validDecoded?.bdo || !invalidDecoded?.bdo) return;
+
+	const bootstrapHex = validDecoded.bdo.bs.toString('hex');
+	const firstTxHex = validDecoded.bdo.tx.toString('hex');
+	const secondTxHex = invalidDecoded.bdo.tx.toString('hex');
+
+	const deploymentKey = `deployment/${bootstrapHex}`;
+	const deploymentEntry = await validatorPeer.base.view.get(deploymentKey);
+	t.ok(deploymentEntry, 'deployment entry still stored');
+	const decodedDeployment = deploymentEntry ? deploymentEntryUtils.decode(deploymentEntry.value) : null;
+	t.ok(decodedDeployment, 'deployment entry decodes');
+	if (decodedDeployment?.txHash) {
+		t.is(decodedDeployment.txHash.toString('hex'), firstTxHex, 'deployment entry keeps original tx hash');
+	} else if (decodedDeployment) {
+		t.fail('deployment entry missing tx hash');
+	}
+
+	const firstTxEntry = await validatorPeer.base.view.get(firstTxHex);
+	t.ok(firstTxEntry, 'original tx hash remains recorded');
+
+	const duplicateTxEntry = await validatorPeer.base.view.get(secondTxHex);
+	t.is(duplicateTxEntry, null, 'duplicate tx hash not recorded');
+
+	if (secondaryDeployer) {
+		const after = await validatorPeer.base.view.get(secondaryDeployer.wallet.address);
+		t.ok(after, 'second deployer entry exists after rejection');
+		if (secondaryBefore && after?.value) {
+			const beforeDecoded = nodeEntryUtils.decode(secondaryBefore);
+			const afterDecoded = nodeEntryUtils.decode(after.value);
+			t.ok(beforeDecoded, 'second deployer entry before decodes');
+			t.ok(afterDecoded, 'second deployer entry after decodes');
+			if (beforeDecoded && afterDecoded) {
+				t.ok(b4a.equals(afterDecoded.balance, beforeDecoded.balance), 'second deployer balance unchanged');
+				t.ok(
+					b4a.equals(afterDecoded.stakedBalance, beforeDecoded.stakedBalance),
+					'second deployer stake unchanged'
+				);
+			}
+		}
+	}
+}
+
+export default function bootstrapDeploymentDuplicateRegistrationScenario() {
+	test('State.apply bootstrapDeployment ignores duplicate bootstrap registrations', async t => {
+		const context = await setupDuplicateBootstrapScenario(t);
+		const validatorPeer = context.bootstrapDeployment?.validatorPeer ?? context.peers?.[1];
+
+		const validPayload = await buildBootstrapDeploymentPayload(context);
+		const invalidPayload = await buildDuplicatePayload(validPayload, context);
+
+		const capturedLogs = [];
+		const originalConsoleError = console.error;
+		console.error = (...args) => {
+			capturedLogs.push(args);
+			originalConsoleError(...args);
+		};
+
+		try {
+			await validatorPeer.base.append(validPayload);
+			await validatorPeer.base.update();
+			await assertBootstrapDeploymentSuccessState(t, context, { payload: validPayload, skipSync: true });
+
+			await validatorPeer.base.append(invalidPayload);
+			await validatorPeer.base.update();
+
+			await assertDuplicateBootstrapState(t, context, validPayload, invalidPayload);
+
+			const foundLog = capturedLogs.some(args =>
+				args.some(arg => String(arg).includes('Bootstrap already registered.'))
+			);
+			t.ok(foundLog, 'expected apply log "Bootstrap already registered." was emitted');
+		} finally {
+			console.error = originalConsoleError;
+		}
+	});
+}

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

@@ -0,0 +1,26 @@
+import { test } from 'brittle';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import {
+	setupBootstrapDeploymentScenario,
+	buildBootstrapDeploymentPayload,
+	assertBootstrapDeploymentSuccessState
+} from './bootstrapDeploymentScenarioHelpers.js';
+
+export default function bootstrapDeploymentHappyPathScenario() {
+	test(
+		'State.apply bootstrapDeployment registers external bootstrap and rewards validator - happy path',
+		async t => {
+			const context = await setupBootstrapDeploymentScenario(t);
+			const validatorPeer =
+				context.bootstrapDeployment?.validatorPeer ?? context.adminBootstrap ?? context.peers[0];
+
+			const payload = await buildBootstrapDeploymentPayload(context);
+
+			await validatorPeer.base.append(payload);
+			await validatorPeer.base.update();
+			await eventFlush();
+
+			await assertBootstrapDeploymentSuccessState(t, context, { payload });
+		}
+	);
+}