trac-msb 0.2.9 → 0.2.10

package/src/core/network/services/TransactionRateLimiterService.js

@@ -1,26 +1,23 @@
 import b4a from 'b4a';
-import {
-    CLEANUP_INTERVAL_MS,
-    CONNECTION_TIMEOUT_MS,
-    MAX_TRANSACTIONS_PER_SECOND
-} from '../../../utils/constants.js';
 
 class TransactionRateLimiterService {
     #lastCleanup;
     #connectionsStatistics;
     #swarm;
+    #config;
 
-    constructor(swarm) {
+    constructor(swarm, config) {
         this.#lastCleanup = Date.now();
         this.#connectionsStatistics = new Map();
         this.#swarm = swarm
+        this.#config = config
     }
 
     /*
         Checks if the peer has exceeded the rate limit.
         A peer is considered to have exceeded the rate limit if:
         - The time since the last activity is greater than or equal to 1000 ms (1 second)
-        - The number of transactions in the current session is greater than or equal to MAX_TRANSACTIONS_PER_SECOND
+        - The number of transactions in the current session is greater than or equal to rateLimitMaxTransactionsPerSecond
         If the rate limit is exceeded, the peer is disconnected.
     */
     #hasExceededRateLimit(peer) {
@@ -33,7 +30,7 @@ class TransactionRateLimiterService {
             this.#connectionsStatistics.set(peer, peerData);
         }
         
-        return peerData.transactionCount >= MAX_TRANSACTIONS_PER_SECOND;
+        return peerData.transactionCount >= this.#config.rateLimitMaxTransactionsPerSecond;
     }
 
     /*
@@ -65,13 +62,13 @@ class TransactionRateLimiterService {
     }
 
     #shouldCleanupConnections(currentTime) {
-        return currentTime - this.#lastCleanup >= CLEANUP_INTERVAL_MS;
+        return currentTime - this.#lastCleanup >= this.#config.rateLimitCleanupIntervalMs;
     }
 
     /**
         Cleans up old connections that have timed out.
         Condition for cleanup based on #shouldCleanupConnections:
-        - If the last cleanup was more than CLEANUP_INTERVAL_MS ago
+        - If the last cleanup was more than rateLimitCleanupIntervalMs ago
     */
     #cleanUpOldConnections(currentTime) {
         if (!this.#shouldCleanupConnections(currentTime)) {
@@ -125,7 +122,7 @@ class TransactionRateLimiterService {
     */
     #isConnectionExpired(peer) {
         const peerData = this.#connectionsStatistics.get(peer);
-        return peerData.lastActivityTime - peerData.sessionStartTime >= CONNECTION_TIMEOUT_MS;
+        return peerData.lastActivityTime - peerData.sessionStartTime >= this.#config.rateLimitConnectionTimeoutMs;
     }
 }
 

package/src/core/network/services/ValidatorObserverService.js

@@ -1,6 +1,5 @@
 import PeerWallet from "trac-wallet";
 import b4a from "b4a";
-import { MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION } from '../../../utils/constants.js';
 import { bufferToAddress } from '../../state/utils/address.js';
 import { sleep } from '../../../utils/helpers.js';
 import Scheduler from "../../../utils/Scheduler.js";
@@ -31,7 +30,7 @@ class ValidatorObserverService {
      * @param {Network} network
      * @param {State} state
      * @param {string} address
-     * @param {object} config
+     * @param {Config} config
      **/
     constructor(network, state, address, config) {
         this.#config = config
@@ -132,7 +131,7 @@ class ValidatorObserverService {
         const validatorPubKeyHex = validatorPubKeyBuffer.toString('hex');
         const adminEntry = await this.state.getAdminEntry();
 
-        if (validatorAddress !== adminEntry?.address || validatorListLength < MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION) {
+        if (validatorAddress !== adminEntry?.address || validatorListLength < this.#config.maxWritersForAdminIndexerConnection) {
             this.#network.tryConnect(validatorPubKeyHex, 'validator');
         }
     };
@@ -151,7 +150,7 @@ class ValidatorObserverService {
             return false;
         }
 
-        if (validatorAddress === adminEntry?.address && validatorListLength >= MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION) {
+        if (validatorAddress === adminEntry?.address && validatorListLength >= this.#config.maxWritersForAdminIndexerConnection) {
             if (this.#network.validatorConnectionManager.exists(validatorPubKeyBuffer)) {
                 this.#network.validatorConnectionManager.remove(validatorPubKeyBuffer)
             }
@@ -161,12 +160,12 @@ class ValidatorObserverService {
         // - Cannot connect if already connected to a validator
         // - Validator must exist and be a writer
         // - Cannot connect to indexers, except for admin-indexer
-        // - Admin-indexer connection is allowed only when writers length has less than 10 writers
+        // - Admin-indexer connection is allowed only when writers length is below maxWritersForAdminIndexerConnection
         if (this.#network.validatorConnectionManager.connected(validatorPubKeyBuffer) ||
             this.#network.validatorConnectionManager.maxConnectionsReached() ||
             validatorEntry === null ||
             !validatorEntry.isWriter ||
-            (validatorEntry.isIndexer && (validatorAddress !== adminEntry?.address || validatorListLength >= MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION))
+            (validatorEntry.isIndexer && (validatorAddress !== adminEntry?.address || validatorListLength >= this.#config.maxWritersForAdminIndexerConnection))
         ) {
             return false;
         }

package/src/core/state/State.js

@@ -12,7 +12,6 @@ import {
     HYPERBEE_VALUE_ENCODING,
     BATCH_SIZE,
     ADMIN_INITIAL_STAKED_BALANCE,
-    MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION,
     TRAC_NAMESPACE,
     CustomEventType
 } from '../../utils/constants.js';
@@ -58,7 +57,7 @@ class State extends ReadyResource {
     /**
      * @param {Corestore} store
      * @param {PeerWallet} wallet
-     * @param {object} config
+     * @param {Config} config
      **/
     constructor(store, wallet, config) {
         super();
@@ -178,7 +177,7 @@ class State extends ReadyResource {
     async isAdminAllowedToValidate() {
         const isAdmin = this.writingKey.toString('hex') === this.#config.bootstrap.toString('hex');
         const isIndexer = this.isIndexer();
-        const lengthCondition = await this.getWriterLength() <= MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION;
+        const lengthCondition = await this.getWriterLength() <= this.#config.maxWritersForAdminIndexerConnection;
         return !!(isAdmin && isIndexer && lengthCondition);
     }
 

package/src/index.js

@@ -55,7 +55,7 @@ export class MainSettlementBus extends ReadyResource {
     #config
 
     /**
-     * @param {object} config
+     * @param {Config} config
      **/
     constructor(config) {
         super();
@@ -96,6 +96,8 @@ export class MainSettlementBus extends ReadyResource {
     }
 
     async _open() {
+        await fileUtils.ensureCoresStoreDir(this.#config);
+
         if (this.#config.enableWallet) {
             await this.#wallet.initKeyPair(
                 this.#config.keyPairPath,

package/src/messages/network/v1/NetworkMessageBuilder.js

@@ -8,7 +8,7 @@ import {encodeCapabilities} from "../../../utils/buffer.js";
 /**
  * Builder for v1 internal network protocol messages.
  * @param {PeerWallet} wallet
- * @param {object} config
+ * @param {Config} config
  */
 class NetworkMessageBuilder {
     #wallet;
@@ -26,7 +26,7 @@ class NetworkMessageBuilder {
 
     /**
      * @param {PeerWallet} wallet
-     * @param {object} config
+     * @param {Config} config
      */
     constructor(wallet, config) {
         this.#config = config;

package/src/messages/state/ApplyStateMessageBuilder.js

@@ -23,7 +23,7 @@ import { isHexString } from '../../utils/helpers.js';
 /**
  * Builder for partial/complete ApplyState messages.
  * @param {PeerWallet} wallet
- * @param {object} config
+ * @param {Config} config
  */
 class ApplyStateMessageBuilder {
     #address;

package/src/utils/check.js

@@ -26,7 +26,7 @@ class Check {
     #config
 
     /**
-     * @param {object} config
+     * @param {Config} config
      **/
     constructor(config) {
         this.#config = config

package/src/utils/constants.js

@@ -82,13 +82,6 @@ export const TRAC_NAMESPACE = 'TracNetwork';
 export const WHITELIST_SLEEP_INTERVAL = 1_000;
 export const BALANCE_MIGRATION_SLEEP_INTERVAL = 500;
 
-// Connectivity constants
-export const MAX_PEERS = 64;
-export const MAX_PARALLEL = 64;
-export const MAX_SERVER_CONNECTIONS = Infinity;
-export const MAX_CLIENT_CONNECTIONS = Infinity;
-export const MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION = 10;
-
 // State
 export const ACK_INTERVAL = 1_000;
 export const AUTOBASE_VALUE_ENCODING = 'binary';
@@ -115,16 +108,6 @@ export const BOOTSTRAP_HEXSTRING_LENGTH = 64;
 
 // Pool constants
 export const BATCH_SIZE = 10;
-export const PROCESS_INTERVAL_MS = 50;
-
-// Rate limiting constants
-export const CLEANUP_INTERVAL_MS = 120_000;
-export const CONNECTION_TIMEOUT_MS = 60_000;
-export const MAX_TRANSACTIONS_PER_SECOND = 50;
-
-// Operation handler constants
-export const MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE = 3072;
-export const TRANSACTION_POOL_SIZE = 1000;
 
 // Network message constants
 export const NETWORK_MESSAGE_TYPES = Object.freeze({

package/src/utils/fileUtils.js

@@ -123,6 +123,18 @@ export async function getAllMigrationFiles(migrationDirectory = BALANCE_MIGRATED
     }
 }
 
+export async function ensureCoresStoreDir(config) {
+    try {
+        // const storesDirectoryStats = await fs.promises.stat(config.storesDirectory);
+        // if (!storesDirectoryStats.isDirectory()) {
+        //     throw new Error(`Stores directory path is not a directory: ${config.storesDirectory}`);
+        // }
+        await fs.promises.mkdir(config.storesFullPath, { recursive: true });
+    } catch (err) {
+        throw new Error(`Failed to ensure corestore directory: ${err.message}`);
+    }
+}
+
 export async function validateBalanceMigrationData(addresses) {
     const migrationFiles = await getAllMigrationFiles(BALANCE_MIGRATED_DIR);
     const addressSet = new Set(addresses.map(a => a.address));
@@ -197,6 +209,7 @@ export default {
     readAddressesFromWhitelistFile,
     readBalanceMigrationFile,
     getAllMigrationFiles,
+    ensureCoresStoreDir,
     validateBalanceMigrationData,
     validateWhitelistMigrationData,
     getNextMigrationNumber,

package/src/utils/type.js

@@ -0,0 +1,26 @@
+import _ from "lodash"
+
+/**
+ * Checks if `value` is considered defined akin to RoR `#defined?`.
+ * 
+ * @static
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `false` if `value` is nullish, else `true`.
+ * @example
+ *
+ * isDefined(undefined);
+ * // => false
+ *
+ * isDefined(null);
+ * // => false
+ *
+ * isDefined(void 0);
+ * // => false
+ *
+ * isDefined(NaN);
+ * // => false
+ */
+export function isDefined(value) {
+    return !_.isNil(value) && !_.isNaN(value)
+}
+

package/tests/acceptance/v1/balance/balance.test.mjs

@@ -44,8 +44,7 @@ export const registerBalanceTests = (context) => {
             expect(BigInt(res.body.balance)).toBe(0n)
         })
 
-        //TODO: This test should return 400, but for backward compatibility reasons it currently returns 200 with zero balance. Please fix this.
-        it.skip("returns zero balance for an invalid address format", async () => {
+        it("returns 400 for an invalid address format", async () => {
             const invalidAddress = "not-a-valid-address"
             const res = await request(context.server).get(`/v1/balance/${invalidAddress}`)
             expect(res.statusCode).toBe(400)

package/tests/acceptance/v1/broadcast-transaction/broadcast-transaction.test.mjs

@@ -1,6 +1,5 @@
 import request from "supertest"
 import b4a from "b4a"
-import { $TNK } from "../../../../src/core/state/utils/balance.js"
 import { buildRpcSelfTransferPayload, waitForConnection } from "../../../helpers/transactionPayloads.mjs"
 
 const toBase64 = (value) => b4a.toString(b4a.from(JSON.stringify(value)), "base64")
@@ -52,8 +51,7 @@ export const registerBroadcastTransactionTests = (context) => {
             expect(res.body).toEqual({ error: "Payload must be a valid base64 string." })
         })
 
-        // TODO: enable once handler returns 400 for client-side decode errors
-        it.skip("returns 400 when decoded payload is not valid JSON", async () => {
+        it("returns 400 when decoded payload is not valid JSON", async () => {
             const invalidJsonBase64 = b4a.toString(b4a.from("{{invalid"), "base64")
 
             await waitForConnection(context.rpcMsb)
@@ -66,8 +64,7 @@ export const registerBroadcastTransactionTests = (context) => {
             expect(res.body).toEqual({ error: "Decoded payload is not valid JSON." })
         })
 
-        // TODO: enable once handler returns 400 for client-side validation errors
-        it.skip("returns 400 for invalid transaction structure", async () => {
+        it("returns 400 for invalid transaction structure", async () => {
             const invalidStructure = {
                 type: 1,
                 address: context.wallet.address,
@@ -83,38 +80,37 @@ export const registerBroadcastTransactionTests = (context) => {
             expect(res.body).toEqual({ error: "Invalid payload structure." })
         })
 
-        // TODO: AFTER REFACTORIZATION IMPROVE THESE IMPLEMENTATIONS ENDPOINT TO COVER THESE TESTS.
-        it.skip("returns 413 when payload exceeds size limit", async () => {
-            const largeString = "a".repeat(3_000_000)
-            const payload = toBase64({ type: 1, address: context.wallet.address, txo: { large: largeString } })
+        it("returns 413 when payload exceeds size limit", async () => {
+            const largeString = "a".repeat(2_100_000); 
+            const payload = toBase64({ type: 1, address: context.wallet.address, txo: { large: largeString } });
 
-            await waitForConnection(context.rpcMsb)
+            await waitForConnection(context.rpcMsb);
             const res = await request(context.server)
                 .post("/v1/broadcast-transaction")
                 .set("Accept", "application/json")
-                .send(JSON.stringify({ payload }))
+                .send(JSON.stringify({ payload }));
 
-            expect(res.statusCode).toBe(413)
-        })
+            expect(res.statusCode).toBe(413);
+        });
 
-        it.skip("returns 429 on repeated broadcast failures", async () => {
-            // TODO: Would require forcing msb to throw 'Failed to broadcast transaction after multiple attempts.'
-            const txData = await tracCrypto.transaction.preBuild(
-                context.wallet.address,
-                context.wallet.address,
-                b4a.toString($TNK(1n), 'hex'),
-                b4a.toString(await context.rpcMsb.state.getIndexerSequenceState(), 'hex')
-            )
 
-            const payload = tracCrypto.transaction.build(txData, b4a.from(context.wallet.secretKey, 'hex'))
-            await waitForConnection(context.rpcMsb)
-            const res = await request(context.server)
-                .post("/v1/broadcast-transaction")
-                .set("Accept", "application/json")
-                .send(JSON.stringify({ payload }))
+        it("returns 429 on repeated broadcast failures", async () => {
+            const { payload } = await buildRpcSelfTransferPayload(context, context.rpcMsb.state, 1n);
+            const originalMethod = context.rpcMsb.broadcastPartialTransaction;
+            context.rpcMsb.broadcastPartialTransaction = async () => false; 
 
-            expect(res.statusCode).toBe(429)
-            expect(res.body).toEqual({ error: "Failed to broadcast transaction after multiple attempts." })
-        })
+            try {
+                await waitForConnection(context.rpcMsb);
+                const res = await request(context.server)
+                    .post("/v1/broadcast-transaction")
+                    .set("Accept", "application/json")
+                    .send(JSON.stringify({ payload }));
+
+                expect(res.statusCode).toBe(429);
+                expect(res.body).toEqual({ error: "Failed to broadcast transaction after multiple attempts." });
+            } finally {
+                context.rpcMsb.broadcastPartialTransaction = originalMethod;
+            }
+        });
     })
 }

package/tests/acceptance/v1/health/health.test.mjs

@@ -0,0 +1,33 @@
+import request from "supertest"
+
+export const registerHealthTests = (context) => {
+    describe("GET /v1/health", () => {
+        it("should return 200 and ok:true when healthy", async () => {
+            const res = await request(context.server).get("/v1/health")
+            expect(res.statusCode).toBe(200)
+            expect(res.body).toEqual({ ok: true })
+        })
+
+        it("should return 503 when the state is unavailable", async () => {
+            const originalState = context.rpcMsb.state;
+            Object.defineProperty(context.rpcMsb, 'state', {
+                get: () => null,
+                configurable: true
+            });
+
+            try {
+                const res = await request(context.server).get("/v1/health")
+                
+                expect(res.statusCode).toBe(503)
+                expect(res.body).toEqual({ 
+                    error: "Could not connect to RPC server" 
+                })
+            } finally {
+                Object.defineProperty(context.rpcMsb, 'state', {
+                    get: () => originalState,
+                    configurable: true
+                });
+            }
+        })
+    })
+}

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

@@ -13,6 +13,7 @@ import { registerTxDetailsTests } from "./tx-details/tx-details.test.mjs"
 import { registerTxTests } from "./tx/tx.test.mjs"
 import { registerTxvTests } from "./txv/txv.test.mjs"
 import { registerUnconfirmedLengthTests } from "./unconfirmed-length/unconfirmed-length.test.mjs"
+import { registerHealthTests } from "./health/health.test.mjs"
 
 let toClose
 let tmpDirectory
@@ -37,8 +38,7 @@ const setupNetwork = async () => {
         enableInteractiveMode: false,
         disableRateLimit: true,
         enableTxApplyLogs: false,
-        storesDirectory: `${tmpDirectory}/stores/`,
-        storeName: '/admin'
+        storesDirectory: `${tmpDirectory}/admin/`,
     }
 
     const admin = await setupMsbAdmin(testKeyPair1, tmpDirectory, rpcOpts)
@@ -91,4 +91,5 @@ describe("API acceptance tests", () => {
     registerTxPayloadsBulkTests(testContext)
     registerTxDetailsTests(testContext)
     registerAccountTests(testContext)
+    registerHealthTests(testContext)
 })

package/tests/acceptance/v1/tx/tx.test.mjs

@@ -29,70 +29,81 @@ export const registerTxTests = (context) => {
             expect(res.body).toEqual({ txDetails: null })
         })
 
-        // TODO: adjust implementation to cover tests below
-        it.skip("returns 400 for invalid hash format (too short)", async () => {
+        it("returns 400 for invalid hash format (too short)", async () => {
             const invalidHash = '0'.repeat(63)
             const res = await request(context.server).get(`/v1/tx/${invalidHash}`)
             expect(res.statusCode).toBe(400)
             expect(res.body).toEqual({ error: "Invalid transaction hash format" })
         })
 
-        it.skip("returns 400 for invalid hash format (non-hex)", async () => {
+        it("returns 400 for invalid hash format (non-hex)", async () => {
             const invalidHash = 'Z'.repeat(64)
             const res = await request(context.server).get(`/v1/tx/${invalidHash}`)
             expect(res.statusCode).toBe(400)
             expect(res.body).toEqual({ error: "Invalid transaction hash format" })
         })
 
-        it.skip("returns 400 when no hash provided", async () => {
+        it("returns 400 when no hash provided", async () => {
             const res = await request(context.server).get('/v1/tx')
             expect(res.statusCode).toBe(400)
             expect(res.body).toEqual({ error: "Transaction hash is required" })
         })
 
-        it.skip("returns 400 for hash with invalid characters", async () => {
+        it("returns 400 for hash with invalid characters", async () => {
             const invalidHash = '0b4d1c1dac48$af13212f6166017399457476a0b644850875b7f4b79df6ff89c'
             const res = await request(context.server).get(`/v1/tx/${invalidHash}`)
             expect(res.statusCode).toBe(400)
             expect(res.body).toEqual({ error: "Invalid transaction hash format" })
         })
 
-        it.skip("returns 400 for hash with special characters", async () => {
+        it("returns 400 for hash with special characters", async () => {
             const invalidHash = '!@#$%^&*'.repeat(8)
             const res = await request(context.server).get(`/v1/tx/${invalidHash}`)
             expect(res.statusCode).toBe(400)
             expect(res.body).toEqual({ error: "Invalid transaction hash format" })
         })
 
-        it.skip("returns 400 for hash with spaces", async () => {
+        it("returns 400 for hash with spaces", async () => {
             const invalidHash = '0b4d1c1dac48af13212f616601d7399457476a0b644850875b7 4b79df6ff89c'
             const res = await request(context.server).get(`/v1/tx/${invalidHash}`)
             expect(res.statusCode).toBe(400)
             expect(res.body).toEqual({ error: "Invalid transaction hash format" })
         })
 
-        it.skip("returns 400 for hash with 0x prefix", async () => {
+        it("returns 400 for hash with 0x prefix", async () => {
             const hash = "0x" + "0".repeat(62)
             const res = await request(context.server).get(`/v1/tx/${hash}`)
             expect(res.statusCode).toBe(400)
             expect(res.body).toEqual({ error: "Invalid transaction hash format" })
         })
 
-        it.skip("returns 400 for odd-length hex", async () => {
+        it("returns 400 for odd-length hex", async () => {
             const hash = "a".repeat(63)
             const res = await request(context.server).get(`/v1/tx/${hash}`)
             expect(res.statusCode).toBe(400)
             expect(res.body).toEqual({ error: "Invalid transaction hash format" })
         })
 
-        it.skip("accepts uppercase hex", async () => {
-            const hash = "A".repeat(64)
-            const res = await request(context.server).get(`/v1/tx/${hash}`)
-            expect(res.statusCode).toBe(200)
-        })
 
-        it.skip("returns 400 for trailing space hash", async () => {
-            const hash = `${"a".repeat(64)} `
+        it("accepts uppercase hex", async () => {
+            const { payload, txHashHex } = await buildRpcSelfTransferPayload(context, context.rpcMsb.state, 1n);
+            
+            // Send the transaction
+            await request(context.server)
+                .post("/v1/broadcast-transaction")
+                .send(JSON.stringify({ payload }));
+
+            // Waits for the node indexer to process
+            await new Promise(resolve => setTimeout(resolve, 500)); 
+
+            const uppercaseHash = txHashHex.toUpperCase();
+            const res = await request(context.server).get(`/v1/tx/${uppercaseHash}`);
+            
+            expect(res.statusCode).toBe(200);
+        });
+
+        it("returns 400 for trailing space hash", async () => {
+            const hash = "a".repeat(64) + "%20" // Forcing space
             const res = await request(context.server).get(`/v1/tx/${hash}`)
             expect(res.statusCode).toBe(400)
         })

package/tests/acceptance/v1/tx-details/tx-details.test.mjs

@@ -182,18 +182,32 @@ export const registerTxDetailsTests = (context) => {
             expect(res.body).toEqual({ error: "Invalid transaction hash format" })
         })
 
-        // TODOadjust implementation to cover tests below
-        it.skip("accepts uppercase hex", async () => {
-            const hash = "A".repeat(64)
-            const res = await request(context.server).get(`/v1/tx/details/${hash}?confirmed=false`)
-            expect([200]).toContain(res.statusCode)
-            expect(res.statusCode).toBe(200)
-        })
+        it("accepts uppercase hex", async () => {
+            const { payload, txHashHex } = await buildRpcSelfTransferPayload(
+                context,
+                context.rpcMsb.state,
+                1n
+            );
 
-        it.skip("returns 400 for trailing space hash", async () => {
-            const hash = `${"a".repeat(64)} `
-            const res = await request(context.server).get(`/v1/tx/details/${hash}`)
-            expect(res.statusCode).toBe(400)
-        })
+            await waitForConnection(context.rpcMsb);
+            await request(context.server)
+                .post("/v1/broadcast-transaction")
+                .send(JSON.stringify({ payload }));
+
+            const upperHash = txHashHex.toUpperCase();
+            const res = await request(context.server)
+                .get(`/v1/tx/details/${upperHash}?confirmed=false`);
+
+            expect(res.statusCode).toBe(200);
+        });
+
+        it("returns 400 for trailing space hash", async () => {
+            const hash = "a".repeat(64) + " "; 
+            const res = await request(context.server)
+                .get(`/v1/tx/details/${encodeURIComponent(hash)}`);
+            
+            expect(res.statusCode).toBe(400);
+            expect(res.body).toEqual({ error: "Invalid transaction hash format" });
+        });
     })
 }