trac-msb 0.2.17 → 0.2.19

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

@@ -1,123 +0,0 @@
-import request from "supertest"
-import { bufferToBigInt, licenseBufferToBigInt } from "../../../../src/utils/amountSerialization.js"
-import { ZERO_WK } from "../../../../rpc/constants.js"
-import { ADMIN_INITIAL_STAKED_BALANCE } from "../../../../src/utils/constants.js"
-import { BALANCE_TO_STAKE } from "../../../../src/core/state/utils/balance.js"
-import { randomAddress } from "../../../unit/state/stateTestUtils.js"
-
-export const registerAccountTests = (context) => {
-    const formatNodeEntryResponse = (address, entry) => {
-        const licenseValue = licenseBufferToBigInt(entry.license)
-        return {
-            address,
-            writingKey: entry.wk.toString('hex'),
-            isWhitelisted: entry.isWhitelisted,
-            isValidator: entry.isWriter,
-            isIndexer: entry.isIndexer,
-            license: licenseValue === 0n ? null : licenseValue.toString(),
-            balance: bufferToBigInt(entry.balance).toString(),
-            stakedBalance: bufferToBigInt(entry.stakedBalance).toString(),
-        }
-    }
-
-    describe("GET /v1/account", () => {
-        it("returns admin account details", async () => {
-            const adminEntry = await context.rpcMsb.state.getNodeEntry(context.adminWallet.address)
-            expect(adminEntry).toBeTruthy()
-
-            const res = await request(context.server).get(`/v1/account/${context.adminWallet.address}`)
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual(formatNodeEntryResponse(context.adminWallet.address, adminEntry))
-            expect(res.body).toMatchObject({
-                isWhitelisted: true,
-                isValidator: true,
-                isIndexer: true,
-                stakedBalance: bufferToBigInt(ADMIN_INITIAL_STAKED_BALANCE).toString(),
-                license: '1',
-            })
-        })
-
-        it("returns validator account details", async () => {
-            const writerEntry = await context.rpcMsb.state.getNodeEntry(context.wallet.address)
-            expect(writerEntry).toBeTruthy()
-
-            const res = await request(context.server).get(`/v1/account/${context.wallet.address}`)
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual(formatNodeEntryResponse(context.wallet.address, writerEntry))
-            expect(res.body).toMatchObject({
-                isWhitelisted: true,
-                isValidator: true,
-                stakedBalance: bufferToBigInt(BALANCE_TO_STAKE.value).toString(),
-            })
-            expect(res.body.license).not.toBeNull()
-            expect(res.body.license).not.toBe('1')
-        })
-
-        it("returns validator account details when confirmed=true", async () => {
-            const confirmedEntry = await context.rpcMsb.state.getNodeEntry(context.wallet.address)
-            expect(confirmedEntry).toBeTruthy()
-
-            const res = await request(context.server).get(`/v1/account/${context.wallet.address}?confirmed=true`)
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual(formatNodeEntryResponse(context.wallet.address, confirmedEntry))
-        })
-
-        it("returns validator account details (unconfirmed view)", async () => {
-            const unsignedEntry = await context.rpcMsb.state.getNodeEntryUnsigned(context.wallet.address)
-            expect(unsignedEntry).toBeTruthy()
-
-            const res = await request(context.server).get(`/v1/account/${context.wallet.address}?confirmed=false`)
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual(formatNodeEntryResponse(context.wallet.address, unsignedEntry))
-        })
-
-        it("returns default state for non-existent node", async () => {
-            const address = randomAddress(context.rpcMsb.config.addressPrefix)
-
-            const res = await request(context.server).get(`/v1/account/${address}`)
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual({
-                address: address,
-                writingKey: ZERO_WK.toString('hex'),
-                isWhitelisted: false,
-                isValidator: false,
-                isIndexer: false,
-                license: null,
-                balance: '0',
-                stakedBalance: '0',
-            })
-        })
-
-        it("returns 400 when address is missing", async () => {
-            const res = await request(context.server).get("/v1/account")
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({ error: "Account address is required" })
-        })
-
-        it("returns 400 for invalid address format", async () => {
-            const res = await request(context.server).get("/v1/account/not-a-valid-address")
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({ error: "Invalid account address format" })
-        })
-
-        it("returns 400 for invalid confirmed parameter", async () => {
-            const res = await request(context.server).get(`/v1/account/${context.wallet.address}?confirmed=test`)
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({ error: 'Parameter "confirmed" must be exactly "true" or "false"' })
-        })
-
-        it("returns 500 on internal error", async () => {
-            const originalGetNodeEntry = context.rpcMsb.state.getNodeEntry
-
-            context.rpcMsb.state.getNodeEntry = async () => { throw new Error("test") }
-
-            try {
-                const res = await request(context.server).get(`/v1/account/${context.wallet.address}`)
-                expect(res.statusCode).toBe(500)
-                expect(res.body).toEqual({ error: 'An error occurred processing the request.' })
-            } finally {
-                context.rpcMsb.state.getNodeEntry = originalGetNodeEntry
-            }
-        })
-    })
-}

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

@@ -1,54 +0,0 @@
-import request from "supertest"
-import { randomAddress } from "../../../unit/state/stateTestUtils.js"
-
-export const registerBalanceTests = (context) => {
-    let expectedBalance
-    describe("GET /v1/balance", () => {
-        it("returns balance for confirmed view by default", async () => {
-            const res = await request(context.server).get(`/v1/balance/${context.wallet.address}`)
-            expect(res.statusCode).toBe(200)
-            expect(res.body.address).toBe(context.wallet.address)
-            expect(typeof res.body.balance).toBe("string")
-            expectedBalance = res.body.balance
-        })
-
-        it("returns balance for unconfirmed view", async () => {
-            const res = await request(context.server).get(`/v1/balance/${context.wallet.address}?confirmed=false`)
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual({ address: context.wallet.address, balance: expectedBalance })
-        })
-
-        it("returns balance when confirmed flag is explicitly true", async () => {
-            const res = await request(context.server).get(`/v1/balance/${context.wallet.address}?confirmed=true`)
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual({ address: context.wallet.address, balance: expectedBalance })
-        })
-
-        it("falls back to unconfirmed view on invalid confirmed flag", async () => {
-            const res = await request(context.server).get(`/v1/balance/${context.wallet.address}?confirmed=test`)
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual({ address: context.wallet.address, balance: expectedBalance })
-        })
-
-        it("returns 400 when address is missing", async () => {
-            const res = await request(context.server).get("/v1/balance")
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({ error: "Wallet address is required" })
-        })
-
-        it("returns zero balance for an unknown address", async () => {
-            const address = randomAddress(context.rpcMsb.config.addressPrefix)
-            const res = await request(context.server).get(`/v1/balance/${address}`)
-            expect(res.statusCode).toBe(200)
-            expect(res.body.address).toBe(address)
-            expect(BigInt(res.body.balance)).toBe(0n)
-        })
-
-        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)
-            expect(res.body).toEqual({ error: "Invalid account address format" })
-        })
-    })
-}

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,111 +0,0 @@
-import request from "supertest"
-import { buildRpcSelfTransferPayload, waitForConnection } from "../../../helpers/transactionPayloads.mjs"
-
-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 request(context.server).get(`/v1/tx/${txHashHex}`)
-            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)
-        })
-    })
-}