trac-msb 0.2.13 → 0.2.15

package/tests/unit/network/v1/V1BaseOperation.test.js

@@ -1,356 +0,0 @@
-import test from 'brittle';
-import b4a from 'b4a';
-import PeerWallet from 'trac-wallet';
-
-import V1BaseOperation from '../../../../src/core/network/protocols/v1/validators/V1BaseOperation.js';
-import NetworkWalletFactory from '../../../../src/core/network/identity/NetworkWalletFactory.js';
-import NetworkMessageBuilder from '../../../../src/messages/network/v1/NetworkMessageBuilder.js';
-import {
-    V1InvalidPayloadError,
-    V1SignatureInvalidError,
-    V1UnexpectedError
-} from '../../../../src/core/network/protocols/v1/V1ProtocolError.js';
-import {
-    NetworkOperationType,
-    ResultCode
-} from '../../../../src/utils/constants.js';
-import { testKeyPair1, testKeyPair2 } from '../../../fixtures/apply.fixtures.js';
-import { config } from '../../../helpers/config.js';
-import { errorMessageIncludes } from '../../../helpers/regexHelper.js';
-
-const createWallet = (fixture = testKeyPair1) => {
-    const keyPair = {
-        publicKey: b4a.from(fixture.publicKey, 'hex'),
-        secretKey: b4a.from(fixture.secretKey, 'hex'),
-    };
-
-    return NetworkWalletFactory.provide({
-        enableWallet: false,
-        keyPair,
-        networkPrefix: config.addressPrefix,
-    });
-};
-
-const buildSignedPayload = async (wallet, type, options = {}) => {
-    const builder = new NetworkMessageBuilder(wallet, config)
-        .setType(type)
-        .setId(`id-${type}-${Date.now()}-${Math.random()}`)
-        .setTimestamp()
-        .setCapabilities(['cap:a']);
-
-    switch (type) {
-        case NetworkOperationType.LIVENESS_REQUEST:
-            break;
-        case NetworkOperationType.LIVENESS_RESPONSE:
-            builder.setResultCode(options.resultCode ?? ResultCode.OK);
-            break;
-        case NetworkOperationType.BROADCAST_TRANSACTION_REQUEST:
-            builder.setData(options.data ?? b4a.from('abcd', 'hex'));
-            break;
-        case NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE:
-            builder
-                .setResultCode(options.resultCode ?? ResultCode.OK)
-                .setProof(options.proof ?? b4a.from('deadbeef', 'hex'))
-                .setTimestampLedger(options.timestamp ?? Date.now());
-            break;
-        default:
-            throw new Error(`Unsupported type in test helper: ${type}`);
-    }
-
-    await builder.buildPayload();
-    return builder.getResult();
-};
-
-test('V1BaseOperation.validate throws "must be implemented" by default', async t => {
-    const operation = new V1BaseOperation(config);
-
-    await t.exception(
-        async () => operation.validate({}, {}, {}),
-        errorMessageIncludes('must be implemented')
-    );
-});
-
-test('V1BaseOperation.isPayloadSchemaValid handles missing/invalid type cases', async t => {
-    const operation = new V1BaseOperation(config);
-
-    t.exception(
-        () => operation.isPayloadSchemaValid(null),
-        errorMessageIncludes('Payload or payload type is missing')
-    );
-
-    t.exception(
-        () => operation.isPayloadSchemaValid({ type: null }),
-        errorMessageIncludes('Payload or payload type is missing')
-    );
-
-    t.exception(
-        () => operation.isPayloadSchemaValid({ type: 1.5 }),
-        errorMessageIncludes('Operation type must be an integer')
-    );
-
-    t.exception(
-        () => operation.isPayloadSchemaValid({ type: 0 }),
-        errorMessageIncludes('Operation type is unspecified')
-    );
-
-    t.exception(
-        () => operation.isPayloadSchemaValid({ type: 9999 }),
-        errorMessageIncludes('Unknown operation type')
-    );
-});
-
-test('V1BaseOperation.isPayloadSchemaValid accepts all supported message schemas', async t => {
-    const operation = new V1BaseOperation(config);
-    const wallet = createWallet();
-
-    const payloads = [
-        await buildSignedPayload(wallet, NetworkOperationType.LIVENESS_REQUEST),
-        await buildSignedPayload(wallet, NetworkOperationType.LIVENESS_RESPONSE),
-        await buildSignedPayload(wallet, NetworkOperationType.BROADCAST_TRANSACTION_REQUEST),
-        await buildSignedPayload(wallet, NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE),
-    ];
-
-    for (const payload of payloads) {
-        operation.isPayloadSchemaValid(payload);
-    }
-
-    t.pass();
-});
-
-test('V1BaseOperation.validateSignature verifies valid signatures for all supported message types', async t => {
-    const operation = new V1BaseOperation(config);
-    const wallet = createWallet();
-
-    const payloads = [
-        await buildSignedPayload(wallet, NetworkOperationType.LIVENESS_REQUEST),
-        await buildSignedPayload(wallet, NetworkOperationType.LIVENESS_RESPONSE),
-        await buildSignedPayload(wallet, NetworkOperationType.BROADCAST_TRANSACTION_REQUEST),
-        await buildSignedPayload(wallet, NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE),
-    ];
-
-    for (const payload of payloads) {
-        await operation.validateSignature(payload, wallet.publicKey);
-    }
-
-    t.pass();
-});
-
-test('V1BaseOperation.validateSignature throws V1SignatureInvalidError on wrong public key', async t => {
-    const operation = new V1BaseOperation(config);
-    const wallet = createWallet(testKeyPair1);
-    const otherWallet = createWallet(testKeyPair2);
-
-    const payload = await buildSignedPayload(wallet, NetworkOperationType.LIVENESS_REQUEST);
-
-    await t.exception(
-        async () => operation.validateSignature(payload, otherWallet.publicKey),
-        errorMessageIncludes('signature verification failed')
-    );
-});
-
-test('V1BaseOperation.validateSignature rethrows protocol-shaped build errors', async t => {
-    const operation = new V1BaseOperation(config);
-
-    const payload = {
-        type: 0,
-        id: 'id',
-        timestamp: Date.now(),
-        capabilities: [],
-    };
-
-    try {
-        await operation.validateSignature(payload, b4a.alloc(32, 1));
-        t.fail('expected validateSignature to throw');
-    } catch (error) {
-        t.ok(error instanceof V1InvalidPayloadError);
-        t.is(error.resultCode, ResultCode.INVALID_PAYLOAD);
-        t.ok(error.message.includes('Operation type is unspecified'));
-    }
-});
-
-test('V1BaseOperation.validateSignature wraps non-protocol build errors as V1InvalidPayloadError', async t => {
-    const operation = new V1BaseOperation(config);
-
-    const payload = {
-        type: NetworkOperationType.LIVENESS_REQUEST,
-        id: 'id',
-        timestamp: Date.now(),
-        capabilities: [],
-    };
-
-    try {
-        await operation.validateSignature(payload, b4a.alloc(32, 1));
-        t.fail('expected validateSignature to throw');
-    } catch (error) {
-        t.ok(error instanceof V1InvalidPayloadError);
-        t.is(error.resultCode, ResultCode.INVALID_PAYLOAD);
-        t.ok(error.message.includes('Failed to build signature message'));
-    }
-});
-
-test('V1BaseOperation.validateSignature throws V1InvalidPayloadError when hashing fails', async t => {
-    const operation = new V1BaseOperation(config);
-    const wallet = createWallet();
-    const payload = await buildSignedPayload(wallet, NetworkOperationType.LIVENESS_REQUEST);
-
-    const originalBlake3 = PeerWallet.blake3;
-    PeerWallet.blake3 = async () => {
-        throw new Error('hash fail');
-    };
-
-    t.teardown(() => {
-        PeerWallet.blake3 = originalBlake3;
-    });
-
-    try {
-        await operation.validateSignature(payload, wallet.publicKey);
-        t.fail('expected validateSignature to throw');
-    } catch (error) {
-        t.ok(error instanceof V1InvalidPayloadError);
-        t.ok(error.message.includes('Failed to hash signature message'));
-    }
-});
-
-test('V1BaseOperation.validateSignature handles verify() throw as invalid signature', async t => {
-    const operation = new V1BaseOperation(config);
-    const wallet = createWallet();
-    const payload = await buildSignedPayload(wallet, NetworkOperationType.LIVENESS_REQUEST);
-
-    const originalVerify = PeerWallet.verify;
-    PeerWallet.verify = () => {
-        throw new Error('verify fail');
-    };
-
-    t.teardown(() => {
-        PeerWallet.verify = originalVerify;
-    });
-
-    try {
-        await operation.validateSignature(payload, wallet.publicKey);
-        t.fail('expected validateSignature to throw');
-    } catch (error) {
-        t.ok(error instanceof V1SignatureInvalidError);
-        t.is(error.resultCode, ResultCode.SIGNATURE_INVALID);
-    }
-});
-
-test('V1BaseOperation.validateSignature enforces BROADCAST_TRANSACTION_RESPONSE proof/timestamp invariants', async t => {
-    const operation = new V1BaseOperation(config);
-    const wallet = createWallet();
-
-    const validBase = await buildSignedPayload(wallet, NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE);
-
-    const cases = [
-        {
-            mutate: payload => {
-                payload.broadcast_transaction_response.result = ResultCode.OK;
-                payload.broadcast_transaction_response.proof = b4a.alloc(0);
-            },
-            match: 'Result code OK requires non-empty proof'
-        },
-        {
-            mutate: payload => {
-                payload.broadcast_transaction_response.result = ResultCode.TX_ACCEPTED_PROOF_UNAVAILABLE;
-                payload.broadcast_transaction_response.proof = b4a.from('aa', 'hex');
-            },
-            match: 'TX_ACCEPTED_PROOF_UNAVAILABLE requires empty proof'
-        },
-        {
-            mutate: payload => {
-                payload.broadcast_transaction_response.result = ResultCode.TX_ACCEPTED_PROOF_UNAVAILABLE;
-                payload.broadcast_transaction_response.proof = b4a.alloc(0);
-                payload.broadcast_transaction_response.timestamp = 0;
-            },
-            match: 'TX_ACCEPTED_PROOF_UNAVAILABLE requires timestamp > 0'
-        },
-        {
-            mutate: payload => {
-                payload.broadcast_transaction_response.result = ResultCode.TIMEOUT;
-                payload.broadcast_transaction_response.proof = b4a.from('aa', 'hex');
-                payload.broadcast_transaction_response.timestamp = 0;
-            },
-            match: 'Non-OK result code requires empty proof'
-        },
-        {
-            mutate: payload => {
-                payload.broadcast_transaction_response.result = ResultCode.TIMEOUT;
-                payload.broadcast_transaction_response.proof = b4a.alloc(0);
-                payload.broadcast_transaction_response.timestamp = Date.now();
-            },
-            match: 'Non-OK result code requires timestamp to be 0'
-        },
-    ];
-
-    for (const scenario of cases) {
-        const payload = structuredClone(validBase);
-        scenario.mutate(payload);
-
-        await t.exception(
-            async () => operation.validateSignature(payload, wallet.publicKey),
-            errorMessageIncludes(scenario.match)
-        );
-    }
-});
-
-test('V1BaseOperation.validateSignature throws V1UnexpectedError for unknown operation type', async t => {
-    const operation = new V1BaseOperation(config);
-
-    const payload = {
-        type: 9999,
-        id: 'id',
-        timestamp: Date.now(),
-        capabilities: [],
-    };
-
-    await t.exception(
-        async () => operation.validateSignature(payload, b4a.alloc(32, 1)),
-        errorMessageIncludes('Unknown operation type')
-    );
-});
-
-test('V1BaseOperation.validatePeerCorrectness validates response sender identity', t => {
-    const operation = new V1BaseOperation(config);
-    const remotePublicKey = b4a.alloc(32, 9);
-
-    operation.validatePeerCorrectness(remotePublicKey, {
-        requestedTo: b4a.toString(remotePublicKey, 'hex')
-    });
-
-    t.exception(
-        () => operation.validatePeerCorrectness(remotePublicKey, { requestedTo: 'ff' }),
-        errorMessageIncludes('Response sender mismatch')
-    );
-});
-
-test('V1BaseOperation.validateResponseType supports expected mappings and rejects mismatches', t => {
-    const operation = new V1BaseOperation(config);
-
-    operation.validateResponseType(
-        { type: NetworkOperationType.LIVENESS_RESPONSE },
-        { id: '1', requestType: NetworkOperationType.LIVENESS_REQUEST }
-    );
-
-    operation.validateResponseType(
-        { type: NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE },
-        { id: '2', requestType: NetworkOperationType.BROADCAST_TRANSACTION_REQUEST }
-    );
-
-    t.exception(
-        () => operation.validateResponseType(
-            { type: NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE },
-            { id: '3', requestType: NetworkOperationType.LIVENESS_REQUEST }
-        ),
-        errorMessageIncludes('Response type mismatch')
-    );
-
-    try {
-        operation.validateResponseType(
-            { type: NetworkOperationType.LIVENESS_RESPONSE },
-            { id: '4', requestType: 9999 }
-        );
-        t.fail('expected validateResponseType to throw');
-    } catch (error) {
-        t.ok(error instanceof V1UnexpectedError);
-        t.ok(error.message.includes('Unsupported pending request type'));
-    }
-});

package/tests/unit/network/v1/V1BroadcastTransactionOperationHandler.test.js

@@ -1,129 +0,0 @@
-import { test } from 'brittle';
-import b4a from 'b4a';
-import { TRAC_NETWORK_MSB_MAINNET_PREFIX } from 'trac-wallet/constants.js';
-import { config } from '../../../helpers/config.js';
-import { testKeyPair1, testKeyPair2 } from '../../../fixtures/apply.fixtures.js';
-import NetworkWalletFactory from '../../../../src/core/network/identity/NetworkWalletFactory.js';
-import V1BroadcastTransactionOperationHandler from '../../../../src/core/network/protocols/v1/handlers/V1BroadcastTransactionOperationHandler.js';
-import PartialTransactionValidator from '../../../../src/core/network/protocols/shared/validators/PartialTransactionValidator.js';
-import { TransactionPoolFullError } from '../../../../src/core/network/services/TransactionPoolService.js';
-import { V1NodeOverloadedError } from '../../../../src/core/network/protocols/v1/V1ProtocolError.js';
-import { applyStateMessageFactory } from '../../../../src/messages/state/applyStateMessageFactory.js';
-
-const createWallet = (keyPair) => {
-    const normalizedKeyPair = {
-        publicKey: b4a.from(keyPair.publicKey, 'hex'),
-        secretKey: b4a.from(keyPair.secretKey, 'hex')
-    };
-
-    return NetworkWalletFactory.provide({
-        enableWallet: false,
-        keyPair: normalizedKeyPair,
-        networkPrefix: TRAC_NETWORK_MSB_MAINNET_PREFIX
-    });
-};
-
-test('V1BroadcastTransactionOperationHandler dispatchTransaction does not emit unhandledRejection when enqueue fails after pending commit registration', async t => {
-    const originalValidate = PartialTransactionValidator.prototype.validate;
-    PartialTransactionValidator.prototype.validate = async () => true;
-
-    try {
-        const txPoolService = {
-            addTransaction() {
-                throw new TransactionPoolFullError(1);
-            }
-        };
-
-        const pendingRejectors = new Map();
-        const transactionCommitService = {
-            registerPendingCommit(txHash) {
-                return new Promise((resolve, reject) => {
-                    pendingRejectors.set(txHash, reject);
-                });
-            },
-            rejectPendingCommit(txHash, error) {
-                const reject = pendingRejectors.get(txHash);
-                if (!reject) return false;
-                pendingRejectors.delete(txHash);
-                reject(error);
-                return true;
-            }
-        };
-
-        const validatorWallet = createWallet(testKeyPair1);
-        const requesterWallet = createWallet(testKeyPair2);
-        const externalBootstrap = b4a.alloc(32, 0x11);
-
-        const decodedTransaction = await applyStateMessageFactory(requesterWallet, config)
-            .buildPartialTransactionOperationMessage(
-                requesterWallet.address,
-                b4a.alloc(32, 0x22),
-                b4a.alloc(32, 0x33),
-                b4a.alloc(32, 0x44),
-                externalBootstrap,
-                config.bootstrap,
-                'buffer'
-            );
-
-        const handler = new V1BroadcastTransactionOperationHandler(
-            {},
-            validatorWallet,
-            { v1HandleRateLimit() {} },
-            txPoolService,
-            { getPendingRequest() { return null; } },
-            transactionCommitService,
-            config
-        );
-
-        let unhandled = null;
-        const onUnhandled = (error) => {
-            unhandled = error;
-        };
-
-        const detachUnhandled = (() => {
-            const proc = globalThis.process;
-            if (proc?.once && proc?.removeListener) {
-                proc.once('unhandledRejection', onUnhandled);
-                return () => proc.removeListener('unhandledRejection', onUnhandled);
-            }
-            if (typeof globalThis.addEventListener === 'function') {
-                const listener = (event) => onUnhandled(event?.reason ?? event);
-                globalThis.addEventListener('unhandledrejection', listener);
-                return () => globalThis.removeEventListener('unhandledrejection', listener);
-            }
-            if ('onunhandledrejection' in globalThis) {
-                const previous = globalThis.onunhandledrejection;
-                globalThis.onunhandledrejection = (event) => {
-                    onUnhandled(event?.reason ?? event);
-                    if (typeof previous === 'function') {
-                        previous(event);
-                    }
-                };
-                return () => {
-                    globalThis.onunhandledrejection = previous;
-                };
-            }
-            return null;
-        })();
-        try {
-            let thrown = null;
-            try {
-                await handler.dispatchTransaction(decodedTransaction);
-            } catch (error) {
-                thrown = error;
-            }
-
-            t.ok(thrown, 'dispatchTransaction should throw when enqueue fails');
-            t.ok(thrown instanceof V1NodeOverloadedError, 'should map tx pool full to V1NodeOverloadedError');
-            await new Promise(resolve => setImmediate(resolve));
-        } finally {
-            if (detachUnhandled) {
-                detachUnhandled();
-            }
-        }
-
-        t.absent(unhandled, 'should not emit unhandledRejection');
-    } finally {
-        PartialTransactionValidator.prototype.validate = originalValidate;
-    }
-});

package/tests/unit/network/v1/V1BroadcastTransactionRequest.test.js

@@ -1,53 +0,0 @@
-import test from 'brittle';
-import b4a from 'b4a';
-
-import V1BroadcastTransactionRequest from '../../../../src/core/network/protocols/v1/validators/V1BroadcastTransactionRequest.js';
-import { V1InvalidPayloadError } from '../../../../src/core/network/protocols/v1/V1ProtocolError.js';
-import { MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE } from '../../../../src/utils/constants.js';
-import { config } from '../../../helpers/config.js';
-
-test('V1BroadcastTransactionRequest.validate runs schema, size and signature validation', async t => {
-    const validator = new V1BroadcastTransactionRequest(config);
-    const calls = [];
-
-    validator.isPayloadSchemaValid = () => calls.push('schema');
-    validator.isDataPropertySizeValid = () => calls.push('size');
-    validator.validateSignature = async () => calls.push('signature');
-
-    const result = await validator.validate({}, b4a.alloc(32, 1));
-
-    t.is(result, true);
-    t.is(calls.length, 3);
-    t.is(calls[0], 'schema');
-    t.is(calls[1], 'size');
-    t.is(calls[2], 'signature');
-});
-
-test('V1BroadcastTransactionRequest.isDataPropertySizeValid accepts max allowed payload size', t => {
-    const validator = new V1BroadcastTransactionRequest(config);
-    const payload = {
-        broadcast_transaction_request: {
-            data: b4a.alloc(MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE, 1)
-        }
-    };
-
-    validator.isDataPropertySizeValid(payload);
-    t.pass();
-});
-
-test('V1BroadcastTransactionRequest.isDataPropertySizeValid throws for oversized payload', t => {
-    const validator = new V1BroadcastTransactionRequest(config);
-    const payload = {
-        broadcast_transaction_request: {
-            data: b4a.alloc(MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE + 1, 1)
-        }
-    };
-
-    try {
-        validator.isDataPropertySizeValid(payload);
-        t.fail('expected size validation to throw');
-    } catch (error) {
-        t.ok(error instanceof V1InvalidPayloadError);
-        t.ok(error.message.includes('exceeds the maximum allowed byte size'));
-    }
-});