trac-msb 0.2.0 → 0.2.2

package/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+    Copyright 2025 Trac Systems UG
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -198,4 +198,4 @@
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
-   limitations under the License.
+   limitations under the License.

package/SECURITY.md

@@ -0,0 +1,54 @@
+# Security Policy
+
+## Supported Versions
+
+The following table shows which versions of this project are currently receiving security updates.
+
+| Version | Supported          |
+| -------- | ------------------ |
+| 0.2.x    | :white_check_mark: |
+| < 0.2    | :x:                |
+
+Older versions (< 0.2.x) are no longer supported.  
+Please upgrade to the latest release to ensure you receive security fixes.
+
+---
+
+## Reporting a Vulnerability
+
+If you discover a security vulnerability affecting the TRAC Network,  
+please **do not disclose it publicly** (e.g., on social media, Discord, or GitHub Issues).
+
+Instead, report it responsibly and confidentially through one of the following contacts:
+
+- 📧 **info@trac.network** — protocol, API, infrastructure, or tooling vulnerabilities 
+
+Alternatively, you can use the **“Report a vulnerability”** option on GitHub if available.
+
+---
+
+### Responsible Disclosure Guidelines
+
+- **Do not exploit or test vulnerabilities on mainnet.**  
+  Use **testnet** environments or isolated local nodes for proof-of-concepts (PoCs).  
+- Include clear and reproducible details in your report:
+  - affected **component or module**,  
+  - minimal **proof of concept (PoC)** showing the issue,  
+  - expected vs. actual behavior,  
+  - estimated **impact** (e.g., fund loss, network instability, or data integrity issue),  
+  - any relevant **logs or transaction hashes** if applicable.  
+- Please avoid:
+  - phishing or social engineering,  
+  - denial-of-service (DoS) or spam tests,  
+  - public disclosure before coordinated remediation.
+
+---
+
+### Response Process
+
+- You will receive an **acknowledgment within 72 hours** of submission.  
+- The TRAC Network security team will investigate and validate the issue.  
+- If confirmed, we’ll provide updates on the **remediation plan and timeline**.  
+- After a fix is deployed, we may publicly recognize your contribution (with your consent).  
+
+Thank you for helping us keep the TRAC Network ecosystem secure and resilient 💙

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trac-msb",
   "main": "msb.mjs",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "pear": {
     "name": "trac-msb",
     "type": "terminal"

package/rpc/create_server.mjs

@@ -32,9 +32,23 @@ export const createServer = (msbInstance) => {
 
     // Find the matching route
     let foundRoute = false;
-    for (const route of routes) {
-        // Simple path matching
-        if (req.method === route.method && req.url.startsWith(route.path)) {
+    
+    // Extract the path without query parameters
+    const requestPath = req.url.split('?')[0];
+    
+    // Sort routes by path length (longest first) to ensure more specific routes match first
+    const sortedRoutes = [...routes].sort((a, b) => b.path.length - a.path.length);
+    
+    for (const route of sortedRoutes) {
+        // Exact path matching for base route, allow parameters after base path
+        const routeBase = route.path.endsWith('/') ? route.path.slice(0, -1) : route.path;
+        const requestParts = requestPath.split('/');
+        const routeParts = routeBase.split('/');
+        
+        if (req.method === route.method && 
+            requestParts.length >= routeParts.length &&
+            routeParts.every((part, i) => part === requestParts[i])) {
+            
             foundRoute = true;
             try {
                 // This try/catch covers synchronous errors and errors from awaited promises
@@ -43,8 +57,6 @@ export const createServer = (msbInstance) => {
             } catch (error) {
                 // Catch errors thrown directly from the handler (or its awaited parts)
                 console.error(`Error on ${route.path}:`, error);
-                
-                // FIX: Pass an object payload
                 respond(500, { error: 'An error occurred processing the request.' });
             }
             break;

package/rpc/handlers.mjs

@@ -1,5 +1,6 @@
-import {decodeBase64Payload, isBase64, sanitizeBulkPayloadsRequestBody, sanitizeTransferPayload, validatePayloadStructure} from "./utils/helpers.mjs"
+import { decodeBase64Payload, isBase64, sanitizeBulkPayloadsRequestBody, sanitizeTransferPayload, validatePayloadStructure } from "./utils/helpers.mjs"
 import { MAX_SIGNED_LENGTH } from "./constants.mjs";
+import { isHexString } from "../src/utils/helpers";
 
 export async function handleBalance({ req, respond, msbInstance }) {
     const [path, queryString] = req.url.split("?");
@@ -198,4 +199,47 @@ export async function handleFetchBulkTxPayloads({ msbInstance, respond, req }) {
         console.error('Stream error in handleFetchBulkTxPayloads:', err);
         respond(500, { error: 'Request stream failed during body transfer.' });
     });
+}
+
+export async function handleTransactionExtendedDetails({ msbInstance, respond, req }) {
+    const [path, queryString] = req.url.split("?");
+    const pathParts = path.split('/');
+    const hash = pathParts[4];
+    
+    if (!hash) {
+        return respond(400, { error: "Transaction hash is required" });
+    }
+    
+    if (isHexString(hash) === false || hash.length !== 64) {
+        return respond(400, { error: "Invalid transaction hash format" });
+    }
+    let confirmed = true; // default
+    if (queryString) {
+        const params = new URLSearchParams(queryString);
+        if (params.has("confirmed")) {
+            const confirmedParam = params.get("confirmed");
+            if (confirmedParam !== "true" && confirmedParam !== "false") {
+                return respond(400, { error: 'Parameter "confirmed" must be exactly "true" or "false"' });
+            }
+            confirmed = confirmedParam === "true";
+        }
+    }
+    
+    try {
+        let txDetails;
+        const commandString = `/get_extended_tx_details ${hash} ${confirmed}`;
+        txDetails = await msbInstance.handleCommand(commandString);
+        if (txDetails === null) {
+            respond(404, { error: `No payload found for tx hash: ${hash}` });
+        } else {
+            respond(200, txDetails);
+        }
+    } catch (error) {
+        if (error.message?.includes('No payload found for tx hash')) {
+            respond(404, { error: error.message });
+        } else {
+            console.error('Error in handleTransactionDetails:', error);
+            respond(500, { error: 'An error occurred processing the request.' });
+        }
+    }
 }

package/rpc/routes/v1.mjs

@@ -7,7 +7,8 @@ import {
     handleTxHashes,
     handleUnconfirmedLength,
     handleTransactionDetails,
-    handleFetchBulkTxPayloads
+    handleFetchBulkTxPayloads,
+    handleTransactionExtendedDetails
 } from '../handlers.mjs';
 
 export const v1Routes = [
@@ -20,4 +21,5 @@ export const v1Routes = [
     { method: 'GET', path: '/unconfirmed-length', handler: handleUnconfirmedLength },
     { method: 'GET', path: '/tx', handler: handleTransactionDetails },
     { method: 'POST', path: '/tx-payloads-bulk', handler: handleFetchBulkTxPayloads },
+    { method: 'GET', path: '/tx/details', handler: handleTransactionExtendedDetails },
 ];

package/rpc/rpc_server.mjs

@@ -5,6 +5,6 @@ export function startRpcServer(msbInstance, host, port) {
     const server = createServer(msbInstance)
 
     return server.listen(port, host, () => {
-        console.log(`Running RPC with https at https://${host}:${port}`);
+        console.log(`Running RPC with http at http://${host}:${port}`);
     });
 }

package/src/core/state/State.js

@@ -17,7 +17,7 @@ import {
     TRAC_NAMESPACE,
     CustomEventType
 } from '../../utils/constants.js';
-import { isHexString, sleep } from '../../utils/helpers.js';
+import { isHexString, sleep, isTransactionRecordPut } from '../../utils/helpers.js';
 import PeerWallet from 'trac-wallet';
 import Check from '../../utils/check.js';
 import { safeDecodeApplyOperation } from '../../utils/protobuf/operationHelpers.js';
@@ -265,6 +265,24 @@ class State extends ReadyResource {
             return b4a.equals(initialization, safeWriteUInt32BE(0, 0))
         }
     }
+    async getTransactionConfirmedLength(hash) {
+        if (!isHexString(hash) || hash.length !== 64) {
+            throw new Error("Invalid hash format");
+        }
+
+        const confirmedLength = this.getSignedLength();
+        const historyStream = this.#base.view.createHistoryStream({
+            gte: 0,
+            lte: confirmedLength
+        });
+
+        for await (const entry of historyStream) {
+            if (isTransactionRecordPut(entry) && entry.key === hash) {
+                return entry.seq;
+            }
+        }
+        return null;
+    }
 
     async confirmedTransactionsBetween(startSignedLength, endSignedLength) {
         if (!Number.isInteger(startSignedLength) || !Number.isInteger(endSignedLength)) {

package/src/index.js

@@ -8,7 +8,7 @@ import readline from "readline";
 import tty from "tty";
 
 import { sleep, getFormattedIndexersWithAddresses, isHexString, convertAdminCoreOperationPayloadToHex } from "./utils/helpers.js";
-import { verifyDag, printHelp, printWalletInfo, get_tx_info, printBalance } from "./utils/cli.js";
+import { verifyDag, printHelp, printWalletInfo, get_confirmed_tx_info, printBalance, get_unconfirmed_tx_info } from "./utils/cli.js";
 import CompleteStateMessageOperations from "./messages/completeStateMessages/CompleteStateMessageOperations.js";
 import { safeDecodeApplyOperation } from "./utils/protobuf/operationHelpers.js";
 import { bufferToAddress, isAddressValid } from "./core/state/utils/address.js";
@@ -821,11 +821,11 @@ export class MainSettlementBus extends ReadyResource {
         }
 
         const { addressBalancePair, totalBalance, totalAddresses, addresses } = await fileUtils.readBalanceMigrationFile();
-        
+
         for (let i = 0; i < addresses.length; i++) {
             await migrationUtils.validateAddressFromIncomingFile(this.#state, addresses[i].address, adminEntry);
         }
-        
+
         await fileUtils.validateBalanceMigrationData(addresses);
         const migrationNumber = await fileUtils.getNextMigrationNumber();
         await fileUtils.createMigrationEntryFile(addressBalancePair, migrationNumber);
@@ -1070,7 +1070,7 @@ export class MainSettlementBus extends ReadyResource {
                 } else if (input.startsWith("/get_tx_info")) {
                     const splitted = input.split(" ");
                     const txHash = splitted[1];
-                    const txInfo = await get_tx_info(this.#state, txHash);
+                    const txInfo = await get_confirmed_tx_info(this.#state, txHash);
                     if (txInfo) {
                         console.log(`Payload for transaction hash ${txHash}:`);
                         console.log(txInfo.decoded);
@@ -1199,7 +1199,7 @@ export class MainSettlementBus extends ReadyResource {
                             this.network.validatorConnectionManager.rotate() // force change connection rotation for the next retry
                         }
 
-                        return { message: "Transaction broadcasted successfully.", signedLength, unsignedLength };
+                        return { message: "Transaction broadcasted successfully.", signedLength, unsignedLength, tx: hash };
                     } else {
                         // Handle case where payload is missing if called internally without one.
                         throw new Error("Transaction payload is required for broadcast_transaction command.");
@@ -1218,7 +1218,7 @@ export class MainSettlementBus extends ReadyResource {
                             throw new Error("Length of input tx hashes exceeded.");
                         }
 
-                        const promises = hashes.map(hash => get_tx_info(this.#state, hash));
+                        const promises = hashes.map(hash => get_confirmed_tx_info(this.#state, hash));
                         const results = await Promise.all(promises);
 
                         // Iterate and categorize
@@ -1251,9 +1251,8 @@ export class MainSettlementBus extends ReadyResource {
                 } else if (input.startsWith("/get_tx_details")) {
                     const splitted = input.split(' ')
                     const hash = splitted[1];
-
                     try {
-                        const rawPayload = await get_tx_info(this.#state, hash);
+                        const rawPayload = await get_confirmed_tx_info(this.#state, hash);
                         if (!rawPayload) {
                             console.log(`No payload found for tx hash: ${hash}`)
                             return null
@@ -1264,6 +1263,52 @@ export class MainSettlementBus extends ReadyResource {
                         throw new Error("Invalid params to perform the request.", error.message);
                     }
                 }
+                else if (input.startsWith("/get_extended_tx_details")) {
+                    const splitted = input.split(' ');
+                    const hash = splitted[1];
+                    const confirmed = splitted[2] === 'true';
+
+                    if (confirmed) {
+                        const rawPayload = await get_confirmed_tx_info(this.#state, hash);
+                        if (!rawPayload) {
+                            throw new Error(`No payload found for tx hash: ${hash}`);
+                        }
+                        const confirmedLength = await this.#state.getTransactionConfirmedLength(hash);
+                        const normalizedPayload = normalizeDecodedPayloadForJson(rawPayload.decoded, true);
+                        if (confirmedLength === null) {
+                            throw new Error(`No confirmed length found for tx hash: ${hash} in confirmed mode`);
+                        }
+                        const fee = this.#state.getFee();
+                        return {
+                            txDetails: normalizedPayload,
+                            confirmed_length: confirmedLength,
+                            fee: bufferToBigInt(fee).toString()
+                        }
+                    }
+                    else {
+                        const rawPayload = await get_unconfirmed_tx_info(this.#state, hash);
+                        if (!rawPayload) {
+                            throw new Error(`No payload found for tx hash: ${hash}`);
+                        }
+                        const normalizedPayload = normalizeDecodedPayloadForJson(rawPayload.decoded, true);
+                        const length = await this.#state.getTransactionConfirmedLength(hash)
+                        if (length === null) {
+                            return {
+                                txDetails: normalizedPayload,
+                                confirmed_length: 0,
+                                fee: '0'
+                            }
+                        }
+
+                        const fee = this.#state.getFee();
+                        return {
+                            txDetails: normalizedPayload,
+                            confirmed_length: length,
+                            fee: bufferToBigInt(fee).toString()
+                        }
+
+                    }
+                }
         }
         if (rl) rl.prompt();
     }

package/src/utils/cli.js

@@ -103,7 +103,7 @@ export const printBalance = async (address, state, wallet_enabled) => {
     }
 }
 
-export const get_tx_info = async (state_instance, txHash) => {
+export const get_confirmed_tx_info = async (state_instance, txHash) => {
     const payload = await state_instance.getSigned(txHash);
     if (!payload) {
         return null
@@ -119,3 +119,20 @@ export const get_tx_info = async (state_instance, txHash) => {
         decoded
     }
 }
+
+export const get_unconfirmed_tx_info = async (state_instance, txHash) => {
+    const payload = await state_instance.get(txHash);
+    if (!payload) {
+        return null
+    }
+
+    const decoded = safeDecodeApplyOperation(payload);
+    if (!decoded) {
+        throw new Error(`Failed to decode payload for transaction hash: ${txHash}`);
+    }
+
+    return {
+        payload,
+        decoded
+    }
+}

package/src/utils/helpers.js

@@ -97,3 +97,10 @@ export function convertAdminCoreOperationPayloadToHex(payload) {
         },
     };
 }
+
+export function isTransactionRecordPut(entry) {
+    const isPut = entry.type === "put";
+    const isHex = isHexString(entry.key);
+    const is64 = entry.key.length === 64;
+    return isPut && isHex && is64;
+}

package/test/acceptance/v1/rpc.test.mjs

@@ -28,7 +28,7 @@ const setupNetwork = async () => {
         store_name: '/admin'
     }
 
-    const peer =await setupMsbAdmin(testKeyPair1, tmpDirectory, rpcOpts)
+    const peer = await setupMsbAdmin(testKeyPair1, tmpDirectory, rpcOpts)
     const writer = await setupMsbWriter(peer, 'writer', testKeyPair2, tmpDirectory, peer.options);
     return { writer, peer }
 }
@@ -76,7 +76,7 @@ describe("API acceptance tests", () => {
         it("< 1000", async () => {
             const res = await request(server).get("/v1/tx-hashes/1/1001")
             expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual({ 
+            expect(res.body).toEqual({
                 hashes: expect.arrayContaining([
                     expect.objectContaining({
                         hash: expect.any(String),
@@ -124,6 +124,7 @@ describe("API acceptance tests", () => {
                 message: "Transaction broadcasted successfully.",
                 signedLength: expect.any(Number),
                 unsignedLength: expect.any(Number),
+                tx: expect.any(String)
             }
         })
     })
@@ -137,8 +138,8 @@ describe("API acceptance tests", () => {
         const res = await request(server)
             .post("/v1/tx-payloads-bulk")
             .set("Accept", "application/json")
-            .send(JSON.stringify( payload ))
-        
+            .send(JSON.stringify(payload))
+
         expect(res.statusCode).toBe(200)
         expect(res.body).toMatchObject({
             results: expect.arrayOf(
@@ -146,7 +147,177 @@ describe("API acceptance tests", () => {
                     hash: expect.any(String),
                 })
             ),
-            missing:[]
+            missing: []
         })
     })
+
+    describe('GET /v1/tx/details', () => {
+
+        it("positive case - should return 200 for valid already broadcasted hash confirmed and unconfirmed", async () => {
+            const txData = await tracCrypto.transaction.preBuild(
+                wallet.address,
+                wallet.address,
+                b4a.toString($TNK(1n), 'hex'),
+                b4a.toString(await msb.state.getIndexerSequenceState(), 'hex')
+            );
+
+            const payload = tracCrypto.transaction.build(txData, b4a.from(wallet.secretKey, 'hex'));
+            const broadcastRes = await request(server)
+                .post("/v1/broadcast-transaction")
+                .set("Accept", "application/json")
+                .send(JSON.stringify({ payload }));
+            expect(broadcastRes.statusCode).toBe(200);
+
+            const resConfirmed = await request(server)
+                .get(`/v1/tx/details/${txData.hash.toString('hex')}?confirmed=true`);
+            expect(resConfirmed.statusCode).toBe(200);
+
+            expect(resConfirmed.body).toMatchObject({
+                txDetails: expect.any(Object),
+                confirmed_length: expect.any(Number),
+                fee: expect.any(String)
+            })
+
+            const resUnconfirmed = await request(server)
+                .get(`/v1/tx/details/${txData.hash.toString('hex')}?confirmed=false`);
+            expect(resUnconfirmed.statusCode).toBe(200);
+
+            expect(resUnconfirmed.body).toMatchObject({
+                txDetails: expect.any(Object),
+                confirmed_length: expect.any(Number),
+                fee: expect.any(String)
+            })
+        });
+
+        it("should handle null confirmed_length for unconfirmed transaction", async () => {
+            const txData = await tracCrypto.transaction.preBuild(
+                wallet.address,
+                wallet.address,
+                b4a.toString($TNK(1n), 'hex'),
+                b4a.toString(await msb.state.getIndexerSequenceState(), 'hex')
+            );
+
+            const payload = tracCrypto.transaction.build(txData, b4a.from(wallet.secretKey, 'hex'));
+            
+            const originalGetConfirmedLength = msb.state.getTransactionConfirmedLength;
+            msb.state.getTransactionConfirmedLength = async () => null;
+
+            try {
+                const broadcastRes = await request(server)
+                    .post("/v1/broadcast-transaction")
+                    .set("Accept", "application/json")
+                    .send(JSON.stringify({ payload }));
+                expect(broadcastRes.statusCode).toBe(200);
+
+                const res = await request(server)
+                    .get(`/v1/tx/details/${txData.hash.toString('hex')}?confirmed=false`);
+                expect(res.statusCode).toBe(200);
+
+                expect(res.body).toMatchObject({
+                    txDetails: expect.any(Object),
+                    confirmed_length: 0,
+                    fee: '0'
+                });
+            } finally {
+                msb.state.getTransactionConfirmedLength = originalGetConfirmedLength;
+            }
+        });
+
+        it("should return 404 for non-existent transaction hash", async () => {
+            const nonExistentHash = "0b4d1c1dac48af13212f616601d7399457476a0b644850875b7f4b79df6ff89c";
+            const res = await request(server)
+                .get(`/v1/tx/details/${nonExistentHash}`);
+
+            expect(res.statusCode).toBe(404);
+            expect(res.body).toEqual({
+                error: `No payload found for tx hash: ${nonExistentHash}`
+            });
+        });
+
+        it("should return 400 for invalid hash format (too short)", async () => {
+            const invalidHash = '0'.repeat(63);
+            const res = await request(server)
+                .get(`/v1/tx/details/${invalidHash}`);
+
+            expect(res.statusCode).toBe(400);
+            expect(res.body).toEqual({
+                error: "Invalid transaction hash format"
+            });
+        });
+
+        it("should return 400 for invalid hash format (non-hex)", async () => {
+            const invalidHash = 'Z'.repeat(64);
+            const res = await request(server)
+                .get(`/v1/tx/details/${invalidHash}`);
+
+            expect(res.statusCode).toBe(400);
+            expect(res.body).toEqual({
+                error: "Invalid transaction hash format"
+            });
+        });
+
+        it("should return 400 for invalid confirmed parameter", async () => {
+            const hash = "0b4d1c1dac48af13212f616601d7399457476a0b644850875b7f4b79df6ff89c";
+
+            const res = await request(server)
+                .get(`/v1/tx/details/${hash}?confirmed=invalid`);
+
+            expect(res.statusCode).toBe(400);
+            expect(res.body).toEqual({
+                error: 'Parameter "confirmed" must be exactly "true" or "false"'
+            });
+        });
+
+        it("should return 400 for invalid confirmed parameter case (UPPERCASE)", async () => {
+            const hash = "0b4d1c1dac48af13212f616601d7399457476a0b644850875b7f4b79df6ff89c";
+            const res = await request(server).get(`/v1/tx/details/${hash}?confirmed=TRUE`);
+            expect(res.statusCode).toBe(400);
+            expect(res.body).toEqual({
+                error: 'Parameter "confirmed" must be exactly "true" or "false"'
+            });
+        });
+
+        it("should return 400 when no hash provided", async () => {
+            const res = await request(server)
+                .get('/v1/tx/details');
+
+            expect(res.statusCode).toBe(400);
+            expect(res.body).toEqual({
+                error: "Transaction hash is required"
+            });
+        });
+
+        it("should return 400 for hash with invalid characters", async () => {
+            const invalidHash = '0b4d1c1dac48$af13212f6166017399457476a0b644850875b7f4b79df6ff89c';
+            const res = await request(server)
+                .get(`/v1/tx/details/${invalidHash}`);
+
+            expect(res.statusCode).toBe(400);
+            expect(res.body).toEqual({
+                error: "Invalid transaction hash format"
+            });
+        });
+
+        it("should return 400 for hash with special characters", async () => {
+            const invalidHash = '!@#$%^&*'.repeat(8);
+            const res = await request(server)
+                .get(`/v1/tx/details/${invalidHash}`);
+
+            expect(res.statusCode).toBe(400);
+            expect(res.body).toEqual({
+                error: "Invalid transaction hash format"
+            });
+        });
+
+        it("should return 400 for hash with spaces", async () => {
+            const invalidHash = '0b4d1c1dac48af13212f616601d7399457476a0b644850875b7 4b79df6ff89c';
+            const res = await request(server)
+                .get(`/v1/tx/details/${invalidHash}`);
+
+            expect(res.statusCode).toBe(400);
+            expect(res.body).toEqual({
+                error: "Invalid transaction hash format"
+            });
+        });
+    })
 })

package/test/all.test.js

@@ -6,15 +6,16 @@ async function runTests() {
   test.pause();
 
   await import('./state/stateTests.test.js');
-  await import('./check/check.test.js');
-  await import('./protobuf/protobuf.test.js');
-  await import('./functions/functions.test.js');
-  await import('./fileUtils/readAddressesFromWhitelistFile.test.js');
-  await import('./fileUtils/readBalanceMigrationFile.test.js');
-  await import('./migrationUtils/validateAddressFromIncomingFile.test.js');
+  // await import('./state/apply.addAdmin.basic.test.js');
+  // await import('./check/check.test.js');
+  // await import('./protobuf/protobuf.test.js');
+  // await import('./functions/functions.test.js');
+  // await import('./fileUtils/readAddressesFromWhitelistFile.test.js');
+  // await import('./fileUtils/readBalanceMigrationFile.test.js');
+  // await import('./migrationUtils/validateAddressFromIncomingFile.test.js');
   // await import('./messageOperations/stateMessageOperations.test.js');
-  await import('./buffer/buffer.test.js')
-  await import('./network/connectionManagerTests.test.js')
+  // await import('./buffer/buffer.test.js')
+  // await import('./network/connectionManagerTests.test.js')
   // await import('./apply/apply.test.js'); // This test has been disabled because Github CI fails due to lack of resources. This test can still be run locally but sometimes it hangs when destroying resources.
   test.resume();
 }