trac-msb 0.2.9 → 0.2.11

package/src/utils/protobuf/operationHelpers.js

@@ -1,7 +1,17 @@
 import applyOperations from './applyOperations.cjs';
-import networkV1Operations from './network.cjs';
+import networkV1Generated from './networkV1.generated.cjs';
 import b4a from 'b4a';
 
+const networkV1Operations = networkV1Generated.network.v1;
+const NETWORK_TO_OBJECT_OPTIONS = Object.freeze({
+    enums: Number,
+    longs: Number,
+    bytes: Buffer,
+    defaults: true,
+    arrays: true,
+    oneofs: false
+});
+
 /**
  * Safely encodes an operation using `applyOperations.Operation.encode`.
  * If the encoding fails (e.g., due to an invalid payload), returns an empty Buffer.
@@ -36,6 +46,14 @@ export const safeDecodeApplyOperation = (payload) => {
     return null;
 }
 
+export const unsafeDecodeApplyOperation= (payload) => {
+    return applyOperations.Operation.decode(payload);
+}
+
+export const unsafeEncodeApplyOperation = (payload) => {
+    return applyOperations.Operation.encode(payload);
+}
+
 export const normalizeIncomingMessage = (message) => {
     if (!message) return null;
     if (b4a.isBuffer(message)) {
@@ -51,10 +69,13 @@ export const normalizeIncomingMessage = (message) => {
 };
 
 export const encodeV1networkOperation = (payload) => {
-    return networkV1Operations.MessageHeader.encode(payload);
+    return b4a.from(networkV1Operations.MessageHeader.encode(payload).finish());
 }
 
 
 export const decodeV1networkOperation = (payload) => {
-    return networkV1Operations.MessageHeader.decode(payload);
+    return networkV1Operations.MessageHeader.toObject(
+        networkV1Operations.MessageHeader.decode(payload),
+        NETWORK_TO_OBJECT_OPTIONS
+    );
 }

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/account/account.test.mjs

@@ -108,11 +108,17 @@ export const registerAccountTests = (context) => {
 
         it("returns 500 on internal error", async () => {
             const originalGetNodeEntry = context.rpcMsb.state.getNodeEntry
+            const failingAddress = randomAddress(context.rpcMsb.config.addressPrefix)
 
-            context.rpcMsb.state.getNodeEntry = async () => { throw new Error("test") }
+            context.rpcMsb.state.getNodeEntry = async (address) => {
+                if (address === failingAddress) {
+                    throw new Error("test")
+                }
+                return originalGetNodeEntry.call(context.rpcMsb.state, address)
+            }
 
             try {
-                const res = await request(context.server).get(`/v1/account/${context.wallet.address}`)
+                const res = await request(context.server).get(`/v1/account/${failingAddress}`)
                 expect(res.statusCode).toBe(500)
                 expect(res.body).toEqual({ error: 'An error occurred processing the request.' })
             } finally {

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

@@ -1,5 +1,24 @@
 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", () => {
@@ -17,7 +36,10 @@ export const registerTxTests = (context) => {
                 .send(JSON.stringify({ payload }))
             expect(broadcastRes.statusCode).toBe(200)
 
-            const res = await request(context.server).get(`/v1/tx/${txHashHex}`)
+            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) })
         })
@@ -29,70 +51,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

@@ -1,5 +1,24 @@
 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", () => {
@@ -17,8 +36,11 @@ export const registerTxDetailsTests = (context) => {
                 .send(JSON.stringify({ payload }))
             expect(broadcastRes.statusCode).toBe(200)
 
-            const resConfirmed = await request(context.server)
-                .get(`/v1/tx/details/${txHashHex}?confirmed=true`)
+            const resConfirmed = await waitForStatusCode(
+                () => request(context.server)
+                    .get(`/v1/tx/details/${txHashHex}?confirmed=true`),
+                200
+            )
             expect(resConfirmed.statusCode).toBe(200)
 
             expect(resConfirmed.body).toMatchObject({
@@ -27,8 +49,11 @@ export const registerTxDetailsTests = (context) => {
                 fee: expect.any(String)
             })
 
-            const resUnconfirmed = await request(context.server)
-                .get(`/v1/tx/details/${txHashHex}?confirmed=false`)
+            const resUnconfirmed = await waitForStatusCode(
+                () => request(context.server)
+                    .get(`/v1/tx/details/${txHashHex}?confirmed=false`),
+                200
+            )
             expect(resUnconfirmed.statusCode).toBe(200)
 
             expect(resUnconfirmed.body).toMatchObject({
@@ -57,8 +82,11 @@ export const registerTxDetailsTests = (context) => {
                     .send(JSON.stringify({ payload }))
                 expect(broadcastRes.statusCode).toBe(200)
 
-                const res = await request(context.server)
-                    .get(`/v1/tx/details/${txHashHex}?confirmed=false`)
+                const res = await waitForStatusCode(
+                    () => request(context.server)
+                        .get(`/v1/tx/details/${txHashHex}?confirmed=false`),
+                    200
+                )
                 expect(res.statusCode).toBe(200)
 
                 expect(res.body).toMatchObject({
@@ -182,18 +210,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" });
+        });
     })
 }