trac-msb 0.2.4 → 0.2.6

package/tests/unit/state/apply/addWriter/addWriterStakeBalanceUpdateFailureScenario.js

@@ -0,0 +1,50 @@
+import { BALANCE_ZERO } from '../../../../../src/core/state/utils/balance.js';
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import {
+	setupAddWriterScenario,
+	buildAddWriterPayload,
+	assertAddWriterFailureState,
+	applyWithStakeEntryMutation
+} from './addWriterScenarioHelpers.js';
+
+const STAKE_BALANCE_MARK = Symbol('stake-balance-update-target');
+
+export default function addWriterStakeBalanceUpdateFailureScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply addWriter rejects payloads when stake balance update fails',
+		setupScenario: setupAddWriterScenario,
+		buildValidPayload: buildAddWriterPayload,
+		mutatePayload: (_t, payload) => payload,
+		applyInvalidPayload: async (context, invalidPayload) => {
+			const balancePrototype = Object.getPrototypeOf(BALANCE_ZERO);
+			const originalUpdate = balancePrototype.update;
+			let shouldFail = true;
+
+			balancePrototype.update = function patchedUpdate(nodeEntryBuffer) {
+				if (shouldFail && nodeEntryBuffer?.[STAKE_BALANCE_MARK]) {
+					shouldFail = false;
+					delete nodeEntryBuffer[STAKE_BALANCE_MARK];
+					return null;
+				}
+				return originalUpdate.call(this, nodeEntryBuffer);
+			};
+
+			try {
+				await applyWithStakeEntryMutation(
+					context,
+					invalidPayload,
+					nodeEntryBuffer => {
+						if (nodeEntryBuffer && typeof nodeEntryBuffer === 'object') {
+							nodeEntryBuffer[STAKE_BALANCE_MARK] = true;
+						}
+						return nodeEntryBuffer;
+					}
+				);
+			} finally {
+				balancePrototype.update = originalUpdate;
+			}
+		},
+		assertStateUnchanged: (t, context) => assertAddWriterFailureState(t, context, { skipSync: true }),
+		expectedLogs: ['Failed to update node entry with new balance']
+	}).performScenario();
+}

package/tests/unit/state/apply/addWriter/addWriterStakeInsufficientBalanceScenario.js

@@ -0,0 +1,29 @@
+import { BALANCE_ZERO } from '../../../../../src/core/state/utils/balance.js';
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import {
+	setupAddWriterScenario,
+	buildAddWriterPayload,
+	assertAddWriterFailureState,
+	applyWithStakeEntryMutation
+} from './addWriterScenarioHelpers.js';
+
+export default function addWriterStakeInsufficientBalanceScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply addWriter rejects payloads when stake balance is insufficient',
+		setupScenario: setupAddWriterScenario,
+		buildValidPayload: buildAddWriterPayload,
+		mutatePayload: (_t, payload) => payload,
+		applyInvalidPayload: (context, invalidPayload) =>
+			applyWithStakeEntryMutation(
+				context,
+				invalidPayload,
+				nodeEntryBuffer => nodeEntryBuffer,
+				decodedEntry => {
+					if (!decodedEntry) return decodedEntry;
+					return { ...decodedEntry, balance: BALANCE_ZERO.value };
+				}
+			),
+		assertStateUnchanged: (t, context) => assertAddWriterFailureState(t, context, { skipSync: true }),
+		expectedLogs: ['Insufficient balance to stake']
+	}).performScenario();
+}

package/tests/unit/state/apply/addWriter/addWriterStakeInvalidBalanceScenario.js

@@ -0,0 +1,29 @@
+import b4a from 'b4a';
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import {
+	setupAddWriterScenario,
+	buildAddWriterPayload,
+	assertAddWriterFailureState,
+	applyWithStakeEntryMutation
+} from './addWriterScenarioHelpers.js';
+
+export default function addWriterStakeInvalidBalanceScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply addWriter rejects payloads when stake balance is invalid',
+		setupScenario: setupAddWriterScenario,
+		buildValidPayload: buildAddWriterPayload,
+		mutatePayload: (_t, payload) => payload,
+		applyInvalidPayload: (context, invalidPayload) =>
+			applyWithStakeEntryMutation(
+				context,
+				invalidPayload,
+				nodeEntryBuffer => nodeEntryBuffer,
+				decodedEntry => {
+					if (!decodedEntry) return decodedEntry;
+					return { ...decodedEntry, balance: b4a.alloc(1) };
+				}
+			),
+		assertStateUnchanged: (t, context) => assertAddWriterFailureState(t, context, { skipSync: true }),
+		expectedLogs: ['Invalid node balance']
+	}).performScenario();
+}

package/tests/unit/state/apply/addWriter/addWriterStakeInvalidEntryScenario.js

@@ -0,0 +1,21 @@
+import b4a from 'b4a';
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import {
+	setupAddWriterScenario,
+	buildAddWriterPayload,
+	assertAddWriterFailureState,
+	applyWithStakeEntryMutation
+} from './addWriterScenarioHelpers.js';
+
+export default function addWriterStakeInvalidEntryScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply addWriter rejects payloads when stake entry buffer is invalid',
+		setupScenario: setupAddWriterScenario,
+		buildValidPayload: buildAddWriterPayload,
+		mutatePayload: (_t, payload) => payload,
+		applyInvalidPayload: (context, invalidPayload) =>
+			applyWithStakeEntryMutation(context, invalidPayload, () => b4a.alloc(1)),
+		assertStateUnchanged: (t, context) => assertAddWriterFailureState(t, context, { skipSync: true }),
+		expectedLogs: ['Invalid node entry buffer']
+	}).performScenario();
+}

package/tests/unit/state/apply/addWriter/addWriterStakeStakedBalanceFailureScenario.js

@@ -0,0 +1,37 @@
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import nodeEntryUtils from '../../../../../src/core/state/utils/nodeEntry.js';
+import {
+	setupAddWriterScenario,
+	buildAddWriterPayload,
+	assertAddWriterFailureState,
+	applyWithStakeEntryMutation
+} from './addWriterScenarioHelpers.js';
+
+export default function addWriterStakeStakedBalanceFailureScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply addWriter rejects payloads when setting staked balance fails',
+		setupScenario: setupAddWriterScenario,
+		buildValidPayload: buildAddWriterPayload,
+		mutatePayload: (_t, payload) => payload,
+		applyInvalidPayload: async (context, invalidPayload) => {
+			const originalSetStakedBalance = nodeEntryUtils.setStakedBalance;
+			let shouldFail = true;
+
+			nodeEntryUtils.setStakedBalance = function patchedSetStakedBalance(nodeEntryBuffer, stakedBalance) {
+				if (shouldFail) {
+					shouldFail = false;
+					return null;
+				}
+				return originalSetStakedBalance(nodeEntryBuffer, stakedBalance);
+			};
+
+			try {
+				await applyWithStakeEntryMutation(context, invalidPayload, nodeEntryBuffer => nodeEntryBuffer);
+			} finally {
+				nodeEntryUtils.setStakedBalance = originalSetStakedBalance;
+			}
+		},
+		assertStateUnchanged: (t, context) => assertAddWriterFailureState(t, context, { skipSync: true }),
+		expectedLogs: ['Failed to set staked balance in node entry']
+	}).performScenario();
+}

package/tests/unit/state/apply/addWriter/addWriterStakeSubtractFailureScenario.js

@@ -0,0 +1,42 @@
+import { BALANCE_ZERO, BALANCE_TO_STAKE } from '../../../../../src/core/state/utils/balance.js';
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import {
+	setupAddWriterScenario,
+	buildAddWriterPayload,
+	assertAddWriterFailureState,
+	applyWithStakeEntryMutation
+} from './addWriterScenarioHelpers.js';
+
+export default function addWriterStakeSubtractFailureScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply addWriter rejects payloads when stake balance subtraction fails',
+		setupScenario: setupAddWriterScenario,
+		buildValidPayload: buildAddWriterPayload,
+		mutatePayload: (_t, payload) => payload,
+		applyInvalidPayload: async (context, invalidPayload) => {
+			const balancePrototype = Object.getPrototypeOf(BALANCE_ZERO);
+			const originalSub = balancePrototype.sub;
+			let shouldFailSubtraction = true;
+
+			balancePrototype.sub = function patchedSub(balance) {
+				if (shouldFailSubtraction && balance === BALANCE_TO_STAKE) {
+					shouldFailSubtraction = false;
+					return null;
+				}
+				return originalSub.call(this, balance);
+			};
+
+			try {
+				await applyWithStakeEntryMutation(
+					context,
+					invalidPayload,
+					nodeEntryBuffer => nodeEntryBuffer
+				);
+			} finally {
+				balancePrototype.sub = originalSub;
+			}
+		},
+		assertStateUnchanged: (t, context) => assertAddWriterFailureState(t, context, { skipSync: true }),
+		expectedLogs: ['Failed to subtract stake balance']
+	}).performScenario();
+}

package/tests/unit/state/apply/addWriter/addWriterValidatorRewardScenario.js

@@ -0,0 +1,105 @@
+import { test } from 'brittle';
+import b4a from 'b4a';
+import nodeEntryUtils from '../../../../../src/core/state/utils/nodeEntry.js';
+import {
+	setupAddWriterScenario,
+	selectWriterPeer,
+	buildAddWriterPayload,
+	assertAddWriterSuccessState,
+	defaultWriterFunding
+} from './addWriterScenarioHelpers.js';
+import { initializeBalances, whitelistAddress } from '../common/commonScenarioHelper.js';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import { safeDecodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
+import addressUtils from '../../../../../src/core/state/utils/address.js';
+
+export default function addWriterValidatorRewardScenario() {
+	test(
+		'State.apply addWriter rewards validator writers that process peer promotions',
+		async t => {
+			const context = await setupAddWriterScenario(t, { nodes: 3 });
+			const adminPeer = context.adminBootstrap;
+			const firstWriterPeer = selectWriterPeer(context, 0);
+			const secondReaderPeer = selectWriterPeer(context, 1);
+			if (!secondReaderPeer) {
+				t.fail('Validator reward scenario requires a second reader peer.');
+				return;
+			}
+
+			await fundAndWhitelistPeer(context, secondReaderPeer);
+
+			const adminBalanceBefore = await readNodeBalanceBuffer(adminPeer);
+			const firstAddPayload = await buildAddWriterPayload(context, {
+				readerPeer: firstWriterPeer,
+				validatorPeer: adminPeer
+			});
+
+			await appendPayload(adminPeer.base, firstAddPayload);
+
+			await assertAddWriterSuccessState(t, context, {
+				readerPeer: firstWriterPeer,
+				validatorPeer: adminPeer,
+				writerInitialBalance: context.addWriterScenario?.writerInitialBalance,
+				validatorBalanceBefore: adminBalanceBefore,
+				payload: firstAddPayload,
+				expectedWriterIndex: 1
+			});
+
+			const writerBalanceBeforeReward = await readNodeBalanceBuffer(firstWriterPeer);
+			const secondAddPayload = await buildAddWriterPayload(context, {
+				readerPeer: secondReaderPeer,
+				validatorPeer: firstWriterPeer
+			});
+
+			assertPayloadValidator(t, secondAddPayload, firstWriterPeer.wallet.address);
+
+			await appendPayload(firstWriterPeer.base, secondAddPayload);
+
+			await assertAddWriterSuccessState(t, context, {
+				readerPeer: secondReaderPeer,
+				validatorPeer: firstWriterPeer,
+				writerInitialBalance:
+					context.addWriterScenario?.writerInitialBalance ?? defaultWriterFunding,
+				validatorBalanceBefore: writerBalanceBeforeReward,
+				payload: secondAddPayload,
+				expectedWriterIndex: 2
+			});
+		}
+	);
+}
+
+async function fundAndWhitelistPeer(context, peer) {
+	const funding = context.addWriterScenario?.writerInitialBalance ?? defaultWriterFunding;
+	await initializeBalances(context, [[peer.wallet.address, funding]]);
+	await whitelistAddress(context, peer.wallet.address);
+}
+
+async function appendPayload(nodeBase, payload) {
+	await nodeBase.append(payload);
+	await nodeBase.update();
+	await eventFlush();
+}
+
+async function readNodeBalanceBuffer(peer) {
+	const entry = await peer.base.view.get(peer.wallet.address);
+	if (!entry?.value) {
+		throw new Error('Unable to read node balance for validator reward scenario.');
+	}
+	const decoded = nodeEntryUtils.decode(entry.value);
+	if (!decoded?.balance) {
+		throw new Error('Validator entry decode failed while tracking rewards.');
+	}
+	return b4a.from(decoded.balance);
+}
+
+function assertPayloadValidator(t, payload, validatorAddress) {
+	const decoded = safeDecodeApplyOperation(payload);
+	t.ok(decoded, 'validator reward payload decodes');
+	const validatorBuffer = decoded?.rao?.va;
+	t.ok(validatorBuffer, 'payload carries validator address');
+	const expected = addressUtils.addressToBuffer(validatorAddress);
+	t.ok(
+		b4a.equals(validatorBuffer, expected),
+		'payload validator address matches processing writer'
+	);
+}

package/tests/unit/state/apply/addWriter/addWriterWriterKeyMismatchScenario.js

@@ -0,0 +1,54 @@
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import {
+	setupAddWriterScenario,
+	buildAddWriterPayload,
+	buildRemoveWriterPayload,
+	assertAddWriterFailureState,
+	selectWriterPeer,
+	applyWithRequesterWriterKeyMismatch
+} from './addWriterScenarioHelpers.js';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+
+async function setupScenarioWithRegisteredKey(t) {
+	const context = await setupAddWriterScenario(t);
+	const writerPeer = selectWriterPeer(context);
+	await promotePeerToWriter(context, writerPeer);
+	context.registeredWriterKey = writerPeer.base.local.key;
+	await demoteWriterPeer(context, writerPeer);
+	return context;
+}
+
+async function promotePeerToWriter(context, peer) {
+	const payload = await buildAddWriterPayload(context, { readerPeer: peer });
+	await appendPayload(context, payload);
+}
+
+async function demoteWriterPeer(context, peer) {
+	const payload = await buildRemoveWriterPayload(context, { readerPeer: peer });
+	await appendPayload(context, payload);
+}
+
+async function appendPayload(context, payload) {
+	const node = context.adminBootstrap ?? context.bootstrap;
+	if (!node?.base) {
+		throw new Error('Writer key mismatch scenario requires an admin node with a writable base.');
+	}
+	await node.base.append(payload);
+	await node.base.update();
+	await eventFlush();
+	await context.sync();
+}
+
+export default function addWriterWriterKeyMismatchScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply addWriter rejects payloads when node entry writing key mismatches registered key',
+		setupScenario: setupScenarioWithRegisteredKey,
+		buildValidPayload: context =>
+			buildAddWriterPayload(context, { writerKeyBuffer: context.registeredWriterKey }),
+		mutatePayload: (_t, payload) => payload,
+		applyInvalidPayload: applyWithRequesterWriterKeyMismatch,
+		assertStateUnchanged: (t, context) =>
+			assertAddWriterFailureState(t, context, { skipSync: true, expectRegistryEntry: true }),
+		expectedLogs: ['Invalid writer key: either not owned by requester or different from assigned key.']
+	}).performScenario();
+}

package/tests/unit/state/apply/addWriter/addWriterWriterKeyOwnershipScenario.js

@@ -0,0 +1,54 @@
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import {
+	setupAddWriterScenario,
+	buildAddWriterPayload,
+	assertAddWriterFailureState,
+	selectWriterPeer,
+	defaultWriterFunding
+} from './addWriterScenarioHelpers.js';
+import { initializeBalances, whitelistAddress } from '../common/commonScenarioHelper.js';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+
+async function setupScenarioWithForeignKey(t) {
+	const context = await setupAddWriterScenario(t, { nodes: 3 });
+	const foreignPeer = selectWriterPeer(context, 1);
+	await fundAndWhitelistPeer(context, foreignPeer);
+	await promotePeerToWriter(context, foreignPeer);
+	context.foreignWriterKey = foreignPeer.base.local.key;
+	return context;
+}
+
+async function fundAndWhitelistPeer(context, peer) {
+	const funding = context.addWriterScenario?.writerInitialBalance ?? defaultWriterFunding;
+	await initializeBalances(context, [[peer.wallet.address, funding]]);
+	await whitelistAddress(context, peer.wallet.address);
+}
+
+async function promotePeerToWriter(context, peer) {
+	const payload = await buildAddWriterPayload(context, { readerPeer: peer });
+	await appendPayload(context, payload);
+}
+
+async function appendPayload(context, payload) {
+	const node = context.adminBootstrap ?? context.bootstrap;
+	if (!node?.base) {
+		throw new Error('Writer key ownership scenario requires an admin node with a writable base.');
+	}
+	await node.base.append(payload);
+	await node.base.update();
+	await eventFlush();
+	await context.sync();
+}
+
+export default function addWriterWriterKeyOwnershipScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply addWriter rejects payloads when writer key belongs to another node',
+		setupScenario: setupScenarioWithForeignKey,
+		buildValidPayload: context =>
+			buildAddWriterPayload(context, { writerKeyBuffer: context.foreignWriterKey }),
+		mutatePayload: (_t, payload) => payload,
+		applyInvalidPayload: appendPayload,
+		assertStateUnchanged: assertAddWriterFailureState,
+		expectedLogs: ['Invalid writer key: either not owned by requester or different from assigned key.']
+	}).performScenario();
+}

package/tests/unit/state/apply/addWriter/addWriterZeroWriterKeyScenario.js

@@ -0,0 +1,29 @@
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import { safeDecodeApplyOperation, safeEncodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
+import { ZERO_WK } from '../../../../../src/utils/buffer.js';
+import {
+	setupAddWriterScenario,
+	buildAddWriterPayload,
+	assertAddWriterFailureState,
+	applyWithRoleAccessBypass
+} from './addWriterScenarioHelpers.js';
+
+function mutateWriterKeyToZero(t, validPayload) {
+	const decoded = safeDecodeApplyOperation(validPayload);
+	t.ok(decoded, 'fixtures decode');
+	if (!decoded.rao) return validPayload;
+	decoded.rao.iw = ZERO_WK;
+	return safeEncodeApplyOperation(decoded);
+}
+
+export default function addWriterZeroWriterKeyScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply addWriter rejects zero writer key requests',
+		setupScenario: setupAddWriterScenario,
+		buildValidPayload: buildAddWriterPayload,
+		mutatePayload: mutateWriterKeyToZero,
+		applyInvalidPayload: applyWithRoleAccessBypass,
+		assertStateUnchanged: assertAddWriterFailureState,
+		expectedLogs: ['Writer cannot initialize with zero-writer-key.']
+	}).performScenario();
+}