trac-msb 0.2.4 → 0.2.6

package/tests/unit/state/apply/common/payload-structure/partialOperationValidationScenario.js

@@ -0,0 +1,87 @@
+import b4a from 'b4a';
+import OperationValidationScenarioBase from '../base/OperationValidationScenarioBase.js';
+import {
+	safeDecodeApplyOperation,
+	safeEncodeApplyOperation
+} from '../../../../../../src/utils/protobuf/operationHelpers.js';
+import { eventFlush } from '../../../../../helpers/autobaseTestHelpers.js';
+
+export const PartialOperationMutationStrategy = {
+	MISSING_COMPONENT: 'missing-component',
+	NONCE_MATCH: 'nonce-match',
+	ADDRESS_MATCH: 'address-match',
+	SIGNATURE_MATCH: 'signature-match'
+};
+
+export default class PartialOperationValidationScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		strategy,
+		parentKey = 'rao',
+		applyInvalidPayload = defaultApplyInvalidPayload,
+		expectedLogs
+	}) {
+		const mutatePayload = createMutationStrategy(strategy, parentKey);
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload,
+			applyInvalidPayload,
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+function createMutationStrategy(strategy, parentKey) {
+	switch (strategy) {
+		case PartialOperationMutationStrategy.MISSING_COMPONENT:
+			return (t, payload) => removeComponent(t, payload, parentKey, 'vs');
+		case PartialOperationMutationStrategy.NONCE_MATCH:
+			return (t, payload) => duplicateField(t, payload, parentKey, 'vn', 'in');
+		case PartialOperationMutationStrategy.ADDRESS_MATCH:
+			return (t, payload) => alignAddress(t, payload, parentKey);
+		case PartialOperationMutationStrategy.SIGNATURE_MATCH:
+			return (t, payload) => duplicateField(t, payload, parentKey, 'vs', 'is');
+		default:
+			throw new Error(`Unsupported partial operation strategy: ${strategy}`);
+	}
+}
+
+function removeComponent(t, validPayload, parentKey, component) {
+	const decoded = safeDecodeApplyOperation(validPayload);
+	t.ok(decoded, 'fixtures decode');
+	const parent = decoded[parentKey];
+	if (!parent) return validPayload;
+	delete parent[component];
+	return safeEncodeApplyOperation(decoded);
+}
+
+function duplicateField(t, validPayload, parentKey, targetKey, sourceKey) {
+	const decoded = safeDecodeApplyOperation(validPayload);
+	t.ok(decoded, 'fixtures decode');
+	const parent = decoded[parentKey];
+	if (!parent || !parent[sourceKey]) return validPayload;
+	parent[targetKey] = b4a.from(parent[sourceKey]);
+	return safeEncodeApplyOperation(decoded);
+}
+
+function alignAddress(t, validPayload, parentKey) {
+	const decoded = safeDecodeApplyOperation(validPayload);
+	t.ok(decoded, 'fixtures decode');
+	const parent = decoded[parentKey];
+	if (!parent || !decoded.address) return validPayload;
+	parent.va = b4a.from(decoded.address);
+	return safeEncodeApplyOperation(decoded);
+}
+
+async function defaultApplyInvalidPayload(context, invalidPayload) {
+	const { bootstrap } = context;
+	await bootstrap.base.append(invalidPayload);
+	await bootstrap.base.update();
+	await eventFlush();
+}

package/tests/unit/state/apply/common/requester/requesterNodeEntryBufferMissingScenario.js

@@ -0,0 +1,70 @@
+import b4a from 'b4a';
+import OperationValidationScenarioBase from '../base/OperationValidationScenarioBase.js';
+import addressUtils from '../../../../../../src/core/state/utils/address.js';
+import { eventFlush } from '../../../../../helpers/autobaseTestHelpers.js';
+
+export default class RequesterNodeEntryBufferMissingScenario extends OperationValidationScenarioBase {
+	constructor({
+		title = 'State.apply operation rejects payloads when requester node entry buffer is missing',
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		expectedLogs = ['Invalid requester node entry buffer.'],
+		selectNode = context => context.bootstrap ?? context.adminBootstrap ?? context.peers?.[0],
+		selectPeer = context => context.bootstrapDeployment?.deployerPeer ?? context.peers?.[1]
+	}) {
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload: (_t, payload) => payload,
+			applyInvalidPayload: async (context, payload) => {
+				const node = selectNode(context);
+				const peer = selectPeer(context);
+				if (!node?.base || !peer?.wallet?.address) {
+					throw new Error('Requester node entry buffer scenario requires node and peer.');
+				}
+
+				const targetAddressString = peer.wallet.address;
+				const targetAddressBuffer = addressUtils.addressToBuffer(targetAddressString);
+
+				const originalApply = node.base._handlers.apply;
+				node.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 => {
+							if (isTargetKey(key, targetAddressString, targetAddressBuffer)) return null;
+							return originalGet(key);
+						};
+						return batch;
+					};
+
+					try {
+						return await originalApply.call(this, nodes, view, baseCtx);
+					} finally {
+						view.batch = originalBatch;
+					}
+				};
+
+				try {
+					await node.base.append(payload);
+					await node.base.update();
+					await eventFlush();
+				} finally {
+					node.base._handlers.apply = originalApply;
+				}
+			},
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+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/requester/requesterNodeEntryDecodeFailureScenario.js

@@ -0,0 +1,72 @@
+import b4a from 'b4a';
+import OperationValidationScenarioBase from '../base/OperationValidationScenarioBase.js';
+import addressUtils from '../../../../../../src/core/state/utils/address.js';
+import { eventFlush } from '../../../../../helpers/autobaseTestHelpers.js';
+
+export default class RequesterNodeEntryDecodeFailureScenario extends OperationValidationScenarioBase {
+	constructor({
+		title = 'State.apply operation rejects payloads when requester node entry cannot be decoded',
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		expectedLogs = ['Invalid requester node entry.'],
+		selectNode = context => context.bootstrap ?? context.adminBootstrap ?? context.peers?.[0],
+		selectPeer = context => context.bootstrapDeployment?.deployerPeer ?? context.peers?.[1]
+	}) {
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload: (_t, payload) => payload,
+			applyInvalidPayload: async (context, payload) => {
+				const node = selectNode(context);
+				const peer = selectPeer(context);
+				if (!node?.base || !peer?.wallet?.address) {
+					throw new Error('Requester node entry decode scenario requires node and peer.');
+				}
+
+				const targetAddressString = peer.wallet.address;
+				const targetAddressBuffer = addressUtils.addressToBuffer(targetAddressString);
+
+				const originalApply = node.base._handlers.apply;
+				node.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 => {
+							if (isTargetKey(key, targetAddressString, targetAddressBuffer)) {
+								return { key, value: b4a.alloc(0) };
+							}
+							return originalGet(key);
+						};
+						return batch;
+					};
+
+					try {
+						return await originalApply.call(this, nodes, view, baseCtx);
+					} finally {
+						view.batch = originalBatch;
+					}
+				};
+
+				try {
+					await node.base.append(payload);
+					await node.base.update();
+					await eventFlush();
+				} finally {
+					node.base._handlers.apply = originalApply;
+				}
+			},
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+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/requester/requesterNodeEntryMissingScenario.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 RequesterNodeEntryMissingScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		expectedLogs,
+		selectPeer,
+		mutatePayload = passThroughPayload
+	}) {
+		if (typeof selectPeer !== 'function') {
+			throw new Error('Requester node entry scenario requires a selectPeer function.');
+		}
+
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload,
+			applyInvalidPayload: async (context, invalidPayload) => {
+				const peer = selectPeer(context);
+				if (!peer) {
+					throw new Error('Requester node entry scenario requires a peer instance.');
+				}
+				await applyWithRequesterEntryRemoval(context, invalidPayload, { peer });
+			},
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}

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

@@ -0,0 +1,44 @@
+import b4a from 'b4a';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import { safeDecodeApplyOperation, safeEncodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
+import OperationValidationScenarioBase from './base/OperationValidationScenarioBase.js';
+
+export default class RequesterAddressValidationScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		mutatePayload = defaultMutateRequesterPayload,
+		applyInvalidPayload = defaultApplyInvalidRequesterPayload,
+		expectedLogs
+	}) {
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload,
+			applyInvalidPayload,
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+function defaultMutateRequesterPayload(t, validPayload) {
+	const decodedPayload = safeDecodeApplyOperation(validPayload);
+	t.ok(decodedPayload, 'fixtures decode');
+
+	const invalidAddressBuffer = b4a.from(decodedPayload.address);
+	invalidAddressBuffer[0] = invalidAddressBuffer[0] === 120 ? 121 : 120;
+	decodedPayload.address = invalidAddressBuffer;
+
+	return safeEncodeApplyOperation(decodedPayload);
+}
+
+async function defaultApplyInvalidRequesterPayload(context, invalidPayload) {
+	const { bootstrap } = context;
+	await bootstrap.base.append(invalidPayload);
+	await bootstrap.base.update();
+	await eventFlush();
+}

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

@@ -0,0 +1,25 @@
+import b4a from 'b4a';
+import RequesterAddressValidationScenario from './requesterAddressValidationScenario.js';
+import { safeDecodeApplyOperation, safeEncodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
+
+function mutateRequesterPublicKey(t, validPayload) {
+	const decodedPayload = safeDecodeApplyOperation(validPayload);
+	t.ok(decodedPayload, 'fixtures decode');
+
+	const mutatedAddress = b4a.from(decodedPayload.address);
+	const lastIndex = mutatedAddress.length - 1;
+	const currentChar = mutatedAddress[lastIndex];
+	const asciiP = 'p'.charCodeAt(0);
+	const asciiQ = 'q'.charCodeAt(0);
+	mutatedAddress[lastIndex] = currentChar === asciiP ? asciiQ : asciiP;
+
+	decodedPayload.address = mutatedAddress;
+	return safeEncodeApplyOperation(decodedPayload);
+}
+
+export default function createRequesterPublicKeyValidationScenario(config) {
+	return new RequesterAddressValidationScenario({
+		...config,
+		mutatePayload: mutateRequesterPublicKey
+	});
+}

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

@@ -0,0 +1,98 @@
+import b4a from 'b4a';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import { safeDecodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
+import OperationValidationScenarioBase from './base/OperationValidationScenarioBase.js';
+
+export default class TransactionValidityMismatchScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		txValidityPath = ['cao', 'txv'],
+		applyInvalidPayload = defaultApplyInvalidPayload,
+		rebuildPayloadWithTxValidity,
+		expectedLogs
+	}) {
+		if (typeof rebuildPayloadWithTxValidity !== 'function') {
+			throw new Error(
+				'Transaction validity mismatch scenario requires a rebuildPayloadWithTxValidity function.'
+			);
+		}
+
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload: (t, payload, context) =>
+				mutateTxValidityPayload({
+					t,
+					validPayload: payload,
+					context,
+					txValidityPath,
+					rebuildPayloadWithTxValidity
+				}),
+			applyInvalidPayload,
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+async function mutateTxValidityPayload({
+	t,
+	validPayload,
+	context,
+	txValidityPath,
+	rebuildPayloadWithTxValidity
+}) {
+	const path = Array.isArray(txValidityPath) ? txValidityPath : [txValidityPath];
+	if (!path.length) {
+		throw new Error('Transaction validity mutation requires a non-empty path.');
+	}
+
+	const decodedPayload = safeDecodeApplyOperation(validPayload);
+	t.ok(decodedPayload, 'fixtures decode');
+
+	const txValidityBuffer = locateTxValidityBuffer(decodedPayload, path);
+	if (!txValidityBuffer) {
+		return validPayload;
+	}
+
+	const mutatedValidity = flipTxValidity(txValidityBuffer);
+	return rebuildPayloadWithTxValidity({
+		context,
+		t,
+		validPayload,
+		mutatedTxValidity: mutatedValidity
+	});
+}
+
+function locateTxValidityBuffer(payload, path) {
+	let current = payload;
+	for (let i = 0; i < path.length - 1; i++) {
+		if (!current) return null;
+		current = current[path[i]];
+	}
+
+	const field = path[path.length - 1];
+	const value = current?.[field];
+	if (!b4a.isBuffer(value) || value.length === 0) {
+		return null;
+	}
+	return value;
+}
+
+function flipTxValidity(txValidityBuffer) {
+	const mutatedValidity = b4a.from(txValidityBuffer);
+	const lastIndex = mutatedValidity.length - 1;
+	mutatedValidity[lastIndex] ^= 0xff;
+	return mutatedValidity;
+}
+
+async function defaultApplyInvalidPayload(context, invalidPayload) {
+	const { bootstrap } = context;
+	await bootstrap.base.append(invalidPayload);
+	await bootstrap.base.update();
+	await eventFlush();
+}

package/tests/unit/state/apply/common/validatorConsistency/base/validatorConsistencyScenarioBase.js

@@ -0,0 +1,201 @@
+import b4a from 'b4a';
+import OperationValidationScenarioBase from '../../base/OperationValidationScenarioBase.js';
+import { safeDecodeApplyOperation } from '../../../../../../../src/utils/protobuf/operationHelpers.js';
+import addressUtils from '../../../../../../../src/core/state/utils/address.js';
+import { eventFlush } from '../../../../../../helpers/autobaseTestHelpers.js';
+
+export const ValidatorEntryMutation = {
+	DELETE: Symbol('validator-entry-delete')
+};
+
+const DEFAULT_VALIDATOR_ADDRESS_PATH = ['rao', 'va'];
+
+export default class ValidatorConsistencyScenarioBase extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		mutateEntry,
+		selectNode = defaultSelectNode,
+		validatorAddressPath = DEFAULT_VALIDATOR_ADDRESS_PATH,
+		expectedLogs,
+		applyInvalidPayload
+	}) {
+		if (typeof mutateEntry !== 'function') {
+			throw new Error('Validator consistency scenario requires a mutateEntry function.');
+		}
+
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload: passThroughPayload,
+			applyInvalidPayload:
+				typeof applyInvalidPayload === 'function'
+					? applyInvalidPayload
+					: createApplyInvalidPayload({
+							selectNode,
+							validatorAddressPath,
+							mutateEntry
+					  }),
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+function passThroughPayload(_t, payload) {
+	return payload;
+}
+
+function defaultSelectNode(context) {
+	return context.adminBootstrap ?? context.bootstrap ?? context.peers?.[0] ?? null;
+}
+
+function createApplyInvalidPayload({ selectNode, validatorAddressPath, mutateEntry }) {
+	return async (context, payload, t, validPayload) => {
+		const node = selectNode(context);
+		if (!node?.base) {
+			throw new Error('Validator consistency scenario requires a writable node.');
+		}
+
+		const validatorAddress = extractValidatorAddress(validPayload ?? payload, validatorAddressPath);
+		if (!validatorAddress) {
+			throw new Error('Validator address could not be derived from payload.');
+		}
+
+		const cleanup = patchValidatorEntry({
+			base: node.base,
+			mutateEntry,
+			context,
+			t,
+			validatorAddressString: validatorAddress.string,
+			validatorAddressBuffer: validatorAddress.buffer
+		});
+
+		try {
+			await node.base.append(payload);
+			await node.base.update();
+			await eventFlush();
+		} finally {
+			await cleanup();
+		}
+	};
+}
+
+function patchValidatorEntry({
+	base,
+	mutateEntry,
+	context,
+	t,
+	validatorAddressString,
+	validatorAddressBuffer
+}) {
+	const originalApply = base._handlers.apply;
+	let shouldInterceptNextApply = true;
+
+	base._handlers.apply = async function patchedApply(nodes, view, baseCtx) {
+		if (!shouldInterceptNextApply) {
+			return originalApply.call(this, nodes, view, baseCtx);
+		}
+
+		shouldInterceptNextApply = false;
+		const originalBatch = view.batch;
+		view.batch = function patchedBatch(...args) {
+			const batch = originalBatch.apply(this, args);
+			if (!batch || typeof batch.get !== 'function') {
+				return batch;
+			}
+
+			const originalGet = batch.get.bind(batch);
+			let hasMutatedEntry = false;
+
+			batch.get = async key => {
+				if (
+					!hasMutatedEntry &&
+					isValidatorKeyMatch(key, validatorAddressString, validatorAddressBuffer)
+				) {
+					hasMutatedEntry = true;
+					const entry = await originalGet(key);
+
+					const mutation = await mutateEntry(entry, {
+						context,
+						t,
+						validatorAddress: validatorAddressString
+					});
+
+					return applyEntryMutation(entry, mutation);
+				}
+
+				return originalGet(key);
+			};
+
+			return batch;
+		};
+
+		try {
+			return await originalApply.call(this, nodes, view, baseCtx);
+		} finally {
+			view.batch = originalBatch;
+		}
+	};
+
+	return async () => {
+		base._handlers.apply = originalApply;
+	};
+}
+
+function applyEntryMutation(entry, mutation) {
+	if (typeof mutation === 'undefined') {
+		return entry;
+	}
+
+	if (mutation === ValidatorEntryMutation.DELETE) {
+		return null;
+	}
+
+	if (entry && (b4a.isBuffer(mutation) || mutation instanceof Uint8Array)) {
+		return {
+			...entry,
+			value: b4a.from(mutation)
+		};
+	}
+
+	if (mutation && typeof mutation === 'object') {
+		return mutation;
+	}
+
+	throw new Error('Invalid validator entry mutation result.');
+}
+
+function extractValidatorAddress(payloadBuffer, path) {
+	const decoded = safeDecodeApplyOperation(payloadBuffer);
+	if (!decoded) return null;
+
+	const value = Array.isArray(path) && path.length > 0 ? traversePath(decoded, path) : null;
+	if (!value || !b4a.isBuffer(value) || value.length === 0) {
+		return null;
+	}
+
+	const addressString = addressUtils.bufferToAddress(value);
+	if (!addressString) {
+		return null;
+	}
+
+	return { buffer: value, string: addressString };
+}
+
+function traversePath(payload, path) {
+	return path.reduce((current, segment) => (current ? current[segment] : null), payload);
+}
+
+function isValidatorKeyMatch(key, targetString, targetBuffer) {
+	if (typeof key === 'string') {
+		return key === targetString;
+	}
+	if (b4a.isBuffer(key) && targetBuffer) {
+		return b4a.equals(key, targetBuffer);
+	}
+	return false;
+}

package/tests/unit/state/apply/common/validatorConsistency/validatorEntryDecodeFailureScenario.js

@@ -0,0 +1,17 @@
+import b4a from 'b4a';
+import ValidatorEntryValidationScenarioBase from '../validatorEntryValidation/base/validatorEntryValidationScenarioBase.js';
+
+export default class ValidatorEntryDecodeFailureScenario extends ValidatorEntryValidationScenarioBase {
+	constructor(options) {
+		super({
+			...options,
+			mutateEntry: entry => {
+				if (!entry?.value) {
+					throw new Error('Validator entry decode scenario requires an existing entry.');
+				}
+				return { ...entry, value: b4a.alloc(1) };
+			},
+			expectedLogs: options?.expectedLogs ?? ['Failed to decode validator entry.']
+		});
+	}
+}

package/tests/unit/state/apply/common/validatorConsistency/validatorEntryMissingScenario.js

@@ -0,0 +1,44 @@
+import OperationValidationScenarioBase from '../base/OperationValidationScenarioBase.js';
+import { eventFlush } from '../../../../../helpers/autobaseTestHelpers.js';
+
+export default class ValidatorEntryMissingScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		selectNode = defaultSelectNode,
+		expectedLogs
+	}) {
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload: passThroughPayload,
+			applyInvalidPayload: createApplyInvalidPayload(selectNode),
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+function passThroughPayload(_t, payload) {
+	return payload;
+}
+
+function defaultSelectNode(context) {
+	return context.adminBootstrap ?? context.bootstrap ?? context.peers?.[0] ?? null;
+}
+
+function createApplyInvalidPayload(selectNode) {
+	return async (context, payload) => {
+		const node = selectNode(context);
+		if (!node.base) {
+			throw new Error('Validator entry missing scenario requires a writable node.');
+		}
+
+		await node.base.append(payload);
+		await node.base.update();
+		await eventFlush();
+	};
+}