trac-msb 0.2.4 → 0.2.6

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

@@ -0,0 +1,66 @@
+import OperationValidationScenarioBase from '../base/OperationValidationScenarioBase.js';
+import { eventFlush } from '../../../../../helpers/autobaseTestHelpers.js';
+
+const passThroughPayload = (_t, payload) => payload;
+
+export default class IndexerSequenceStateInvalidScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		mutatePayload = passThroughPayload,
+		applyInvalidPayload = applyWithIndexerSequenceFailure,
+		expectedLogs
+	}) {
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload,
+			applyInvalidPayload,
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+async function applyWithIndexerSequenceFailure(context, invalidPayload) {
+	const node = context.bootstrap ?? context.adminBootstrap ?? context.peers?.[0];
+	if (!node?.base?.system) {
+		return;
+	}
+
+	const system = node.base.system;
+	const originalDescriptor = Object.getOwnPropertyDescriptor(system, 'indexers');
+	const originalValue = system.indexers;
+	let injected = false;
+
+	Object.defineProperty(system, 'indexers', {
+		configurable: true,
+		enumerable: true,
+		get() {
+			if (!injected) {
+				injected = true;
+				throw new Error('forced indexer sequence state failure');
+			}
+			return originalValue;
+		},
+		set(value) {
+			// preserve setter semantics
+			return Reflect.set(system, 'indexers', value);
+		}
+	});
+
+	try {
+		await node.base.append(invalidPayload).catch(() => {});
+		await node.base.update().catch(() => {});
+	} finally {
+		if (originalDescriptor) {
+			Object.defineProperty(system, 'indexers', originalDescriptor);
+		} else {
+			system.indexers = originalValue;
+		}
+		await eventFlush();
+	}
+}

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

@@ -0,0 +1,84 @@
+import OperationValidationScenarioBase from './base/OperationValidationScenarioBase.js';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import b4a from 'b4a';
+import { safeDecodeApplyOperation, safeEncodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
+
+export const MessageComponentStrategy = {
+	TX_VALIDITY: 'TX_VALIDITY',
+	NONCE: 'NONCE'
+};
+
+export default class InvalidMessageComponentValidationScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		strategy = MessageComponentStrategy.TX_VALIDITY,
+		applyInvalidPayload = defaultApplyInvalidPayload,
+		expectedLogs
+	}) {
+		const mutatePayload = createMutationStrategy(strategy);
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload,
+			applyInvalidPayload,
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+function createMutationStrategy(strategy) {
+	switch (strategy) {
+		case MessageComponentStrategy.NONCE:
+			return mutateNonce;
+		case MessageComponentStrategy.TX_VALIDITY:
+		default:
+			return mutateTxValidity;
+	}
+}
+
+function mutateTxValidity(t, validPayload) {
+	return mutateComponent(t, validPayload, 'txv');
+}
+
+function mutateNonce(t, validPayload) {
+	return mutateComponent(t, validPayload, 'in');
+}
+
+function mutateComponent(t, validPayload, componentKey) {
+	const decodedPayload = safeDecodeApplyOperation(validPayload);
+	t.ok(decodedPayload, 'fixtures decode');
+
+	const parent = findParentWithKey(decodedPayload, componentKey);
+	if (!parent || !parent[componentKey]) return validPayload;
+
+	parent[componentKey] = flipBuffer(parent[componentKey]);
+	return safeEncodeApplyOperation(decodedPayload);
+}
+
+function findParentWithKey(payload, key) {
+	const parents = ['cao', 'bio', 'aco', 'tro', 'rao', 'bdo', 'txo'];
+	for (const parentKey of parents) {
+		const parent = payload[parentKey];
+		if (parent?.[key]) return parent;
+	}
+	return null;
+}
+
+function flipBuffer(buf) {
+	const clone = b4a.from(buf);
+	if (clone.length === 0) return clone;
+	clone[clone.length - 1] ^= 0xff;
+	return clone;
+}
+
+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/nodeEntryInitializationFailureScenario.js

@@ -0,0 +1,47 @@
+import OperationValidationScenarioBase from './base/OperationValidationScenarioBase.js';
+import nodeEntryUtils from '../../../../../src/core/state/utils/nodeEntry.js';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+
+/**
+ * Forces nodeEntryUtils.init to return an empty buffer once, triggering
+ * "Failed to initialize node entry." in handlers that create a fresh entry.
+ */
+export default function createNodeEntryInitializationFailureScenario({
+	title,
+	setupScenario,
+	buildValidPayload,
+	assertStateUnchanged,
+	selectNode,
+	expectedLogs = ['Failed to initialize node entry.']
+}) {
+	return new OperationValidationScenarioBase({
+		title,
+		setupScenario,
+		buildValidPayload,
+		mutatePayload: (_t, payload) => payload,
+		applyInvalidPayload: async (context, invalidPayload) => {
+			const node = selectNode ? selectNode(context) : context.adminBootstrap;
+			const originalInit = nodeEntryUtils.init;
+			let shouldFailNextInit = true;
+
+			nodeEntryUtils.init = function patchedInit(...args) {
+				if (shouldFailNextInit) {
+					shouldFailNextInit = false;
+					console.error(expectedLogs[0]);
+					return Buffer.alloc(0);
+				}
+				return originalInit.call(this, ...args);
+			};
+
+			try {
+				await node.base.append(invalidPayload);
+				await node.base.update();
+				await eventFlush();
+			} finally {
+				nodeEntryUtils.init = originalInit;
+			}
+		},
+		assertStateUnchanged,
+		expectedLogs
+	});
+}

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

@@ -0,0 +1,85 @@
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import OperationValidationScenarioBase from './base/OperationValidationScenarioBase.js';
+
+export default class OperationAlreadyAppliedScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		mutatePayload = passThroughPayload,
+		selectNode = defaultSelectNode,
+		applyInvalidPayload,
+		beforeInvalidApply,
+		expectedLogs
+	}) {
+		const applyPayload =
+			applyInvalidPayload ??
+			((context, invalidPayload, t, validPayload) =>
+				defaultApplyInvalidPayload({
+					context,
+					invalidPayload,
+					validPayload,
+					selectNode,
+					beforeInvalidApply,
+					t
+				}));
+
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload,
+			applyInvalidPayload: applyPayload,
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+function passThroughPayload(_t, payload) {
+	return payload;
+}
+
+function defaultSelectNode(context) {
+	return context.adminBootstrap ?? context.bootstrap ?? context.peers?.[0] ?? null;
+}
+
+async function defaultApplyInvalidPayload({
+	context,
+	invalidPayload,
+	validPayload,
+	selectNode,
+	beforeInvalidApply,
+	t
+}) {
+	const node = selectNode(context);
+	if (!node?.base) {
+		throw new Error('Operation already applied scenario requires a writable node.');
+	}
+
+	await node.base.append(validPayload);
+	await node.base.update();
+	await eventFlush();
+
+	let cleanup;
+	if (beforeInvalidApply) {
+		cleanup = await beforeInvalidApply({
+			context,
+			node,
+			invalidPayload,
+			validPayload,
+			t
+		});
+	}
+
+	try {
+		await node.base.append(invalidPayload);
+		await node.base.update();
+		await eventFlush();
+	} finally {
+		if (typeof cleanup === 'function') {
+			await cleanup();
+		}
+	}
+}

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

@@ -0,0 +1,52 @@
+import b4a from 'b4a';
+import InvalidAddressValidationScenario from './invalidAddressValidationScenario.js';
+import {
+	safeDecodeApplyOperation,
+	safeEncodeApplyOperation
+} from '../../../../../../src/utils/protobuf/operationHelpers.js';
+
+export default function createAddressWithInvalidPublicKeyScenario(config, pathOverride) {
+	const { addressPath, ...rest } = config ?? {};
+	const normalizedPath = normalizePath(pathOverride ?? addressPath);
+
+	return new InvalidAddressValidationScenario({
+		...rest,
+		mutatePayload: (t, payload) => mutateAddressBuffer(t, payload, normalizedPath)
+	});
+}
+
+function normalizePath(path) {
+	if (!path) return ['address'];
+	return Array.isArray(path) ? path : [path];
+}
+
+function mutateAddressBuffer(t, validPayload, path) {
+	const decodedPayload = safeDecodeApplyOperation(validPayload);
+	t.ok(decodedPayload, 'fixtures decode');
+
+	const parent = locateParent(decodedPayload, path);
+	if (!parent) return validPayload;
+
+	const field = path[path.length - 1];
+	const buffer = parent[field];
+	if (!b4a.isBuffer(buffer)) return validPayload;
+
+	const mutatedBuffer = b4a.from(buffer);
+	const lastIndex = mutatedBuffer.length - 1;
+	const currentChar = mutatedBuffer[lastIndex];
+	const asciiP = 'p'.charCodeAt(0);
+	const asciiQ = 'q'.charCodeAt(0);
+	mutatedBuffer[lastIndex] = currentChar === asciiP ? asciiQ : asciiP;
+
+	parent[field] = mutatedBuffer;
+	return safeEncodeApplyOperation(decodedPayload);
+}
+
+function locateParent(payload, path) {
+	let current = payload;
+	for (let i = 0; i < path.length - 1; i++) {
+		if (!current) return null;
+		current = current[path[i]];
+	}
+	return current ?? null;
+}

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

@@ -0,0 +1,49 @@
+import { eventFlush, deriveIndexerSequenceState } from '../../../../../helpers/autobaseTestHelpers.js';
+import OperationValidationScenarioBase from '../base/OperationValidationScenarioBase.js';
+import CompleteStateMessageOperations from '../../../../../../src/messages/completeStateMessages/CompleteStateMessageOperations.js';
+
+export default class InitializationDisabledScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		expectedLogs
+	}) {
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload: passThroughPayload,
+			applyInvalidPayload: disableInitializationAndApply,
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+function passThroughPayload(_t, payload) {
+	return payload;
+}
+
+async function disableInitializationAndApply(context, invalidPayload) {
+	const adminNode = context.adminBootstrap ?? context.bootstrap;
+	if (!adminNode) {
+		throw new Error('Initialization disabled scenario requires admin bootstrap context.');
+	}
+
+	const txValidity = await deriveIndexerSequenceState(adminNode.base);
+	const disablePayload = await CompleteStateMessageOperations.assembleDisableInitializationMessage(
+		adminNode.wallet,
+		adminNode.base.local.key,
+		txValidity
+	);
+
+	await adminNode.base.append(disablePayload);
+	await adminNode.base.update();
+	await eventFlush();
+
+	await adminNode.base.append(invalidPayload);
+	await adminNode.base.update();
+	await eventFlush();
+}

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

@@ -0,0 +1,73 @@
+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 InvalidAddressValidationScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		addressPath,
+		mutatePayload,
+		applyInvalidPayload = defaultApplyInvalidPayload,
+		expectedLogs
+	}) {
+		const mutation = mutatePayload ?? createDefaultMutation(addressPath ?? ['address']);
+
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload: mutation,
+			applyInvalidPayload,
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+function createDefaultMutation(addressPath) {
+	const pathArray = Array.isArray(addressPath) ? addressPath : [addressPath];
+	if (!pathArray.length) {
+		throw new Error('Invalid address mutation requires a non-empty addressPath.');
+	}
+
+	return (t, validPayload) => {
+		const decodedPayload = safeDecodeApplyOperation(validPayload);
+		t.ok(decodedPayload, 'fixtures decode');
+
+		const parent = locateParent(decodedPayload, pathArray);
+		if (!parent) return validPayload;
+
+		const field = pathArray[pathArray.length - 1];
+		const buffer = parent[field];
+		if (!b4a.isBuffer(buffer)) return validPayload;
+
+		const mutated = b4a.from(buffer);
+		mutated[0] = mutated[0] === 120 ? 121 : 120;
+		parent[field] = mutated;
+
+		return safeEncodeApplyOperation(decodedPayload);
+	};
+}
+
+function locateParent(payload, pathArray) {
+	let current = payload;
+	for (let i = 0; i < pathArray.length - 1; i++) {
+		if (!current) return null;
+		current = current[pathArray[i]];
+	}
+	return current ?? null;
+}
+
+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/payload-structure/invalidHashValidationScenario.js

@@ -0,0 +1,71 @@
+import { eventFlush } from '../../../../../helpers/autobaseTestHelpers.js';
+import {
+	safeDecodeApplyOperation,
+	safeEncodeApplyOperation
+} from '../../../../../../src/utils/protobuf/operationHelpers.js';
+import { blake3Hash } from '../../../../../../src/utils/crypto.js';
+import OperationValidationScenarioBase from '../base/OperationValidationScenarioBase.js';
+
+export default class InvalidHashValidationScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		mutatePayload = defaultMutateHash,
+		applyInvalidPayload = defaultApplyInvalidPayload,
+		expectedLogs
+	}) {
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload,
+			applyInvalidPayload,
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+async function defaultMutateHash(t, validPayload) {
+	const decodedPayload = safeDecodeApplyOperation(validPayload);
+	t.ok(decodedPayload, 'fixtures decode');
+
+	const invalidHash = await blake3Hash(validPayload);
+
+	switch (true) {
+		case Boolean(decodedPayload.cao?.tx):
+			decodedPayload.cao.tx = invalidHash;
+			break;
+		case Boolean(decodedPayload.bio?.tx):
+			decodedPayload.bio.tx = invalidHash;
+			break;
+		case Boolean(decodedPayload.aco?.tx):
+			decodedPayload.aco.tx = invalidHash;
+			break;
+		case Boolean(decodedPayload.tro?.tx):
+			decodedPayload.tro.tx = invalidHash;
+			break;
+		case Boolean(decodedPayload.rao?.tx):
+			decodedPayload.rao.tx = invalidHash;
+			break;
+		case Boolean(decodedPayload.bdo?.tx):
+			decodedPayload.bdo.tx = invalidHash;
+			break;
+		case Boolean(decodedPayload.txo?.tx):
+			decodedPayload.txo.tx = invalidHash;
+			break;
+		default:
+			return validPayload;
+	}
+
+	return safeEncodeApplyOperation(decodedPayload);
+}
+
+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/payload-structure/invalidPayloadValidationScenario.js

@@ -0,0 +1,31 @@
+import { eventFlush } from '../../../../../helpers/autobaseTestHelpers.js';
+import OperationValidationScenarioBase from '../base/OperationValidationScenarioBase.js';
+
+export default class InvalidPayloadValidationScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		mutatePayload,
+		assertStateUnchanged,
+		applyInvalidPayload = defaultApplyInvalidPayload,
+		expectedLogs
+	}) {
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload,
+			applyInvalidPayload,
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+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/payload-structure/invalidSignatureValidationScenario.js

@@ -0,0 +1,142 @@
+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';
+import { createSignature } from '../../../../../helpers/createTestSignature.js';
+
+export const SignatureMutationStrategy = {
+	ZERO_FILL: 0,
+	FOREIGN_SIGNATURE: 1,
+	TYPE_MISMATCH: 2,
+	AMOUNT_SIGNATURE: 3
+};
+
+export default class InvalidSignatureValidationScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		strategy = SignatureMutationStrategy.FOREIGN_SIGNATURE,
+		applyInvalidPayload = defaultApplyInvalidPayload,
+		expectedLogs
+	}) {
+		const mutatePayload = createMutationStrategy(strategy);
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload,
+			applyInvalidPayload,
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+function createMutationStrategy(strategy) {
+	switch (strategy) {
+		case SignatureMutationStrategy.ZERO_FILL:
+			return zeroFillSignature;
+		case SignatureMutationStrategy.TYPE_MISMATCH:
+			return typeMismatchSignature;
+		case SignatureMutationStrategy.AMOUNT_SIGNATURE:
+			return mutateAmountSignature;
+		case SignatureMutationStrategy.FOREIGN_SIGNATURE:
+		default:
+			return foreignSignature;
+	}
+}
+
+async function foreignSignature(t, validPayload) {
+	const decodedPayload = safeDecodeApplyOperation(validPayload);
+	t.ok(decodedPayload, 'fixtures decode');
+
+	const signatureParent = findSignatureParent(decodedPayload);
+	if (!signatureParent || !signatureParent.parent?.tx) return validPayload;
+
+	const { signature } = await createSignature(signatureParent.parent.tx);
+	if (signature?.length === signatureParent.parent.is.length) {
+		signatureParent.parent.is = signature;
+	} else {
+		signatureParent.parent.is = b4a.alloc(signatureParent.parent.is.length);
+	}
+
+	return safeEncodeApplyOperation(decodedPayload);
+}
+
+async function zeroFillSignature(t, validPayload) {
+	const decodedPayload = safeDecodeApplyOperation(validPayload);
+	t.ok(decodedPayload, 'fixtures decode');
+
+	const signatureParent = findSignatureParent(decodedPayload);
+	if (!signatureParent) return validPayload;
+
+	if (!signatureParent.parent?.tx) return validPayload;
+	const { signature } = await createSignature(signatureParent.parent.tx);
+	if (signature?.length === signatureParent.parent.is.length) {
+		signatureParent.parent.is = signature;
+	} else {
+		signatureParent.parent.is = b4a.alloc(signatureParent.parent.is.length);
+	}
+	return safeEncodeApplyOperation(decodedPayload);
+}
+
+async function typeMismatchSignature(t, validPayload) {
+	const decodedPayload = safeDecodeApplyOperation(validPayload);
+	t.ok(decodedPayload, 'fixtures decode');
+
+	const signatureParent = findSignatureParent(decodedPayload);
+	if (!signatureParent) return validPayload;
+
+	if (!signatureParent.parent?.tx) return validPayload;
+	const { signature } = await createSignature(signatureParent.parent.tx);
+	if (signature?.length === signatureParent.parent.is.length) {
+		const mutatedSignature = Buffer.from(signature);
+		mutatedSignature[mutatedSignature.length - 1] ^= 0xff;
+		signatureParent.parent.is = mutatedSignature;
+	} else {
+		signatureParent.parent.is = Buffer.from((signatureParent.parent.is.length).toString());
+	}
+	return safeEncodeApplyOperation(decodedPayload);
+}
+
+async function mutateAmountSignature(t, validPayload) {
+	const decodedPayload = safeDecodeApplyOperation(validPayload);
+	t.ok(decodedPayload, 'fixtures decode');
+
+	const parent = findSignatureParent(decodedPayload);
+	if (!parent?.parent?.am) return validPayload;
+
+	if (!parent.parent.tx) return validPayload;
+	const { signature } = await createSignature(parent.parent.tx);
+	if (signature?.length !== parent.parent.is.length) return validPayload;
+
+	const mutatedAmount = b4a.from(parent.parent.am);
+	mutatedAmount[mutatedAmount.length - 1] ^= 0xff;
+	parent.parent.am = mutatedAmount;
+	parent.parent.is = signature;
+
+	return safeEncodeApplyOperation(decodedPayload);
+}
+
+function findSignatureParent(payload) {
+	const signatureParents = ['cao', 'bio', 'aco', 'tro', 'rao', 'bdo', 'txo'];
+	for (const key of signatureParents) {
+		const parent = payload[key];
+		if (parent?.is) {
+			return { parent, key };
+		}
+	}
+	return null;
+}
+
+async function defaultApplyInvalidPayload(context, invalidPayload) {
+	const { bootstrap } = context;
+	await bootstrap.base.append(invalidPayload);
+	await bootstrap.base.update();
+	await eventFlush();
+}