trac-msb 0.2.4 → 0.2.6

package/tests/unit/state/apply/transfer/transferContractSchemaValidationScenario.js

@@ -0,0 +1,22 @@
+import InvalidPayloadValidationScenario from '../common/payload-structure/invalidPayloadValidationScenario.js';
+import {
+	buildTransferPayload,
+	mutateTransferPayloadForInvalidSchema,
+	assertTransferFailureState,
+	setupTransferScenario,
+	applyInvalidTransferPayloadWithNoMutations
+} from './transferScenarioHelpers.js';
+
+export default function transferContractSchemaValidationScenario() {
+	new InvalidPayloadValidationScenario({
+		title: 'State.apply transfer rejects payloads when contract schema validation fails',
+		setupScenario: setupTransferScenario,
+		buildValidPayload: context => buildTransferPayload(context),
+		mutatePayload: mutateTransferPayloadForInvalidSchema,
+		applyInvalidPayload: (context, invalidPayload, t) =>
+			applyInvalidTransferPayloadWithNoMutations(t, context, invalidPayload),
+		assertStateUnchanged: (t, context, _validPayload, invalidPayload) =>
+			assertTransferFailureState(t, context, { payload: invalidPayload }),
+		expectedLogs: ['Contract schema validation failed.']
+	}).performScenario();
+}

package/tests/unit/state/apply/transfer/transferDoubleSpendAcrossValidatorsScenario.js

@@ -0,0 +1,137 @@
+import b4a from 'b4a';
+import { test } from 'brittle';
+import PartialStateMessageOperations from '../../../../../src/messages/partialStateMessages/PartialStateMessageOperations.js';
+import CompleteStateMessageOperations from '../../../../../src/messages/completeStateMessages/CompleteStateMessageOperations.js';
+import { deriveIndexerSequenceState, eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import {
+	setupTransferScenario,
+	DEFAULT_TRANSFER_AMOUNT,
+	DEFAULT_INITIAL_BALANCE
+} from './transferScenarioHelpers.js';
+import { initializeBalances, whitelistAddress } from '../common/commonScenarioHelper.js';
+import { promotePeerToWriter } from '../addWriter/addWriterScenarioHelpers.js';
+import transactionUtils from '../../../../../src/core/state/utils/transaction.js';
+import { toBalance } from '../../../../../src/core/state/utils/balance.js';
+import nodeEntryUtils from '../../../../../src/core/state/utils/nodeEntry.js';
+
+export default function transferDoubleSpendAcrossValidatorsScenario() {
+	test('State.apply transfer prevents double spend across validators (distinct tx hashes)', async t => {
+		/* Sender has only amount+fee; sends two distinct transfers (different nonces/hashes) to two recipients via two validators. First succeeds, second is skipped (insufficient balance). */
+		const amountBalance = toBalance(DEFAULT_TRANSFER_AMOUNT);
+		const feeBalance = toBalance(transactionUtils.FEE);
+		const initialSenderBalance = amountBalance && feeBalance ? amountBalance.add(feeBalance)?.value : DEFAULT_INITIAL_BALANCE;
+		t.ok(initialSenderBalance, 'initial sender balance computed');
+
+		const context = await setupTransferScenario(t, {
+			nodes: 6,
+			recipientHasEntry: false,
+			senderInitialBalance: initialSenderBalance
+		});
+
+		const nonAdmin = context.peers.slice(1);
+		const primaryValidator = context.transferScenario.validatorPeer;
+		const senderPeer = context.transferScenario.senderPeer;
+		const recipientA = context.transferScenario.recipientPeer;
+		const secondaryValidator = nonAdmin[3];
+		const recipientB = nonAdmin[4];
+		t.ok(recipientB, 'second recipient available');
+
+		// Prepare secondary validator as writer with funds.
+		await initializeBalances(context, [[secondaryValidator.wallet.address, DEFAULT_INITIAL_BALANCE]]);
+		await whitelistAddress(context, secondaryValidator.wallet.address);
+		await promotePeerToWriter(t, context, {
+			readerPeer: secondaryValidator,
+			validatorPeer: context.adminBootstrap,
+			expectedWriterIndex: 2
+		});
+		await context.sync();
+
+		const txValidityA = await deriveIndexerSequenceState(primaryValidator.base);
+		const txValidityB = await deriveIndexerSequenceState(secondaryValidator.base);
+
+		const partialA = await PartialStateMessageOperations.assembleTransferOperationMessage(
+			senderPeer.wallet,
+			recipientA.wallet.address,
+			b4a.toString(DEFAULT_TRANSFER_AMOUNT, 'hex'),
+			b4a.toString(txValidityA, 'hex')
+		);
+		const partialB = await PartialStateMessageOperations.assembleTransferOperationMessage(
+			senderPeer.wallet,
+			recipientB.wallet.address,
+			b4a.toString(DEFAULT_TRANSFER_AMOUNT, 'hex'),
+			b4a.toString(txValidityB, 'hex')
+		);
+
+		const payloadA = await CompleteStateMessageOperations.assembleCompleteTransferOperationMessage(
+			primaryValidator.wallet,
+			partialA.address,
+			b4a.from(partialA.tro.tx, 'hex'),
+			b4a.from(partialA.tro.txv, 'hex'),
+			b4a.from(partialA.tro.in, 'hex'),
+			partialA.tro.to,
+			b4a.from(partialA.tro.am, 'hex'),
+			b4a.from(partialA.tro.is, 'hex')
+		);
+
+		const payloadB = await CompleteStateMessageOperations.assembleCompleteTransferOperationMessage(
+			secondaryValidator.wallet,
+			partialB.address,
+			b4a.from(partialB.tro.tx, 'hex'),
+			b4a.from(partialB.tro.txv, 'hex'),
+			b4a.from(partialB.tro.in, 'hex'),
+			partialB.tro.to,
+			b4a.from(partialB.tro.am, 'hex'),
+			b4a.from(partialB.tro.is, 'hex')
+		);
+
+		// Apply first transfer successfully via primary validator.
+		await primaryValidator.base.append(payloadA);
+		await primaryValidator.base.update();
+		await eventFlush();
+		await context.sync();
+
+		const senderAfterFirst = await primaryValidator.base.view.get(senderPeer.wallet.address);
+		const recipientAfterFirst = await primaryValidator.base.view.get(recipientA.wallet.address);
+		const validatorAfterFirst = await primaryValidator.base.view.get(primaryValidator.wallet.address);
+
+		t.ok(senderAfterFirst?.value, 'sender entry exists after first transfer');
+		t.ok(recipientAfterFirst?.value, 'first recipient entry exists after first transfer');
+		t.ok(validatorAfterFirst?.value, 'primary validator entry exists after first transfer');
+
+		const txHashA = partialA.tro.tx.toString('hex');
+		const txEntryA = await primaryValidator.base.view.get(txHashA);
+		t.ok(txEntryA, 'first tx hash recorded');
+
+		// Attempt second transfer via secondary validator (should be ignored: insufficient balance).
+		await secondaryValidator.base.append(payloadB);
+		await secondaryValidator.base.update();
+		await eventFlush();
+		await context.sync();
+
+		const senderAfterSecond = await secondaryValidator.base.view.get(senderPeer.wallet.address);
+		const recipientBAfter = await secondaryValidator.base.view.get(recipientB.wallet.address);
+		const validatorBAfter = await secondaryValidator.base.view.get(secondaryValidator.wallet.address);
+
+		// Sender balance unchanged vs after first.
+		const senderBalanceFirst = nodeEntryUtils.decode(senderAfterFirst?.value ?? Buffer.alloc(0))?.balance;
+		const senderBalanceSecond = nodeEntryUtils.decode(senderAfterSecond?.value ?? Buffer.alloc(0))?.balance;
+		t.ok(senderBalanceFirst && senderBalanceSecond && b4a.equals(senderBalanceFirst, senderBalanceSecond), 'sender balance unchanged after second attempt');
+
+		// Recipient B did not receive funds.
+		t.ok(!recipientBAfter?.value, 'second recipient entry absent after ignored transfer');
+
+		// Secondary validator not rewarded.
+		const validatorBalanceB = nodeEntryUtils.decode(validatorBAfter?.value ?? Buffer.alloc(0))?.balance;
+		const validatorInitialB = await primaryValidator.base.view.get(secondaryValidator.wallet.address);
+		const validatorBalanceInitialB = nodeEntryUtils.decode(validatorInitialB?.value ?? Buffer.alloc(0))?.balance;
+		if (validatorBalanceB && validatorBalanceInitialB) {
+			t.ok(b4a.equals(validatorBalanceB, validatorBalanceInitialB), 'secondary validator balance unchanged');
+		}
+
+		const txHashB = partialB.tro.tx.toString('hex');
+		const txEntryB = await secondaryValidator.base.view.get(txHashB);
+		t.is(txEntryB, null, 'second tx hash not recorded after insufficient balance');
+
+		t.ok(nodeEntryUtils.decode(recipientAfterFirst?.value ?? Buffer.alloc(0)), 'recipient A decodes');
+	});
+}

package/tests/unit/state/apply/transfer/transferDoubleSpendSameBatchScenario.js

@@ -0,0 +1,63 @@
+import { test } from 'brittle';
+import {
+	setupTransferScenario,
+	buildTransferPayload,
+	assertTransferSuccessState,
+	snapshotTransferEntries,
+	DEFAULT_TRANSFER_AMOUNT,
+	DEFAULT_INITIAL_BALANCE
+} from './transferScenarioHelpers.js';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import { toBalance } from '../../../../../src/core/state/utils/balance.js';
+import transactionUtils from '../../../../../src/core/state/utils/transaction.js';
+import { safeDecodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
+
+export default function transferDoubleSpendSameBatchScenario() {
+	test('State.apply transfer prevents double spend in single batch (distinct tx hashes)', async t => {
+		/* Same validator processes two different tx hashes spending the same balance in one batch: first applies, second ignored (insufficient funds). */
+		const amountBalance = toBalance(DEFAULT_TRANSFER_AMOUNT);
+		const feeBalance = toBalance(transactionUtils.FEE);
+		const initialSenderBalance = amountBalance && feeBalance ? amountBalance.add(feeBalance)?.value : DEFAULT_INITIAL_BALANCE;
+		t.ok(initialSenderBalance, 'initial sender balance computed');
+
+		const context = await setupTransferScenario(t, {
+			nodes: 5,
+			recipientHasEntry: false,
+			senderInitialBalance: initialSenderBalance
+		});
+
+		const nonAdmin = context.peers.slice(1);
+		const { senderPeer, recipientPeer, validatorPeer } = context.transferScenario;
+		const recipientB = nonAdmin[3];
+		t.ok(recipientB, 'second recipient available');
+
+		const snapshots = await snapshotTransferEntries(context, { senderPeer, recipientPeer, validatorPeer });
+		const payloadA = await buildTransferPayload(context, { recipientPeer });
+		const payloadB = await buildTransferPayload(context, { recipientPeer: recipientB });
+
+		// Append both in a single batch.
+		await validatorPeer.base.append([payloadA, payloadB]);
+		await validatorPeer.base.update();
+		await eventFlush();
+
+		// State should match single successful application of payloadA.
+		await assertTransferSuccessState(t, context, {
+			payload: payloadA,
+			senderEntryBefore: snapshots.senderEntry,
+			recipientEntryBefore: snapshots.recipientEntry,
+			validatorEntryBefore: snapshots.validatorEntry
+		});
+
+		// Second recipient should remain untouched (no entry if it did not exist).
+		const recipientBAfter = await validatorPeer.base.view.get(recipientB.wallet.address);
+		t.is(recipientBAfter, null, 'second recipient not credited after insufficient funds');
+
+		// Second tx hash should not be recorded.
+		const decodedB = safeDecodeApplyOperation(payloadB);
+		const txHashB = decodedB?.tro?.tx?.toString('hex') ?? '';
+		if (txHashB) {
+			const txEntryB = await validatorPeer.base.view.get(txHashB);
+			t.is(txEntryB, null, 'second tx hash not recorded after insufficient funds');
+		}
+	});
+}

package/tests/unit/state/apply/transfer/transferDoubleSpendSingleValidatorScenario.js

@@ -0,0 +1,67 @@
+import { test } from 'brittle';
+import {
+	setupTransferScenario,
+	buildTransferPayload,
+	assertTransferSuccessState,
+	snapshotTransferEntries,
+	DEFAULT_TRANSFER_AMOUNT,
+	DEFAULT_INITIAL_BALANCE
+} from './transferScenarioHelpers.js';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import { toBalance } from '../../../../../src/core/state/utils/balance.js';
+import transactionUtils from '../../../../../src/core/state/utils/transaction.js';
+import { safeDecodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
+
+export default function transferDoubleSpendSingleValidatorScenario() {
+	test('State.apply transfer prevents double spend via same validator (separate appends, distinct tx hashes)', async t => {
+		/* Sender has only amount+fee; same validator processes two distinct transfers (different nonces/hashes) to two recipients. First applies, second skipped. */
+		const amountBalance = toBalance(DEFAULT_TRANSFER_AMOUNT);
+		const feeBalance = toBalance(transactionUtils.FEE);
+		const initialSenderBalance = amountBalance && feeBalance ? amountBalance.add(feeBalance)?.value : DEFAULT_INITIAL_BALANCE;
+		t.ok(initialSenderBalance, 'initial sender balance computed');
+
+		const context = await setupTransferScenario(t, {
+			nodes: 5,
+			recipientHasEntry: false,
+			senderInitialBalance: initialSenderBalance
+		});
+
+		const nonAdmin = context.peers.slice(1);
+		const { senderPeer, recipientPeer, validatorPeer } = context.transferScenario;
+		const recipientB = nonAdmin[3];
+		t.ok(recipientB, 'second recipient available');
+
+		const snapshots = await snapshotTransferEntries(context, { senderPeer, recipientPeer, validatorPeer });
+		const payloadA = await buildTransferPayload(context, { recipientPeer });
+		const payloadB = await buildTransferPayload(context, { recipientPeer: recipientB });
+
+		// First transfer
+		await validatorPeer.base.append(payloadA);
+		await validatorPeer.base.update();
+		await eventFlush();
+
+		// Second transfer (should be ignored due to insufficient balance)
+		await validatorPeer.base.append(payloadB);
+		await validatorPeer.base.update();
+		await eventFlush();
+
+		await assertTransferSuccessState(t, context, {
+			payload: payloadA,
+			senderEntryBefore: snapshots.senderEntry,
+			recipientEntryBefore: snapshots.recipientEntry,
+			validatorEntryBefore: snapshots.validatorEntry
+		});
+
+		// Second recipient should remain untouched (no entry if it did not exist).
+		const recipientBAfter = await validatorPeer.base.view.get(recipientB.wallet.address);
+		t.is(recipientBAfter, null, 'second recipient not credited after insufficient funds');
+
+		// Second tx hash should not be recorded.
+		const decodedB = safeDecodeApplyOperation(payloadB);
+		const txHashB = decodedB?.tro?.tx?.toString('hex') ?? '';
+		if (txHashB) {
+			const txEntryB = await validatorPeer.base.view.get(txHashB);
+			t.is(txEntryB, null, 'second tx hash not recorded after insufficient funds');
+		}
+	});
+}

package/tests/unit/state/apply/transfer/transferExistingRecipientAmountScenario.js

@@ -0,0 +1,31 @@
+import { test } from 'brittle';
+import {
+	setupTransferScenario,
+	buildTransferPayload,
+	assertTransferSuccessState,
+	snapshotTransferEntries,
+	DEFAULT_TRANSFER_AMOUNT
+} from './transferScenarioHelpers.js';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+
+export default function transferExistingRecipientAmountScenario() {
+	test('State.apply transfer pays existing recipient and validator (amount > 0)', async t => {
+		/* Existing recipient gains amount, sender pays amount+fee, validator earns 75% fee. */
+		const context = await setupTransferScenario(t, { recipientHasEntry: true });
+		const { senderPeer, recipientPeer, validatorPeer } = context.transferScenario;
+
+		const snapshots = await snapshotTransferEntries(context, { senderPeer, recipientPeer, validatorPeer });
+		const payload = await buildTransferPayload(context, { amount: DEFAULT_TRANSFER_AMOUNT });
+
+		await validatorPeer.base.append(payload);
+		await validatorPeer.base.update();
+		await eventFlush();
+
+		await assertTransferSuccessState(t, context, {
+			payload,
+			senderEntryBefore: snapshots.senderEntry,
+			recipientEntryBefore: snapshots.recipientEntry,
+			validatorEntryBefore: snapshots.validatorEntry
+		});
+	});
+}

package/tests/unit/state/apply/transfer/transferExistingRecipientZeroAmountScenario.js

@@ -0,0 +1,31 @@
+import { test } from 'brittle';
+import {
+	setupTransferScenario,
+	buildTransferPayload,
+	assertTransferSuccessState,
+	snapshotTransferEntries,
+	ZERO_TRANSFER_AMOUNT
+} from './transferScenarioHelpers.js';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+
+export default function transferExistingRecipientZeroAmountScenario() {
+	test('State.apply transfer charges fee when recipient exists (amount = 0)', async t => {
+		/* Sender only pays fee, recipient balance stays the same, validator earns 75% fee. */
+		const context = await setupTransferScenario(t, { recipientHasEntry: true });
+		const { senderPeer, recipientPeer, validatorPeer } = context.transferScenario;
+
+		const snapshots = await snapshotTransferEntries(context, { senderPeer, recipientPeer, validatorPeer });
+		const payload = await buildTransferPayload(context, { amount: ZERO_TRANSFER_AMOUNT });
+
+		await validatorPeer.base.append(payload);
+		await validatorPeer.base.update();
+		await eventFlush();
+
+		await assertTransferSuccessState(t, context, {
+			payload,
+			senderEntryBefore: snapshots.senderEntry,
+			recipientEntryBefore: snapshots.recipientEntry,
+			validatorEntryBefore: snapshots.validatorEntry
+		});
+	});
+}

package/tests/unit/state/apply/transfer/transferHandlerGuardScenarios.js

@@ -0,0 +1,22 @@
+import { createTransferHandlerGuardBypassScenario } from './transferScenarioHelpers.js';
+
+/**
+ * Covers handler-level guards that react to null entries returned from #transfer.
+ * These are purely handler guards, not transfer arithmetic failures.
+ */
+export default function transferHandlerGuardScenarios() {
+	createTransferHandlerGuardBypassScenario({
+		title: 'State.apply transfer rejects payloads when sender entry from transfer result is null',
+		logMessage: 'Invalid sender entry.'
+	}).performScenario();
+
+	createTransferHandlerGuardBypassScenario({
+		title: 'State.apply transfer rejects payloads when validator entry from transfer result is null',
+		logMessage: 'Invalid validator entry.'
+	}).performScenario();
+
+	createTransferHandlerGuardBypassScenario({
+		title: 'State.apply transfer rejects payloads when recipient entry from transfer result is null',
+		logMessage: 'Invalid recipient entry.'
+	}).performScenario();
+}

package/tests/unit/state/apply/transfer/transferHappyPathScenario.js

@@ -0,0 +1,8 @@
+import { test } from 'brittle';
+
+export default function transferHappyPathScenario() {
+	test('State.apply transfer moves balances - happy path (TODO)', t => {
+		t.comment('Happy path scenario not implemented yet.');
+		t.pass('placeholder');
+	});
+}

package/tests/unit/state/apply/transfer/transferInvalidIncomingDataScenario.js

@@ -0,0 +1,66 @@
+import b4a from 'b4a';
+import { test } from 'brittle';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import { safeDecodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
+import {
+	setupTransferScenario,
+	buildTransferPayload,
+	snapshotTransferEntries,
+	assertTransferFailureState
+} from './transferScenarioHelpers.js';
+
+export default function transferInvalidIncomingDataScenario() {
+	test('State.apply transfer rejects when incoming data is missing', async t => {
+		const context = await setupTransferScenario(t);
+		const { senderPeer, recipientPeer, validatorPeer } = context.transferScenario;
+
+		const snapshots = await snapshotTransferEntries(context, {
+			senderPeer,
+			recipientPeer,
+			validatorPeer
+		});
+
+		const payload = await buildTransferPayload(context);
+		const decoded = safeDecodeApplyOperation(payload);
+		t.ok(decoded?.address && decoded?.tro?.to, 'transfer payload decodes');
+
+		const requesterAddressBuffer = decoded.address;
+		const recipientAddressBuffer = decoded.tro.to;
+
+		const originalEquals = b4a.equals;
+		const originalConsoleError = console.error;
+		const capturedLogs = [];
+
+		console.error = (...args) => {
+			capturedLogs.push(args);
+			originalConsoleError(...args);
+		};
+
+		b4a.equals = (a, b) => {
+			if (originalEquals(a, requesterAddressBuffer) && originalEquals(b, recipientAddressBuffer)) {
+				return undefined;
+			}
+			return originalEquals(a, b);
+		};
+
+		try {
+			await validatorPeer.base.append(payload);
+			await validatorPeer.base.update();
+			await eventFlush();
+		} finally {
+			b4a.equals = originalEquals;
+			console.error = originalConsoleError;
+		}
+
+	await assertTransferFailureState(t, context, {
+				payload,
+				senderEntryBefore: snapshots.senderEntry,
+				recipientEntryBefore: snapshots.recipientEntry
+			});
+
+		const expectedLog = capturedLogs.some(args =>
+			args.some(arg => typeof arg === 'string' && arg.includes('Invalid transfer incoming data.'))
+		);
+		t.ok(expectedLog, 'expected apply log was emitted');
+	});
+}

package/tests/unit/state/apply/transfer/transferNewRecipientAmountScenario.js

@@ -0,0 +1,31 @@
+import { test } from 'brittle';
+import {
+	setupTransferScenario,
+	buildTransferPayload,
+	assertTransferSuccessState,
+	snapshotTransferEntries,
+	DEFAULT_TRANSFER_AMOUNT
+} from './transferScenarioHelpers.js';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+
+export default function transferNewRecipientAmountScenario() {
+	test('State.apply transfer creates recipient entry when missing (amount > 0)', async t => {
+		/* Missing recipient gets new reader entry with amount, sender pays amount+fee, validator earns 75% fee. */
+		const context = await setupTransferScenario(t, { recipientHasEntry: false });
+		const { senderPeer, recipientPeer, validatorPeer } = context.transferScenario;
+
+		const snapshots = await snapshotTransferEntries(context, { senderPeer, recipientPeer, validatorPeer });
+		const payload = await buildTransferPayload(context, { amount: DEFAULT_TRANSFER_AMOUNT });
+
+		await validatorPeer.base.append(payload);
+		await validatorPeer.base.update();
+		await eventFlush();
+
+		await assertTransferSuccessState(t, context, {
+			payload,
+			senderEntryBefore: snapshots.senderEntry,
+			recipientEntryBefore: snapshots.recipientEntry,
+			validatorEntryBefore: snapshots.validatorEntry
+		});
+	});
+}

package/tests/unit/state/apply/transfer/transferNewRecipientZeroAmountScenario.js

@@ -0,0 +1,31 @@
+import { test } from 'brittle';
+import {
+	setupTransferScenario,
+	buildTransferPayload,
+	assertTransferSuccessState,
+	snapshotTransferEntries,
+	ZERO_TRANSFER_AMOUNT
+} from './transferScenarioHelpers.js';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+
+export default function transferNewRecipientZeroAmountScenario() {
+	test('State.apply transfer initializes missing recipient with zero balance (amount = 0)', async t => {
+		/* Missing recipient gets zeroed reader entry, sender pays fee, validator earns 75% fee. */
+		const context = await setupTransferScenario(t, { recipientHasEntry: false });
+		const { senderPeer, recipientPeer, validatorPeer } = context.transferScenario;
+
+		const snapshots = await snapshotTransferEntries(context, { senderPeer, recipientPeer, validatorPeer });
+		const payload = await buildTransferPayload(context, { amount: ZERO_TRANSFER_AMOUNT });
+
+		await validatorPeer.base.append(payload);
+		await validatorPeer.base.update();
+		await eventFlush();
+
+		await assertTransferSuccessState(t, context, {
+			payload,
+			senderEntryBefore: snapshots.senderEntry,
+			recipientEntryBefore: snapshots.recipientEntry,
+			validatorEntryBefore: snapshots.validatorEntry
+		});
+	});
+}