trac-msb 0.2.4 → 0.2.6

package/tests/unit/state/apply/common/balances/base/requesterBalanceScenarioBase.js

@@ -0,0 +1,197 @@
+import b4a from 'b4a';
+import OperationValidationScenarioBase from '../../base/OperationValidationScenarioBase.js';
+import nodeEntryUtils from '../../../../../../../src/core/state/utils/nodeEntry.js';
+import addressUtils from '../../../../../../../src/core/state/utils/address.js';
+import { BALANCE_ZERO } from '../../../../../../../src/core/state/utils/balance.js';
+import { eventFlush } from '../../../../../../helpers/autobaseTestHelpers.js';
+
+export default class RequesterBalanceScenarioBase extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		mutateDecodedEntry = decoded => decoded,
+		selectPeer,
+		selectNode = defaultSelectNode,
+		expectedLogs,
+		mutatePayload,
+		applyInvalidPayload,
+		failNextBalanceSub = false,
+		failNextBalanceUpdate = false
+	}) {
+		if (typeof mutateDecodedEntry !== 'function') {
+			throw new Error('Requester balance scenario requires a mutateDecodedEntry function.');
+		}
+
+		if (typeof selectPeer !== 'function') {
+			throw new Error('Requester balance scenario requires a selectPeer function.');
+		}
+
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload: mutatePayload ?? passThroughPayload,
+			applyInvalidPayload:
+				typeof applyInvalidPayload === 'function'
+					? applyInvalidPayload
+					: createApplyInvalidPayload({
+							selectNode,
+							selectPeer,
+							mutateDecodedEntry,
+							failNextBalanceSub,
+							failNextBalanceUpdate
+					  }),
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+function passThroughPayload(_t, payload) {
+	return payload;
+}
+
+function defaultSelectNode(context) {
+	return context.adminBootstrap ?? context.bootstrap ?? context.peers?.[0] ?? null;
+}
+
+function createApplyInvalidPayload({
+	selectNode,
+	selectPeer,
+	mutateDecodedEntry,
+	failNextBalanceSub,
+	failNextBalanceUpdate
+}) {
+	return async (context, payload) => {
+		const node = selectNode(context);
+		if (!node?.base) {
+			throw new Error('Requester balance scenario requires a writable node.');
+		}
+
+		const peer = selectPeer(context);
+		if (!peer?.wallet?.address) {
+			throw new Error('Requester balance scenario requires a peer with an address.');
+		}
+
+		const targetAddressString = peer.wallet.address;
+		const targetAddressBuffer = addressUtils.addressToBuffer(targetAddressString);
+
+		const originalDecode = nodeEntryUtils.decode;
+		let shouldFailNextSub = false;
+		let shouldFailNextUpdate = false;
+		let shouldMutateNextDecode = false;
+
+		nodeEntryUtils.decode = function patchedDecode(buffer) {
+			const decoded = originalDecode(buffer);
+			if (shouldMutateNextDecode) {
+				shouldMutateNextDecode = false;
+				shouldFailNextSub = failNextBalanceSub;
+				shouldFailNextUpdate = failNextBalanceUpdate;
+				const mutated = mutateDecodedEntry(decoded, { context, peer });
+				if (mutated && typeof mutated === 'object') {
+					return mutated;
+				}
+			}
+			return decoded;
+		};
+
+		let originalSub = null;
+		if (failNextBalanceSub) {
+			const balancePrototype = Object.getPrototypeOf(BALANCE_ZERO);
+			originalSub = balancePrototype.sub;
+			balancePrototype.sub = function patchedSub(...args) {
+				if (shouldFailNextSub) {
+					shouldFailNextSub = false;
+					return null;
+				}
+				return originalSub.call(this, ...args);
+			};
+		}
+
+		let originalUpdate = null;
+		let balancePrototype = null;
+		if (failNextBalanceUpdate) {
+			balancePrototype = Object.getPrototypeOf(BALANCE_ZERO);
+			originalUpdate = balancePrototype.update;
+			balancePrototype.update = function patchedUpdate(...args) {
+				if (shouldFailNextUpdate) {
+					shouldFailNextUpdate = false;
+					return null;
+				}
+				return originalUpdate.call(this, ...args);
+			};
+		}
+
+		const cleanup = patchNodeEntryAccess({
+			base: node.base,
+			targetAddressString,
+			targetAddressBuffer,
+			onTargetHit: () => {
+				shouldMutateNextDecode = true;
+			}
+		});
+
+		try {
+			await node.base.append(payload);
+			await node.base.update();
+			await eventFlush();
+		} finally {
+			nodeEntryUtils.decode = originalDecode;
+			if (failNextBalanceSub && originalSub) {
+				const balancePrototype = Object.getPrototypeOf(BALANCE_ZERO);
+				balancePrototype.sub = originalSub;
+			}
+			if (failNextBalanceUpdate && balancePrototype && originalUpdate) {
+				balancePrototype.update = originalUpdate;
+			}
+			cleanup();
+		}
+	};
+}
+
+function patchNodeEntryAccess({ base, targetAddressString, targetAddressBuffer, onTargetHit }) {
+	const originalApply = base._handlers.apply;
+
+	base._handlers.apply = async function patchedApply(nodes, view, baseCtx) {
+		const originalBatch = view.batch;
+		view.batch = function patchedBatch(...args) {
+			const batch = originalBatch.apply(this, args);
+			if (!batch?.get) {
+				return batch;
+			}
+
+			const originalGet = batch.get.bind(batch);
+			batch.get = async key => {
+				const entry = await originalGet(key);
+				if (isTargetKey(key, targetAddressString, targetAddressBuffer)) {
+					onTargetHit?.();
+				}
+				return entry;
+			};
+
+			return batch;
+		};
+
+		try {
+			return await originalApply.call(this, nodes, view, baseCtx);
+		} finally {
+			view.batch = originalBatch;
+		}
+	};
+
+	return () => {
+		base._handlers.apply = originalApply;
+	};
+}
+
+function isTargetKey(key, targetAddressString, targetAddressBuffer) {
+	if (typeof key === 'string') {
+		return key === targetAddressString;
+	}
+	if (b4a.isBuffer(key) && targetAddressBuffer) {
+		return b4a.equals(key, targetAddressBuffer);
+	}
+	return false;
+}

package/tests/unit/state/apply/common/balances/feeDecodeFailureScenario.js

@@ -0,0 +1,52 @@
+import b4a from 'b4a';
+import OperationValidationScenarioBase from '../base/OperationValidationScenarioBase.js';
+import transactionUtils from '../../../../../../src/core/state/utils/transaction.js';
+import { eventFlush } from '../../../../../helpers/autobaseTestHelpers.js';
+
+const DEFAULT_LOG = 'Invalid fee amount.';
+
+export default class FeeDecodeFailureScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		expectedLogs = [DEFAULT_LOG],
+		selectNode = defaultSelectNode,
+		mutatePayload
+	}) {
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload: mutatePayload ?? passThroughPayload,
+			applyInvalidPayload: async (context, payload) => {
+				const node = selectNode(context);
+				if (!node?.base) {
+					throw new Error('Fee decode failure scenario requires a writable node.');
+				}
+
+				const originalFee = transactionUtils.FEE;
+				transactionUtils.FEE = b4a.alloc(1); // invalid buffer to break toBalance()
+
+				try {
+					await node.base.append(payload);
+					await node.base.update();
+					await eventFlush();
+				} finally {
+					transactionUtils.FEE = originalFee;
+				}
+			},
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+function passThroughPayload(_t, payload) {
+	return payload;
+}
+
+function defaultSelectNode(context) {
+	return context.adminBootstrap ?? context.bootstrap ?? context.peers?.[0] ?? null;
+}

package/tests/unit/state/apply/common/balances/requesterBalanceDecodeFailureScenario.js

@@ -0,0 +1,15 @@
+import b4a from 'b4a';
+import RequesterBalanceScenarioBase from './base/requesterBalanceScenarioBase.js';
+
+export default class RequesterBalanceDecodeFailureScenario extends RequesterBalanceScenarioBase {
+	constructor(options) {
+		super({
+			...options,
+			mutateDecodedEntry: decoded => ({
+				...decoded,
+				balance: b4a.alloc(1)
+			}),
+			expectedLogs: ['Invalid requester balance.']
+		});
+	}
+}

package/tests/unit/state/apply/common/balances/requesterBalanceFeeApplicationFailureScenario.js

@@ -0,0 +1,11 @@
+import RequesterBalanceScenarioBase from './base/requesterBalanceScenarioBase.js';
+
+export default class RequesterBalanceFeeApplicationFailureScenario extends RequesterBalanceScenarioBase {
+	constructor(options) {
+		super({
+			...options,
+			failNextBalanceSub: true,
+			expectedLogs: options?.expectedLogs ?? ['Failed to apply fee to requester balance.']
+		});
+	}
+}

package/tests/unit/state/apply/common/balances/requesterBalanceInsufficientScenario.js

@@ -0,0 +1,15 @@
+import b4a from 'b4a';
+import RequesterBalanceScenarioBase from './base/requesterBalanceScenarioBase.js';
+
+export default class RequesterBalanceInsufficientScenario extends RequesterBalanceScenarioBase {
+	constructor(options) {
+		super({
+			...options,
+			mutateDecodedEntry: decoded => ({
+				...decoded,
+				balance: b4a.alloc(decoded.balance.length)
+			}),
+			expectedLogs: ['Insufficient requester balance.']
+		});
+	}
+}

package/tests/unit/state/apply/common/balances/requesterBalanceUpdateFailureScenario.js

@@ -0,0 +1,11 @@
+import RequesterBalanceScenarioBase from './base/requesterBalanceScenarioBase.js';
+
+export default class RequesterBalanceUpdateFailureScenario extends RequesterBalanceScenarioBase {
+	constructor(options) {
+		super({
+			...options,
+			failNextBalanceUpdate: true,
+			expectedLogs: options?.expectedLogs ?? ['Failed to update node balance.']
+		});
+	}
+}

package/tests/unit/state/apply/common/balances/validatorEntryRewardFailureScenario.js

@@ -0,0 +1,11 @@
+import ValidatorEntryValidationScenarioBase from '../validatorEntryValidation/base/validatorEntryValidationScenarioBase.js';
+
+export default class ValidatorEntryRewardFailureScenario extends ValidatorEntryValidationScenarioBase {
+	constructor(options) {
+		super({
+			...options,
+			failNextBalanceAdd: true,
+			expectedLogs: options?.expectedLogs ?? ['Failed to transfer fee to validator.']
+		});
+	}
+}

package/tests/unit/state/apply/common/balances/validatorEntryUpdateFailureScenario.js

@@ -0,0 +1,11 @@
+import ValidatorEntryValidationScenarioBase from '../validatorEntryValidation/base/validatorEntryValidationScenarioBase.js';
+
+export default class ValidatorEntryUpdateFailureScenario extends ValidatorEntryValidationScenarioBase {
+	constructor(options) {
+		super({
+			...options,
+			failNextBalanceUpdate: true,
+			expectedLogs: options?.expectedLogs ?? ['Failed to update validator entry.']
+		});
+	}
+}

package/tests/unit/state/apply/common/balances/validatorNodeEntryDecodeFailureScenario.js

@@ -0,0 +1,40 @@
+import nodeEntryUtils from '../../../../../../src/core/state/utils/nodeEntry.js';
+import RequesterBalanceScenarioBase from './base/requesterBalanceScenarioBase.js';
+
+export default class ValidatorNodeEntryDecodeFailureScenario extends RequesterBalanceScenarioBase {
+	constructor({
+		title = 'State.apply operation rejects payloads when validator node entry cannot be decoded',
+		expectedLogs = ['Failed to decode validator entry.'],
+		...options
+	}) {
+		super({
+			...options,
+			title,
+			expectedLogs,
+			selectPeer: options.selectPeer ?? (() => options.validatorPeer ?? null),
+			mutateDecodedEntry: decoded => decoded,
+			applyInvalidPayload: createApplyInvalidPayload(options)
+		});
+	}
+}
+
+function createApplyInvalidPayload({ selectNode, selectPeer }) {
+	return async (context, payload) => {
+		const node = selectNode?.(context) ?? context.bootstrap ?? context.adminBootstrap ?? context.peers?.[0];
+		const peer = selectPeer?.(context) ?? context.bootstrapDeployment?.validatorPeer ?? context.peers?.[1];
+		if (!node?.base || !peer?.wallet?.address) {
+			throw new Error('Validator node entry decode failure scenario requires node and validator peer.');
+		}
+
+		const originalDecode = nodeEntryUtils.decode;
+
+		nodeEntryUtils.decode = () => null;
+
+		try {
+			await node.base.append(payload);
+			await node.base.update();
+		} finally {
+			nodeEntryUtils.decode = originalDecode;
+		}
+	};
+}

package/tests/unit/state/apply/common/base/OperationValidationScenarioBase.js

@@ -0,0 +1,114 @@
+import { test } from 'brittle';
+
+export default class OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		mutatePayload,
+		applyInvalidPayload,
+		assertStateUnchanged,
+		expectedLogs = []
+	}) {
+		Object.entries({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload,
+			applyInvalidPayload,
+			assertStateUnchanged
+		}).forEach(([key, value]) => {
+			if (!value) {
+				throw new Error(`Operation validation scenario missing required ${key}`);
+			}
+		});
+
+		if (typeof title !== 'string') {
+			throw new Error('Operation validation scenario requires a title string.');
+		}
+
+		this.title = title;
+		this.setupScenario = setupScenario;
+		this.buildValidPayload = buildValidPayload;
+		this.mutatePayload = mutatePayload;
+		this.applyInvalidPayload = applyInvalidPayload;
+		this.assertStateUnchanged = assertStateUnchanged;
+		this.expectedLogs = this.#normalizeExpectedLogs(expectedLogs);
+	}
+
+	async execute(t) {
+		const shouldCaptureLogs = this.expectedLogs.length > 0;
+		const capturedLogs = [];
+		const originalConsoleError = console.error;
+		if (shouldCaptureLogs) {
+			console.error = (...args) => {
+				capturedLogs.push(args);
+				originalConsoleError(...args);
+			};
+		}
+
+		const context = await this.setupScenario(t);
+		const validPayload = await this.buildValidPayload(context, t);
+		t.ok(validPayload?.length > 0, 'valid payload encodes');
+
+		const invalidPayload = await this.mutatePayload(t, validPayload, context);
+		t.ok(invalidPayload.length > 0, 'invalid payload still encodes');
+
+		try {
+			await this.applyInvalidPayload(context, invalidPayload, t, validPayload);
+			await this.assertStateUnchanged(t, context, validPayload, invalidPayload);
+		} finally {
+			if (shouldCaptureLogs) {
+				console.error = originalConsoleError;
+				this.#assertExpectedLogs(t, capturedLogs);
+			}
+		}
+	}
+
+	performScenario() {
+		test(this.title, t => this.execute(t));
+	}
+
+	#assertExpectedLogs(t, capturedLogs) {
+		for (const matcher of this.expectedLogs) {
+			const found = matcher.values.some(expected =>
+				capturedLogs.some(args =>
+					args.some(arg => this.#toComparableString(arg).includes(expected))
+				)
+			);
+			t.ok(found, `expected apply log ${matcher.label} was emitted`);
+		}
+	}
+
+	#normalizeExpectedLogs(expectedLogs) {
+		if (!Array.isArray(expectedLogs) || expectedLogs.length === 0) return [];
+		return expectedLogs.map(entry => {
+			if (typeof entry === 'string') {
+				return { values: [entry], label: `"${entry}"` };
+			}
+			if (Array.isArray(entry) && entry.length > 0) {
+				return {
+					values: entry.map(value => (typeof value === 'string' ? value : String(value))),
+					label: entry.map(value => `"${value}"`).join(' or ')
+				};
+			}
+			if (entry && Array.isArray(entry.anyOf) && entry.anyOf.length > 0) {
+				return {
+					values: entry.anyOf.map(value => (typeof value === 'string' ? value : String(value))),
+					label: entry.anyOf.map(value => `"${value}"`).join(' or ')
+				};
+			}
+			throw new Error('expectedLogs entries must be strings, arrays of strings, or { anyOf: string[] }');
+		});
+	}
+
+	#toComparableString(arg) {
+		if (typeof arg === 'string') return arg;
+		if (arg instanceof Error) return arg.message || arg.toString();
+		try {
+			return JSON.stringify(arg);
+		} catch {
+			return String(arg);
+		}
+	}
+}

package/tests/unit/state/apply/common/commonScenarioHelper.js

@@ -0,0 +1,103 @@
+import { setupStateNetwork } from '../../../../helpers/StateNetworkFactory.js';
+import {
+	seedBootstrapIndexer,
+	defaultOpenHyperbeeView,
+	deriveIndexerSequenceState,
+	eventFlush
+} from '../../../../helpers/autobaseTestHelpers.js';
+import CompleteStateMessageOperations from '../../../../../src/messages/completeStateMessages/CompleteStateMessageOperations.js';
+import { AUTOBASE_VALUE_ENCODING } from '../../../../../src/utils/constants.js';
+import { buildAddAdminRequesterPayload } from '../addAdmin/addAdminScenarioHelpers.js';
+
+/**
+ * Boots a network with an initialized admin node and returns the shared context.
+ */
+export async function setupAdminNetwork(t, { nodes = 2 } = {}) {
+	const context = await setupStateNetwork({
+		nodes: Math.max(nodes, 2),
+		valueEncoding: AUTOBASE_VALUE_ENCODING,
+		open: defaultOpenHyperbeeView
+	});
+
+	seedBootstrapIndexer(context);
+
+	t.teardown(async () => {
+		await context.teardown();
+	});
+
+	await bootstrapAdmin(context);
+	return context;
+}
+
+/**
+ * Ensures the first reader peer receives funds and becomes whitelisted.
+ */
+export async function setupAdminAndWhitelistedReaderNetwork(
+	t,
+	{ nodes = 2, readerInitialBalance = null } = {}
+) {
+	const context = await setupAdminNetwork(t, { nodes });
+	const readerPeers = context.peers.slice(1);
+	const firstReader = readerPeers[0];
+	if (!firstReader) return context;
+
+	if (readerInitialBalance) {
+		await initializeBalances(context, [[firstReader.wallet.address, readerInitialBalance]]);
+	}
+
+	await whitelistAddress(context, firstReader.wallet.address);
+	return context;
+}
+
+/**
+ * Appends balance initialization payloads for provided pairs.
+ * @param {Array<[string, Buffer]>} recipients - address/balance tuples.
+ */
+export async function initializeBalances(context, recipients) {
+	const adminNode = context.adminBootstrap;
+	if (!adminNode || !Array.isArray(recipients) || recipients.length === 0) return;
+
+	const txValidity = await deriveIndexerSequenceState(adminNode.base);
+	const payloads = await CompleteStateMessageOperations.assembleBalanceInitializationMessages(
+		adminNode.wallet,
+		txValidity,
+		recipients
+	);
+
+	for (const payload of payloads) {
+		await adminNode.base.append(payload);
+		await adminNode.base.update();
+		await eventFlush();
+	}
+}
+
+export async function whitelistAddress(context, address) {
+	const adminNode = context.adminBootstrap;
+	if (!adminNode || !address) return;
+
+	const txValidity = await deriveIndexerSequenceState(adminNode.base);
+	const payload = await CompleteStateMessageOperations.assembleAppendWhitelistMessages(
+		adminNode.wallet,
+		txValidity,
+		address
+	);
+
+	await adminNode.base.append(payload);
+	await adminNode.base.update();
+	await eventFlush();
+}
+
+async function bootstrapAdmin(context) {
+	const adminNode = context.adminBootstrap;
+	const payload = await buildAddAdminRequesterPayload(context);
+	await adminNode.base.append(payload);
+	await adminNode.base.update();
+	await eventFlush();
+}
+
+export default {
+	setupAdminNetwork,
+	setupAdminAndWhitelistedReaderNetwork,
+	initializeBalances,
+	whitelistAddress
+};

package/tests/unit/state/apply/common/indexer/indexerNodeEntryDecodeFailureScenario.js

@@ -0,0 +1,36 @@
+import OperationValidationScenarioBase from '../base/OperationValidationScenarioBase.js';
+import { applyWithRequesterEntryCorruption } from '../../addWriter/addWriterScenarioHelpers.js';
+
+const passThroughPayload = (_t, payload) => payload;
+
+export default class IndexerNodeEntryDecodeFailureScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		expectedLogs,
+		selectPeer,
+		mutatePayload = passThroughPayload
+	}) {
+		const peerSelector = typeof selectPeer === 'function' ? selectPeer : null;
+
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload,
+			applyInvalidPayload: (context, invalidPayload, t, validPayload) => {
+				const peer =
+					peerSelector?.(context, {
+						invalidPayload,
+						validPayload,
+						t
+					}) ?? null;
+				return applyWithRequesterEntryCorruption(context, invalidPayload, { peer });
+			},
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}

package/tests/unit/state/apply/common/indexer/indexerNodeEntryMissingScenario.js

@@ -0,0 +1,36 @@
+import OperationValidationScenarioBase from '../base/OperationValidationScenarioBase.js';
+import { applyWithRequesterEntryRemoval } from '../../addWriter/addWriterScenarioHelpers.js';
+
+const passThroughPayload = (_t, payload) => payload;
+
+export default class IndexerNodeEntryMissingScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		expectedLogs,
+		selectPeer,
+		mutatePayload = passThroughPayload
+	}) {
+		const peerSelector = typeof selectPeer === 'function' ? selectPeer : null;
+
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload,
+			applyInvalidPayload: (context, invalidPayload, t, validPayload) => {
+				const peer =
+					peerSelector?.(context, {
+						invalidPayload,
+						validPayload,
+						t
+					}) ?? null;
+				return applyWithRequesterEntryRemoval(context, invalidPayload, { peer });
+			},
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}

package/tests/unit/state/apply/common/indexer/indexerRoleUpdateFailureScenario.js

@@ -0,0 +1,29 @@
+import OperationValidationScenarioBase from '../base/OperationValidationScenarioBase.js';
+
+const passThroughPayload = (_t, payload) => payload;
+
+export default class IndexerRoleUpdateFailureScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		expectedLogs,
+		applyRoleMutationFailure,
+		mutatePayload = passThroughPayload
+	}) {
+		if (typeof applyRoleMutationFailure !== 'function') {
+			throw new Error('Indexer role update failure scenario requires an applyRoleMutationFailure function.');
+		}
+
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload,
+			applyInvalidPayload: applyRoleMutationFailure,
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}