trac-msb 0.2.4 → 0.2.6

package/src/utils/cliCommands.js

@@ -0,0 +1,280 @@
+import { ZERO_WK } from "./buffer.js";
+import { bigIntToDecimalString, bufferToBigInt } from "./amountSerialization.js";
+import { normalizeDecodedPayloadForJson } from "./normalizers.js";
+import { get_confirmed_tx_info, get_unconfirmed_tx_info } from "./cli.js";
+import { EntryType } from "./constants.js";
+import { bufferToAddress } from "../core/state/utils/address.js";
+import deploymentEntryUtils from "../core/state/utils/deploymentEntry.js";
+import { safeDecodeApplyOperation } from "./protobuf/operationHelpers.js";
+
+export async function getBalanceCommand(state, address, confirmedFlag) {
+    const unconfirmedBalance = confirmedFlag === "false";
+    const nodeEntry = unconfirmedBalance
+        ? await state.getNodeEntryUnsigned(address)
+        : await state.getNodeEntry(address);
+
+    if (nodeEntry) {
+        console.log({
+            Address: address,
+            Balance: bigIntToDecimalString(bufferToBigInt(nodeEntry.balance))
+        });
+        return {
+            address,
+            balance: bufferToBigInt(nodeEntry.balance).toString()
+        };
+    }
+
+    console.log("Node Entry:", {
+        WritingKey: ZERO_WK.toString("hex"),
+        IsWhitelisted: false,
+        IsWriter: false,
+        IsIndexer: false,
+        balance: bigIntToDecimalString(0n)
+    });
+}
+
+export async function nodeStatusCommand(state, address) {
+    const nodeEntry = await state.getNodeEntry(address);
+    if (nodeEntry) {
+        const licenseValue = nodeEntry.license.readUInt32BE(0);
+        const licenseDisplay = licenseValue === 0 ? "N/A" : licenseValue.toString();
+        console.log("Node Status:", {
+            Address: address,
+            WritingKey: nodeEntry.wk.toString("hex"),
+            IsWhitelisted: nodeEntry.isWhitelisted,
+            IsWriter: nodeEntry.isWriter,
+            IsIndexer: nodeEntry.isIndexer,
+            License: licenseDisplay,
+            StakedBalance: bigIntToDecimalString(bufferToBigInt(nodeEntry.stakedBalance)),
+            Balance: bigIntToDecimalString(bufferToBigInt(nodeEntry.balance))
+        });
+        return {
+            address,
+            writingKey: nodeEntry.wk.toString("hex"),
+            isWhitelisted: nodeEntry.isWhitelisted,
+            isWriter: nodeEntry.isWriter,
+            isIndexer: nodeEntry.isIndexer,
+            license: licenseDisplay,
+            stakedBalance: bigIntToDecimalString(bufferToBigInt(nodeEntry.stakedBalance))
+        };
+    }
+
+    console.log("Node Status:", {
+        WritingKey: ZERO_WK.toString("hex"),
+        IsWhitelisted: false,
+        IsWriter: false,
+        IsIndexer: false,
+        license: "N/A",
+        stakedBalance: "0"
+    });
+}
+
+export async function coreInfoCommand(state) {
+    const admin = await state.getAdminEntry();
+    console.log("Admin:", admin ? {
+        address: admin.address,
+        writingKey: admin.wk.toString("hex")
+    } : null);
+    const formattedIndexers = await state.getIndexersEntry().then(entry => entry ? entry : null);
+    if (!formattedIndexers || (Array.isArray(formattedIndexers) && formattedIndexers.length === 0)) {
+        console.log("Indexers: no indexers");
+    } else {
+        console.log("Indexers:", formattedIndexers);
+    }
+}
+
+export async function getValidatorAddressCommand(state, wkHexString) {
+    const payload = await state.getSigned(EntryType.WRITER_ADDRESS + wkHexString);
+    if (payload === null) {
+        console.log(`No address assigned to the writer key: ${wkHexString}`);
+    } else {
+        console.log(`Address assigned to the writer key: ${wkHexString} - ${bufferToAddress(payload)}`);
+    }
+}
+
+export async function getDeploymentCommand(state, bootstrapHex) {
+    const deploymentEntry = await state.getRegisteredBootstrapEntry(bootstrapHex);
+    console.log(`Searching deployment for bootstrap: ${bootstrapHex}`);
+    if (deploymentEntry) {
+        const decodedDeploymentEntry = deploymentEntryUtils.decode(deploymentEntry);
+        const txhash = decodedDeploymentEntry.txHash.toString("hex");
+        console.log(`Bootstrap deployed under transaction hash: ${txhash}`);
+        const payload = await state.getSigned(txhash);
+        if (payload) {
+            const decoded = safeDecodeApplyOperation(payload);
+            console.log("Decoded Bootstrap Deployment Payload:", decoded);
+        } else {
+            console.log(`No payload found for transaction hash: ${txhash}`);
+        }
+    } else {
+        console.log(`No deployment found for bootstrap: ${bootstrapHex}`);
+    }
+}
+
+export async function getTxInfoCommand(state, txHash) {
+    const txInfo = await get_confirmed_tx_info(state, txHash);
+    if (txInfo) {
+        console.log(`Payload for transaction hash ${txHash}:`);
+        console.log(txInfo.decoded);
+    } else {
+        console.log(`No information found for transaction hash: ${txHash}`);
+    }
+}
+
+export async function getLicenseNumberCommand(state, address) {
+    const nodeEntry = await state.getNodeEntry(address);
+    if (nodeEntry) {
+        console.log({
+            Address: address,
+            License: bufferToBigInt(nodeEntry.license).toString()
+        });
+    }
+}
+
+export async function getLicenseAddressCommand(state, licenseId) {
+    if (isNaN(licenseId) || licenseId < 0) {
+        console.log("Invalid license ID. Please provide a valid non-negative number.");
+        return;
+    }
+
+    const address = await state.getAddressByLicenseId(licenseId);
+    if (address) {
+        console.log({
+            LicenseId: licenseId,
+            Address: address
+        });
+    } else {
+        console.log(`No address found for license ID: ${licenseId}`);
+    }
+}
+
+export async function getLicenseCountCommand(state, isAdminFn) {
+    const adminEntry = await state.getAdminEntry();
+
+    if (!adminEntry) {
+        throw new Error("Cannot read license count. Admin does not exist");
+    }
+
+    if (!isAdminFn(adminEntry)) {
+        throw new Error("Cannot perform this operation - you are not the admin!.");
+    }
+
+    const licenseCount = await state.getLicenseCount();
+    console.log({
+        LicensesCount: licenseCount
+    });
+}
+
+export async function getTxvCommand(state) {
+    const txv = await state.getIndexerSequenceState();
+    console.log("Current TXV:", txv.toString("hex"));
+    return txv;
+}
+
+export function getFeeCommand(state) {
+    const fee = state.getFee();
+    console.log("Current FEE:", bigIntToDecimalString(bufferToBigInt(fee)));
+    return bufferToBigInt(fee).toString();
+}
+
+export function getConfirmedLengthCommand(state) {
+    const confirmedLength = state.getSignedLength();
+    console.log("Confirmed_length:", confirmedLength);
+    return confirmedLength;
+}
+
+export function getUnconfirmedLengthCommand(state) {
+    const unconfirmedLength = state.getUnsignedLength();
+    console.log("Unconfirmed_length:", unconfirmedLength);
+    return unconfirmedLength;
+}
+
+export async function getTxPayloadsBulkCommand(state, hashes) {
+    if (!Array.isArray(hashes) || hashes.length === 0) {
+        throw new Error("Missing hash list.");
+    }
+
+    if (hashes.length > 1500) {
+        throw new Error("Length of input tx hashes exceeded.");
+    }
+
+    const res = { results: [], missing: [] };
+
+    const promises = hashes.map(hash => get_confirmed_tx_info(state, hash));
+    const results = await Promise.all(promises);
+
+    results.forEach((result, index) => {
+        const hash = hashes[index];
+        if (result === null || result === undefined) {
+            res.missing.push(hash);
+        } else {
+            const decodedResult = normalizeDecodedPayloadForJson(result.decoded);
+            res.results.push({ hash, payload: decodedResult });
+        }
+    });
+
+    return res;
+}
+
+export async function getTxHashesCommand(state, start, end) {
+    try {
+        const hashes = await state.confirmedTransactionsBetween(start, end);
+        return { hashes };
+    } catch (error) {
+        throw new Error("Invalid params to perform the request.", error.message);
+    }
+}
+
+export async function getTxDetailsCommand(state, hash) {
+    try {
+        const rawPayload = await get_confirmed_tx_info(state, hash);
+        if (!rawPayload) {
+            console.log(`No payload found for tx hash: ${hash}`);
+            return null;
+        }
+        return normalizeDecodedPayloadForJson(rawPayload.decoded);
+    } catch (error) {
+        throw new Error("Invalid params to perform the request.", error.message);
+    }
+}
+
+export async function getExtendedTxDetailsCommand(state, hash, confirmed) {
+    if (confirmed) {
+        const rawPayload = await get_confirmed_tx_info(state, hash);
+        if (!rawPayload) {
+            throw new Error(`No payload found for tx hash: ${hash}`);
+        }
+        const confirmedLength = await state.getTransactionConfirmedLength(hash);
+        if (confirmedLength === null) {
+            throw new Error(`No confirmed length found for tx hash: ${hash} in confirmed mode`);
+        }
+        const normalizedPayload = normalizeDecodedPayloadForJson(rawPayload.decoded, true);
+        const fee = state.getFee();
+        return {
+            txDetails: normalizedPayload,
+            confirmed_length: confirmedLength,
+            fee: bufferToBigInt(fee).toString()
+        };
+    }
+
+    const rawPayload = await get_unconfirmed_tx_info(state, hash);
+    if (!rawPayload) {
+        throw new Error(`No payload found for tx hash: ${hash}`);
+    }
+    const normalizedPayload = normalizeDecodedPayloadForJson(rawPayload.decoded, true);
+    const length = await state.getTransactionConfirmedLength(hash);
+    if (length === null) {
+        return {
+            txDetails: normalizedPayload,
+            confirmed_length: 0,
+            fee: "0"
+        };
+    }
+
+    const fee = state.getFee();
+    return {
+        txDetails: normalizedPayload,
+        confirmed_length: length,
+        fee: bufferToBigInt(fee).toString()
+    };
+}

package/src/utils/constants.js

@@ -124,4 +124,6 @@ export const TRAC_ADDRESS_SIZE =  63; // TODO: Change this to config().addressLe
 export const NETWORK_ID = 918; // TODO: Change this to config().network_id || 918
 
 export const MAX_VALIDATORS = 50
-export const MAX_RETRIES = 3
+export const MAX_RETRIES = 3
+
+export const MAX_REQUEST_COUNT = 5;

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

@@ -0,0 +1,123 @@
+import request from "supertest"
+import { bufferToBigInt, licenseBufferToBigInt } from "../../../../src/utils/amountSerialization.js"
+import { ZERO_WK } from "../../../../rpc/constants.mjs"
+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()
+
+            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

@@ -0,0 +1,55 @@
+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()
+            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)
+        })
+
+        //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 () => {
+            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

@@ -0,0 +1,111 @@
+import request from "supertest"
+import b4a from "b4a"
+import { $TNK } from "../../../../src/core/state/utils/balance.js"
+import { buildRpcSelfTransferPayload } 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.wallet,
+                context.rpcMsb.state,
+                1n
+            );
+            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 () => {
+            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 () => {
+            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." })
+        })
+
+        // TODO: enable once handler returns 400 for client-side decode errors
+        it.skip("returns 400 when decoded payload is not valid JSON", async () => {
+            const invalidJsonBase64 = b4a.toString(b4a.from("{{invalid"), "base64")
+            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." })
+        })
+
+        // TODO: enable once handler returns 400 for client-side validation errors
+        it.skip("returns 400 for invalid transaction structure", async () => {
+            const invalidStructure = {
+                type: 1,
+                address: context.wallet.address,
+            }
+            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." })
+        })
+
+        // 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 } })
+
+            const res = await request(context.server)
+                .post("/v1/broadcast-transaction")
+                .set("Accept", "application/json")
+                .send(JSON.stringify({ payload }))
+
+            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'))
+            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." })
+        })
+    })
+}

package/tests/acceptance/v1/confirmed-length/confirmed-length.test.mjs

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

@@ -0,0 +1,11 @@
+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+)?$/) })
+        })
+    })
+}