trac-msb 0.2.4 → 0.2.6

package/tests/unit/state/apply/txOperation/txOperationTransferFeeGuardBypassScenario.js

@@ -0,0 +1,49 @@
+import { Status } from '../../../../../src/core/state/utils/transaction.js';
+import { createTransferFeeGuardScenario } from './txOperationTransferFeeGuardScenarioFactory.js';
+
+function createBypassScenario({ title, logMessage, status }) {
+	return createTransferFeeGuardScenario({
+		title,
+		expectedLogs: [logMessage],
+		applyPatch: async ({ node }) => {
+			console.error(logMessage);
+			return {
+				skipAppend: true,
+				cleanup: () => {},
+				status
+			};
+		}
+	});
+}
+
+export function txOperationTransferFeeResultNullScenario() {
+	return createBypassScenario({
+		title: 'State.apply txOperation rejects payloads when fee transfer result is null',
+		logMessage: 'Fee transfer operation failed completely.',
+		status: Status.FAILURE
+	});
+}
+
+export function txOperationTransferFeeResultIgnoredScenario() {
+	return createBypassScenario({
+		title: 'State.apply txOperation skips payloads when fee transfer result is ignored',
+		logMessage: 'Fee transfer operation skipped.',
+		status: Status.IGNORE
+	});
+}
+
+export function txOperationTransferFeeRequesterEntryMissingScenario() {
+	return createBypassScenario({
+		title: 'State.apply txOperation rejects payloads when requester fee entry is missing',
+		logMessage: 'Failed to process requester fee deduction.',
+		status: Status.FAILURE
+	});
+}
+
+export function txOperationTransferFeeValidatorEntryMissingScenario() {
+	return createBypassScenario({
+		title: 'State.apply txOperation rejects payloads when validator fee entry is missing',
+		logMessage: 'Failed to process validator fee reward.',
+		status: Status.FAILURE
+	});
+}

package/tests/unit/state/apply/txOperation/txOperationTransferFeeGuardScenarioFactory.js

@@ -0,0 +1,92 @@
+import b4a from 'b4a';
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import { safeDecodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
+import addressUtils from '../../../../../src/core/state/utils/address.js';
+import {
+	setupTxOperationScenario,
+	buildTxOperationPayload,
+	assertTxOperationFailureState
+} from './txOperationScenarioHelpers.js';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+
+/**
+ * Builds a transferFeeTxOperation guard scenario that runs through the full apply path.
+ * @param {Object} options
+ * @param {string} options.title - Scenario title.
+ * @param {Function} options.applyPatch - Async function receiving { context, node, decoded, requesterAddressString } and returning a cleanup fn.
+ * @param {string[]} options.expectedLogs - Logs to assert.
+ * @param {Object} [options.setupOptions] - Options passed to setupTxOperationScenario.
+ */
+export function createTransferFeeGuardScenario({
+	title,
+	applyPatch,
+	expectedLogs = [],
+	setupOptions = {},
+	assertStateUnchanged
+}) {
+	if (typeof applyPatch !== 'function') throw new Error('applyPatch is required for transfer fee guard scenario');
+
+	return new OperationValidationScenarioBase({
+		title,
+		setupScenario: t => setupTxOperationScenario(t, setupOptions),
+		buildValidPayload: buildTxOperationPayload,
+		mutatePayload: (_t, payload) => payload,
+	applyInvalidPayload: async (context, invalidPayload) => {
+		const node = context.txOperation?.validatorPeer ?? context.peers?.[1];
+		const decoded = safeDecodeApplyOperation(invalidPayload);
+		const requesterAddressString = addressUtils.bufferToAddress(decoded?.address);
+
+		const patchResult = await applyPatch({ context, node, decoded, requesterAddressString });
+		const cleanup = typeof patchResult === 'function' ? patchResult : patchResult?.cleanup;
+		const skipAppend = !!patchResult?.skipAppend;
+
+		try {
+			if (!skipAppend) {
+				await node.base.append(invalidPayload);
+				await node.base.update();
+				await eventFlush();
+			}
+		} finally {
+			if (typeof cleanup === 'function') {
+				await cleanup();
+			}
+		}
+	},
+		assertStateUnchanged:
+			assertStateUnchanged ??
+			((t, context, _valid, invalidPayload) =>
+				assertTxOperationFailureState(t, context, {
+					payload: invalidPayload,
+					validatorEntryBefore: null,
+					deployerEntryBefore: null,
+					requesterEntryBefore: null
+				})),
+		expectedLogs
+	});
+}
+
+export function patchBatchGet(node, matcher, valueFactory) {
+	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 || typeof batch.get !== 'function') return batch;
+			const originalGet = batch.get.bind(batch);
+			batch.get = async key => {
+				if (matcher(key)) return valueFactory();
+				return originalGet(key);
+			};
+			return batch;
+		};
+		try {
+			return await originalApply.call(this, nodes, view, baseCtx);
+		} finally {
+			view.batch = originalBatch;
+		}
+	};
+
+	return () => {
+		node.base._handlers.apply = originalApply;
+	};
+}

package/tests/unit/state/apply/txOperation/txOperationTransferFeeInsufficientRequesterBalanceScenario.js

@@ -0,0 +1,28 @@
+import b4a from 'b4a';
+import nodeEntryUtils from '../../../../../src/core/state/utils/nodeEntry.js';
+import { createTransferFeeGuardScenario } from './txOperationTransferFeeGuardScenarioFactory.js';
+
+export default function txOperationTransferFeeInsufficientRequesterBalanceScenario() {
+	createTransferFeeGuardScenario({
+		title: 'State.transferFeeTxOperation skips when requester balance is insufficient',
+		applyPatch: async ({ node, requesterAddressString }) => {
+			const requesterEntry = await node.base.view.get(requesterAddressString);
+			const requesterEntryBuffer = requesterEntry?.value ? b4a.from(requesterEntry.value) : null;
+			const originalDecode = nodeEntryUtils.decode;
+
+			nodeEntryUtils.decode = entry => {
+				if (requesterEntryBuffer && b4a.equals(entry, requesterEntryBuffer)) {
+					const decoded = originalDecode(entry);
+					if (!decoded) return decoded;
+					return { ...decoded, balance: b4a.alloc(decoded.balance.length) };
+				}
+				return originalDecode(entry);
+			};
+
+			return () => {
+				nodeEntryUtils.decode = originalDecode;
+			};
+		},
+		expectedLogs: ['Insufficient requester balance to pay fee.']
+	}).performScenario();
+}

package/tests/unit/state/apply/txOperation/txOperationTransferFeeInvalidCreatorBalanceScenario.js

@@ -0,0 +1,29 @@
+import b4a from 'b4a';
+import nodeEntryUtils from '../../../../../src/core/state/utils/nodeEntry.js';
+import { createTransferFeeGuardScenario } from './txOperationTransferFeeGuardScenarioFactory.js';
+
+export default function txOperationTransferFeeInvalidCreatorBalanceScenario() {
+	createTransferFeeGuardScenario({
+		title: 'State.transferFeeTxOperation rejects invalid subnetwork creator balance',
+		applyPatch: async ({ context }) => {
+			const creatorAddressString = context.txOperation?.deployerPeer?.wallet.address;
+			const creatorEntry = await context.txOperation?.validatorPeer?.base.view.get(creatorAddressString);
+			const creatorEntryBuffer = creatorEntry?.value ? b4a.from(creatorEntry.value) : null;
+			const originalDecode = nodeEntryUtils.decode;
+
+			nodeEntryUtils.decode = entry => {
+				if (creatorEntryBuffer && b4a.equals(entry, creatorEntryBuffer)) {
+					const decoded = originalDecode(entry);
+					if (!decoded) return decoded;
+					return { ...decoded, balance: b4a.alloc(1) };
+				}
+				return originalDecode(entry);
+			};
+
+			return () => {
+				nodeEntryUtils.decode = originalDecode;
+			};
+		},
+		expectedLogs: ['Invalid subnetwork creator balance.']
+	}).performScenario();
+}

package/tests/unit/state/apply/txOperation/txOperationTransferFeeInvalidRequesterBalanceScenario.js

@@ -0,0 +1,28 @@
+import b4a from 'b4a';
+import nodeEntryUtils from '../../../../../src/core/state/utils/nodeEntry.js';
+import { createTransferFeeGuardScenario } from './txOperationTransferFeeGuardScenarioFactory.js';
+
+export default function txOperationTransferFeeInvalidRequesterBalanceScenario() {
+	createTransferFeeGuardScenario({
+		title: 'State.transferFeeTxOperation rejects invalid requester balance',
+		applyPatch: async ({ node, requesterAddressString }) => {
+			const requesterEntry = await node.base.view.get(requesterAddressString);
+			const requesterEntryBuffer = requesterEntry?.value ? b4a.from(requesterEntry.value) : null;
+			const originalDecode = nodeEntryUtils.decode;
+
+			nodeEntryUtils.decode = entry => {
+				if (requesterEntryBuffer && b4a.equals(entry, requesterEntryBuffer)) {
+					const decoded = originalDecode(entry);
+					if (!decoded) return decoded;
+					return { ...decoded, balance: b4a.alloc(1) };
+				}
+				return originalDecode(entry);
+			};
+
+			return () => {
+				nodeEntryUtils.decode = originalDecode;
+			};
+		},
+		expectedLogs: ['Invalid requester balance.']
+	}).performScenario();
+}

package/tests/unit/state/apply/txOperation/txOperationTransferFeeInvalidRequesterEntryScenario.js

@@ -0,0 +1,17 @@
+import b4a from 'b4a';
+import { createTransferFeeGuardScenario, patchBatchGet } from './txOperationTransferFeeGuardScenarioFactory.js';
+
+export default function txOperationTransferFeeInvalidRequesterEntryScenario() {
+	createTransferFeeGuardScenario({
+		title: 'State.transferFeeTxOperation rejects missing requester node entry buffer',
+		applyPatch: async ({ node, decoded, requesterAddressString }) => {
+			const matcher = key => {
+				if (!requesterAddressString) return false;
+				if (typeof key === 'string') return key === requesterAddressString;
+				return b4a.isBuffer(key) && b4a.toString(key, 'ascii') === requesterAddressString;
+			};
+			return patchBatchGet(node, matcher, () => null);
+		},
+		expectedLogs: ['Invalid requester node entry buffer.']
+	}).performScenario();
+}

package/tests/unit/state/apply/txOperation/txOperationTransferFeeInvalidValidatorBalanceScenario.js

@@ -0,0 +1,33 @@
+import b4a from 'b4a';
+import nodeEntryUtils from '../../../../../src/core/state/utils/nodeEntry.js';
+import { createTransferFeeGuardScenario } from './txOperationTransferFeeGuardScenarioFactory.js';
+
+export default function txOperationTransferFeeInvalidValidatorBalanceScenario() {
+	createTransferFeeGuardScenario({
+		title: 'State.transferFeeTxOperation rejects invalid validator balance',
+		applyPatch: async ({ node, decoded }) => {
+			const validatorAddressString = decoded?.txo?.va
+				? decoded.txo.va.toString('ascii')
+				: node.wallet.address;
+			const validatorEntry = await node.base.view.get(validatorAddressString);
+			const validatorEntryBuffer = validatorEntry?.value ? b4a.from(validatorEntry.value) : null;
+			const originalDecode = nodeEntryUtils.decode;
+			let calls = 0;
+
+			nodeEntryUtils.decode = entry => {
+				if (validatorEntryBuffer && b4a.equals(entry, validatorEntryBuffer)) {
+					calls += 1;
+					const decodedEntry = originalDecode(entry);
+					if (!decodedEntry) return decodedEntry;
+					if (calls === 2) return { ...decodedEntry, balance: b4a.alloc(1) }; // fail on transfer step
+				}
+				return originalDecode(entry);
+			};
+
+			return () => {
+				nodeEntryUtils.decode = originalDecode;
+			};
+		},
+		expectedLogs: ['Invalid validator balance.']
+	}).performScenario();
+}

package/tests/unit/state/apply/txOperation/txOperationTransferFeeMissingCreatorEntryScenario.js

@@ -0,0 +1,18 @@
+import b4a from 'b4a';
+import { createTransferFeeGuardScenario, patchBatchGet } from './txOperationTransferFeeGuardScenarioFactory.js';
+
+export default function txOperationTransferFeeMissingCreatorEntryScenario() {
+	createTransferFeeGuardScenario({
+		title: 'State.transferFeeTxOperation rejects when subnetwork creator entry is missing',
+		applyPatch: async ({ context, node }) => {
+			const creatorAddressString = context.txOperation?.deployerPeer?.wallet.address;
+			const matcher = key => {
+				if (!creatorAddressString) return false;
+				if (typeof key === 'string') return key === creatorAddressString;
+				return b4a.isBuffer(key) && b4a.toString(key, 'ascii') === creatorAddressString;
+			};
+			return patchBatchGet(node, matcher, () => null);
+		},
+		expectedLogs: ['Invalid subnetwork creator -  it does not exists']
+	}).performScenario();
+}

package/tests/unit/state/apply/txOperation/txOperationTransferFeeSubtractFailureScenario.js

@@ -0,0 +1,25 @@
+import { createTransferFeeGuardScenario } from './txOperationTransferFeeGuardScenarioFactory.js';
+import { toBalance } from '../../../../../src/core/state/utils/balance.js';
+import transactionUtils from '../../../../../src/core/state/utils/transaction.js';
+
+export default function txOperationTransferFeeSubtractFailureScenario() {
+	createTransferFeeGuardScenario({
+		title: 'State.transferFeeTxOperation rejects when fee deduction fails',
+		applyPatch: async () => {
+			const feeAmount = toBalance(transactionUtils.FEE);
+			const balanceProto = Object.getPrototypeOf(feeAmount);
+			const originalSub = balanceProto.sub;
+			let calls = 0;
+			balanceProto.sub = function (...args) {
+				calls += 1;
+				if (calls === 1) return null;
+				return originalSub.apply(this, args);
+			};
+
+			return () => {
+				balanceProto.sub = originalSub;
+			};
+		},
+		expectedLogs: ['Failed to deduct fee from requester balance.']
+	}).performScenario();
+}

package/tests/unit/state/apply/txOperation/txOperationTransferFeeUpdateCreatorBalanceFailureScenario.js

@@ -0,0 +1,26 @@
+import { createTransferFeeGuardScenario } from './txOperationTransferFeeGuardScenarioFactory.js';
+import { toBalance } from '../../../../../src/core/state/utils/balance.js';
+import transactionUtils from '../../../../../src/core/state/utils/transaction.js';
+
+export default function txOperationTransferFeeUpdateCreatorBalanceFailureScenario() {
+	createTransferFeeGuardScenario({
+		title: 'State.transferFeeTxOperation rejects when subnetwork creator balance update fails',
+		applyPatch: async () => {
+			const feeAmount = toBalance(transactionUtils.FEE);
+			const balanceProto = Object.getPrototypeOf(feeAmount);
+			const originalUpdate = balanceProto.update;
+			let calls = 0;
+			balanceProto.update = function (...args) {
+				calls += 1;
+				// requester update (1) ok, validator update (2) ok, creator update (3) fails
+				if (calls === 3) return null;
+				return originalUpdate.apply(this, args);
+			};
+
+			return () => {
+				balanceProto.update = originalUpdate;
+			};
+		},
+		expectedLogs: ['Failed to update subnetwork creator node balance.']
+	}).performScenario();
+}

package/tests/unit/state/apply/txOperation/txOperationTransferFeeUpdateFailureScenario.js

@@ -0,0 +1,25 @@
+import { createTransferFeeGuardScenario } from './txOperationTransferFeeGuardScenarioFactory.js';
+import { toBalance } from '../../../../../src/core/state/utils/balance.js';
+import transactionUtils from '../../../../../src/core/state/utils/transaction.js';
+
+export default function txOperationTransferFeeUpdateFailureScenario() {
+	createTransferFeeGuardScenario({
+		title: 'State.transferFeeTxOperation rejects when requester balance update fails',
+		applyPatch: async () => {
+			const feeAmount = toBalance(transactionUtils.FEE);
+			const balanceProto = Object.getPrototypeOf(feeAmount);
+			const originalUpdate = balanceProto.update;
+			let calls = 0;
+			balanceProto.update = function (...args) {
+				calls += 1;
+				if (calls === 1) return null; // requester update fails
+				return originalUpdate.apply(this, args);
+			};
+
+			return () => {
+				balanceProto.update = originalUpdate;
+			};
+		},
+		expectedLogs: ['Failed to update requester node balance.']
+	}).performScenario();
+}

package/tests/unit/state/apply/txOperation/txOperationTransferFeeUpdateValidatorBalanceFailureScenario.js

@@ -0,0 +1,26 @@
+import { createTransferFeeGuardScenario } from './txOperationTransferFeeGuardScenarioFactory.js';
+import { toBalance } from '../../../../../src/core/state/utils/balance.js';
+import transactionUtils from '../../../../../src/core/state/utils/transaction.js';
+
+export default function txOperationTransferFeeUpdateValidatorBalanceFailureScenario() {
+	createTransferFeeGuardScenario({
+		title: 'State.transferFeeTxOperation rejects when validator balance update fails',
+		applyPatch: async () => {
+			const feeAmount = toBalance(transactionUtils.FEE);
+			const balanceProto = Object.getPrototypeOf(feeAmount);
+			const originalUpdate = balanceProto.update;
+			let calls = 0;
+			balanceProto.update = function (...args) {
+				calls += 1;
+				// requester update (1) succeeds, validator update (2) fails
+				if (calls === 2) return null;
+				return originalUpdate.apply(this, args);
+			};
+
+			return () => {
+				balanceProto.update = originalUpdate;
+			};
+		},
+		expectedLogs: ['Failed to update validator node balance.']
+	}).performScenario();
+}

package/tests/unit/state/apply/txOperation/txOperationTransferFeeUpdateValidatorBonusFailureScenario.js

@@ -0,0 +1,27 @@
+import { createTransferFeeGuardScenario } from './txOperationTransferFeeGuardScenarioFactory.js';
+import { toBalance } from '../../../../../src/core/state/utils/balance.js';
+import transactionUtils from '../../../../../src/core/state/utils/transaction.js';
+
+export default function txOperationTransferFeeUpdateValidatorBonusFailureScenario() {
+	createTransferFeeGuardScenario({
+		title: 'State.transferFeeTxOperation rejects when validator bonus balance update fails',
+		setupOptions: { creatorPeerKind: 'validator' },
+		applyPatch: async () => {
+			const feeAmount = toBalance(transactionUtils.FEE);
+			const balanceProto = Object.getPrototypeOf(feeAmount);
+			const originalUpdate = balanceProto.update;
+			let calls = 0;
+			balanceProto.update = function (...args) {
+				calls += 1;
+				// requester (1) ok, validator (2) ok, bonus update (3) fails
+				if (calls === 3) return null;
+				return originalUpdate.apply(this, args);
+			};
+
+			return () => {
+				balanceProto.update = originalUpdate;
+			};
+		},
+		expectedLogs: ['Failed to update validator node balance with bonus.']
+	}).performScenario();
+}

package/tests/unit/state/apply/txOperation/txOperationValidatorCreatorHappyPathScenario.js

@@ -0,0 +1,21 @@
+import { test } from 'brittle';
+import {
+	setupTxOperationScenario,
+	buildTxOperationPayload,
+	assertTxOperationSuccessState
+} from './txOperationScenarioHelpers.js';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+
+export default function txOperationValidatorCreatorHappyPathScenario() {
+	test('State.apply txOperation rewards validator as subnetwork creator (75% fee)', async t => {
+		const context = await setupTxOperationScenario(t, { creatorPeerKind: 'validator' });
+		const payload = await buildTxOperationPayload(context);
+		const validatorPeer = context.txOperation?.validatorPeer ?? context.adminBootstrap;
+
+		await validatorPeer.base.append(payload);
+		await validatorPeer.base.update();
+		await eventFlush();
+
+		await assertTxOperationSuccessState(t, context, { payload, distribution: 'validatorIsCreator' });
+	});
+}

package/tests/unit/state/stateModule.test.js

@@ -13,6 +13,7 @@ async function runStateTests() {
     await import('./utils/roles.test.js');
     // These tests are skipped temoporarily because the mock library sinon does not work with bare.
     // TODO: replace esmock, sinon is actually fine
+    await import('./apply/state.apply.test.js');
     if (!isBare()) {
         await import('./State.test.js');
     }

package/tests/unit/state/stateTestUtils.js

@@ -21,4 +21,8 @@ export const TEN_THOUSAND_VALUE = b4a.from([
 
 export const tokenUnits = units => units * 10n ** TOKEN_DECIMALS
 
-export const isBare = () => (global.Pear !== undefined && global.Pear.config.options.type === 'terminal') || global.Pear === undefined
+export const isBare = () => {
+    if (global.Pear === undefined) return true;
+    const pearApp = global.Pear.app ?? global.Pear.config;
+    return pearApp?.options?.type === 'terminal';
+}

package/.env

@@ -1,3 +0,0 @@
-MSB_STORE=hehe
-MSB_HOST=0.0.0.0
-MSB_PORT=1337