trac-msb 0.2.18 → 0.2.19

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

@@ -1,116 +0,0 @@
-import request from "supertest"
-import b4a from "b4a"
-import { buildRpcSelfTransferPayload, waitForConnection } from "../../../helpers/transactionPayloads.mjs"
-
-const toBase64 = (value) => b4a.toString(b4a.from(JSON.stringify(value)), "base64")
-
-export const registerBroadcastTransactionTests = (context) => {
-    describe("POST /v1/broadcast-transaction", () => {
-        it("broadcasts transaction and returns lengths", async () => {
-            const { payload } = await buildRpcSelfTransferPayload(
-                context,
-                context.rpcMsb.state,
-                1n
-            );
-            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(200)
-            expect(res.body).toMatchObject({
-                result: {
-                    message: "Transaction broadcasted successfully.",
-                    signedLength: expect.any(Number),
-                    unsignedLength: expect.any(Number),
-                    tx: expect.any(String)
-                }
-            })
-        })
-
-        it("returns 400 when payload is missing", async () => {
-            await waitForConnection(context.rpcMsb)
-            const res = await request(context.server)
-                .post("/v1/broadcast-transaction")
-                .set("Accept", "application/json")
-                .send(JSON.stringify({}))
-
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({ error: "Payload is missing." })
-        })
-
-        it("returns 400 when payload is not base64", async () => {
-            await waitForConnection(context.rpcMsb)
-            const res = await request(context.server)
-                .post("/v1/broadcast-transaction")
-                .set("Accept", "application/json")
-                .send(JSON.stringify({ payload: "not-base64" }))
-
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({ error: "Payload must be a valid base64 string." })
-        })
-
-        it("returns 400 when decoded payload is not valid JSON", async () => {
-            const invalidJsonBase64 = b4a.toString(b4a.from("{{invalid"), "base64")
-
-            await waitForConnection(context.rpcMsb)
-            const res = await request(context.server)
-                .post("/v1/broadcast-transaction")
-                .set("Accept", "application/json")
-                .send(JSON.stringify({ payload: invalidJsonBase64 }))
-
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({ error: "Decoded payload is not valid JSON." })
-        })
-
-        it("returns 400 for invalid transaction structure", async () => {
-            const invalidStructure = {
-                type: 1,
-                address: context.wallet.address,
-            }
-
-            await waitForConnection(context.rpcMsb)
-            const res = await request(context.server)
-                .post("/v1/broadcast-transaction")
-                .set("Accept", "application/json")
-                .send(JSON.stringify({ payload: toBase64(invalidStructure) }))
-
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({ error: "Invalid payload structure." })
-        })
-
-        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);
-            const res = await request(context.server)
-                .post("/v1/broadcast-transaction")
-                .set("Accept", "application/json")
-                .send(JSON.stringify({ payload }));
-
-            expect(res.statusCode).toBe(413);
-        });
-
-
-        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; 
-
-            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/confirmed-length/confirmed-length.test.mjs

@@ -1,19 +0,0 @@
-import request from "supertest"
-
-export const registerConfirmedLengthTests = (context) => {
-    describe("GET /v1/confirmed-length", () => {
-        it("returns confirmed length", async () => {
-            const res = await request(context.server).get("/v1/confirmed-length")
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual({ confirmed_length: expect.any(Number) })
-        })
-
-        it("matches signed length from state", async () => {
-            const res = await request(context.server).get("/v1/confirmed-length")
-            expect(res.statusCode).toBe(200)
-
-            const signedLength = context.rpcMsb.state.getSignedLength()
-            expect(res.body).toEqual({ confirmed_length: signedLength })
-        })
-    })
-}

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

@@ -1,11 +0,0 @@
-import request from "supertest"
-
-export const registerFeeTests = (context) => {
-    describe("GET /v1/fee", () => {
-        it("returns fee", async () => {
-            const res = await request(context.server).get("/v1/fee")
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual({ fee: expect.stringMatching(/^-?\d+(\.\d+)?$/) })
-        })
-    })
-}

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

@@ -1,33 +0,0 @@
-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

@@ -1,95 +0,0 @@
-import { createServer } from "../../../rpc/create_server.js"
-import { initTemporaryDirectory } from '../../helpers/setupApplyTests.js'
-import { testKeyPair1, testKeyPair2, testKeyPair3 } from '../../fixtures/apply.fixtures.js'
-import { randomBytes, setupMsbAdmin, setupMsbWriter, removeTemporaryDirectory, setupMsbPeer, tryToSyncWriters, waitForNodeState } from "../../helpers/setupApplyTests.js"
-import { registerAccountTests } from "./account/account.test.mjs"
-import { registerBalanceTests } from "./balance/balance.test.mjs"
-import { registerBroadcastTransactionTests } from "./broadcast-transaction/broadcast-transaction.test.mjs"
-import { registerConfirmedLengthTests } from "./confirmed-length/confirmed-length.test.mjs"
-import { registerFeeTests } from "./fee/fee.test.mjs"
-import { registerTxHashesTests } from "./tx-hashes/tx-hashes.test.mjs"
-import { registerTxPayloadsBulkTests } from "./tx-payloads-bulk/tx-payloads-bulk.test.mjs"
-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
-const additionalPeers = []
-
-const testContext = {
-    writerMsb: null,
-    rpcMsb: null,
-    server: null,
-    wallet: null,
-    adminWallet: null,
-}
-
-const setupNetwork = async () => {
-    tmpDirectory = await initTemporaryDirectory()
-    const rpcOpts = {
-        bootstrap: randomBytes(32).toString('hex'),
-        channel: randomBytes(32).toString('hex'),
-        enableRoleRequester: false,
-        enableWallet: true,
-        enableValidatorObserver: true,
-        enableInteractiveMode: false,
-        disableRateLimit: true,
-        enableTxApplyLogs: false,
-        storesDirectory: `${tmpDirectory}/admin/`,
-    }
-
-    const admin = await setupMsbAdmin(testKeyPair1, tmpDirectory, rpcOpts)
-    const writer = await setupMsbWriter(admin, 'writer', testKeyPair2, tmpDirectory, admin.options);
-    additionalPeers.push(writer)
-    const reader = await setupMsbPeer('peer-2', testKeyPair3, tmpDirectory, { ...admin.options, enable_wallet: false });
-    additionalPeers.push(reader)
-    await tryToSyncWriters(admin, writer, reader)
-    await waitForNodeState(reader, writer.wallet.address, {
-        wk: writer.msb.state.writingKey,
-        isWhitelisted: true,
-        isWriter: true,
-        isIndexer: false,
-    })
-    return { writer, admin, reader }
-}
-
-beforeAll(async () => {
-    const { admin, writer, reader } = await setupNetwork()
-    const server = createServer(reader.msb, reader.config)
-    toClose = admin.msb
-    Object.assign(testContext, {
-        writerMsb: writer.msb,
-        rpcMsb: reader.msb,
-        server,
-        wallet: writer.msb.wallet,
-        adminWallet: admin.wallet,
-    })
-})
-
-afterAll(async () => {
-    const peersToClose = [...new Set(additionalPeers.map(peer => peer?.msb).filter(Boolean))]
-    await Promise.all([
-        toClose?.close(),
-        ...peersToClose.map(instance => instance.close())
-    ])
-    await removeTemporaryDirectory(tmpDirectory)
-})
-
-// The order here is important since the OPs change the network state. We wont boot up an instance before each because the tests are to verify rpc structure and the decision is to spare ci resources.
-describe("API acceptance tests", () => {
-    registerConfirmedLengthTests(testContext)
-    registerUnconfirmedLengthTests(testContext)
-    registerTxvTests(testContext)
-    registerFeeTests(testContext)
-    registerTxHashesTests(testContext)
-    registerTxTests(testContext)
-    registerBalanceTests(testContext)
-    registerBroadcastTransactionTests(testContext)
-    registerTxPayloadsBulkTests(testContext)
-    registerTxDetailsTests(testContext)
-    registerAccountTests(testContext)
-    registerHealthTests(testContext)
-})

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

@@ -1,133 +0,0 @@
-import request from "supertest"
-import { buildRpcSelfTransferPayload, waitForConnection } from "../../../helpers/transactionPayloads.mjs"
-import { sleep } from "../../../../src/utils/helpers.js"
-
-const TX_ENDPOINT_TIMEOUT_MS = 4000
-const TX_ENDPOINT_RETRY_INTERVAL_MS = 100
-
-const waitForStatusCode = async (requestFactory, expectedStatusCode, timeoutMs = TX_ENDPOINT_TIMEOUT_MS) => {
-    const startedAt = Date.now()
-    let response = null
-
-    while ((Date.now() - startedAt) < timeoutMs) {
-        response = await requestFactory()
-        if (response.statusCode === expectedStatusCode) {
-            return response
-        }
-        await sleep(TX_ENDPOINT_RETRY_INTERVAL_MS)
-    }
-
-    return response
-}
-
-export const registerTxTests = (context) => {
-    describe("GET /v1/tx/:hash", () => {
-        it("returns tx details for a broadcasted transaction", async () => {
-            const { payload, txHashHex } = await buildRpcSelfTransferPayload(
-                context,
-                context.rpcMsb.state,
-                1n
-            );
-
-            await waitForConnection(context.rpcMsb)
-            const broadcastRes = await request(context.server)
-                .post("/v1/broadcast-transaction")
-                .set("Accept", "application/json")
-                .send(JSON.stringify({ payload }))
-            expect(broadcastRes.statusCode).toBe(200)
-
-            const res = await waitForStatusCode(
-                () => request(context.server).get(`/v1/tx/${txHashHex}`),
-                200
-            )
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toMatchObject({ txDetails: expect.any(Object) })
-        })
-
-        it("returns 404 for non-existent transaction hash", async () => {
-            const nonExistentHash = "0b4d1c1dac48af13212f616601d7399457476a0b644850875b7f4b79df6ff89c"
-            const res = await request(context.server).get(`/v1/tx/${nonExistentHash}`)
-            expect(res.statusCode).toBe(404)
-            expect(res.body).toEqual({ txDetails: null })
-        })
-
-        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("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("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("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("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("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("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("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("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

@@ -1,241 +0,0 @@
-import request from "supertest"
-import { buildRpcSelfTransferPayload, waitForConnection } from "../../../helpers/transactionPayloads.mjs"
-import { sleep } from "../../../../src/utils/helpers.js"
-
-const TX_DETAILS_TIMEOUT_MS = 4000
-const TX_DETAILS_RETRY_INTERVAL_MS = 100
-
-const waitForStatusCode = async (requestFactory, expectedStatusCode, timeoutMs = TX_DETAILS_TIMEOUT_MS) => {
-    const startedAt = Date.now()
-    let response = null
-
-    while ((Date.now() - startedAt) < timeoutMs) {
-        response = await requestFactory()
-        if (response.statusCode === expectedStatusCode) {
-            return response
-        }
-        await sleep(TX_DETAILS_RETRY_INTERVAL_MS)
-    }
-
-    return response
-}
-
-export const registerTxDetailsTests = (context) => {
-    describe("GET /v1/tx/details", () => {
-        it("returns 200 for broadcasted hash (confirmed and unconfirmed)", async () => {
-            const { payload, txHashHex } = await buildRpcSelfTransferPayload(
-                context,
-                context.rpcMsb.state,
-                1n
-            );
-
-            await waitForConnection(context.rpcMsb)
-            const broadcastRes = await request(context.server)
-                .post("/v1/broadcast-transaction")
-                .set("Accept", "application/json")
-                .send(JSON.stringify({ payload }))
-            expect(broadcastRes.statusCode).toBe(200)
-
-            const resConfirmed = await waitForStatusCode(
-                () => request(context.server)
-                    .get(`/v1/tx/details/${txHashHex}?confirmed=true`),
-                200
-            )
-            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 waitForStatusCode(
-                () => request(context.server)
-                    .get(`/v1/tx/details/${txHashHex}?confirmed=false`),
-                200
-            )
-            expect(resUnconfirmed.statusCode).toBe(200)
-
-            expect(resUnconfirmed.body).toMatchObject({
-                txDetails: expect.any(Object),
-                confirmed_length: expect.any(Number),
-                fee: expect.any(String)
-            })
-        })
-
-        it("handles null confirmed_length for unconfirmed transaction", async () => {
-            const { payload, txHashHex } = await buildRpcSelfTransferPayload(
-                context,
-                context.rpcMsb.state,
-                1n
-            );
-
-            const originalGetConfirmedLength = context.rpcMsb.state.getTransactionConfirmedLength
-            context.rpcMsb.state.getTransactionConfirmedLength = async () => null
-
-            try {
-
-                await waitForConnection(context.rpcMsb)
-                const broadcastRes = await request(context.server)
-                    .post("/v1/broadcast-transaction")
-                    .set("Accept", "application/json")
-                    .send(JSON.stringify({ payload }))
-                expect(broadcastRes.statusCode).toBe(200)
-
-                const res = await waitForStatusCode(
-                    () => request(context.server)
-                        .get(`/v1/tx/details/${txHashHex}?confirmed=false`),
-                    200
-                )
-                expect(res.statusCode).toBe(200)
-
-                expect(res.body).toMatchObject({
-                    txDetails: expect.any(Object),
-                    confirmed_length: 0,
-                    fee: '0'
-                })
-            } finally {
-                context.rpcMsb.state.getTransactionConfirmedLength = originalGetConfirmedLength
-            }
-        })
-
-        it("returns 404 for non-existent transaction hash", async () => {
-            const nonExistentHash = "0b4d1c1dac48af13212f616601d7399457476a0b644850875b7f4b79df6ff89c"
-            const res = await request(context.server)
-                .get(`/v1/tx/details/${nonExistentHash}`)
-
-            expect(res.statusCode).toBe(404)
-            expect(res.body).toEqual({
-                error: `No payload found for tx hash: ${nonExistentHash}`
-            })
-        })
-
-        it("returns 400 for invalid hash format (too short)", async () => {
-            const invalidHash = '0'.repeat(63)
-            const res = await request(context.server)
-                .get(`/v1/tx/details/${invalidHash}`)
-
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({
-                error: "Invalid transaction hash format"
-            })
-        })
-
-        it("returns 400 for invalid hash format (non-hex)", async () => {
-            const invalidHash = 'Z'.repeat(64)
-            const res = await request(context.server)
-                .get(`/v1/tx/details/${invalidHash}`)
-
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({
-                error: "Invalid transaction hash format"
-            })
-        })
-
-        it("returns 400 for invalid confirmed parameter", async () => {
-            const hash = "0b4d1c1dac48af13212f616601d7399457476a0b644850875b7f4b79df6ff89c"
-
-            const res = await request(context.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("returns 400 for invalid confirmed parameter case (UPPERCASE)", async () => {
-            const hash = "0b4d1c1dac48af13212f616601d7399457476a0b644850875b7f4b79df6ff89c"
-            const res = await request(context.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("returns 400 when no hash provided", async () => {
-            const res = await request(context.server)
-                .get('/v1/tx/details')
-
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({
-                error: "Transaction hash is required"
-            })
-        })
-
-        it("returns 400 for hash with invalid characters", async () => {
-            const invalidHash = '0b4d1c1dac48$af13212f6166017399457476a0b644850875b7f4b79df6ff89c'
-            const res = await request(context.server)
-                .get(`/v1/tx/details/${invalidHash}`)
-
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({
-                error: "Invalid transaction hash format"
-            })
-        })
-
-        it("returns 400 for hash with special characters", async () => {
-            const invalidHash = '!@#$%^&*'.repeat(8)
-            const res = await request(context.server)
-                .get(`/v1/tx/details/${invalidHash}`)
-
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({
-                error: "Invalid transaction hash format"
-            })
-        })
-
-        it("returns 400 for hash with spaces", async () => {
-            const invalidHash = '0b4d1c1dac48af13212f616601d7399457476a0b644850875b7 4b79df6ff89c'
-            const res = await request(context.server)
-                .get(`/v1/tx/details/${invalidHash}`)
-
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({
-                error: "Invalid transaction hash format"
-            })
-        })
-
-        it("returns 400 for hash with 0x prefix", async () => {
-            const hash = "0x" + "0".repeat(62)
-            const res = await request(context.server).get(`/v1/tx/details/${hash}`)
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({ error: "Invalid transaction hash format" })
-        })
-
-        it("returns 400 for odd-length hex", async () => {
-            const hash = "a".repeat(63)
-            const res = await request(context.server).get(`/v1/tx/details/${hash}`)
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({ error: "Invalid transaction hash format" })
-        })
-
-        it("accepts uppercase hex", async () => {
-            const { payload, txHashHex } = await buildRpcSelfTransferPayload(
-                context,
-                context.rpcMsb.state,
-                1n
-            );
-
-            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" });
-        });
-    })
-}