trac-msb 0.2.5 → 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/tests/acceptance/v1/broadcast-transaction/broadcast-transaction.test.mjs

@@ -1,21 +1,18 @@
 import request from "supertest"
-import tracCrypto from "trac-crypto-api"
 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 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 { payload } = await buildRpcSelfTransferPayload(
+                context.wallet,
+                context.rpcMsb.state,
+                1n
+            );
             const res = await request(context.server)
                 .post("/v1/broadcast-transaction")
                 .set("Accept", "application/json")

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

@@ -1,26 +1,21 @@
 import request from "supertest"
-import tracCrypto from "trac-crypto-api"
-import b4a from "b4a"
-import { $TNK } from "../../../../src/core/state/utils/balance.js"
+import { buildRpcSelfTransferPayload } from "../../../helpers/transactionPayloads.mjs"
 
 export const registerTxTests = (context) => {
     describe("GET /v1/tx/:hash", () => {
         it("returns tx details for a broadcasted transaction", async () => {
-            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 { payload, txHashHex } = await buildRpcSelfTransferPayload(
+                context.wallet,
+                context.rpcMsb.state,
+                1n
+            );
             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/${txData.hash.toString('hex')}`)
+            const res = await request(context.server).get(`/v1/tx/${txHashHex}`)
             expect(res.statusCode).toBe(200)
             expect(res.body).toMatchObject({ txDetails: expect.any(Object) })
         })

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

@@ -1,19 +1,14 @@
 import request from "supertest"
-import tracCrypto from "trac-crypto-api"
-import b4a from "b4a"
-import { $TNK } from "../../../../src/core/state/utils/balance.js"
+import { buildRpcSelfTransferPayload } from "../../../helpers/transactionPayloads.mjs"
 
 export const registerTxDetailsTests = (context) => {
     describe("GET /v1/tx/details", () => {
         it("returns 200 for broadcasted hash (confirmed and unconfirmed)", async () => {
-            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 { payload, txHashHex } = await buildRpcSelfTransferPayload(
+                context.wallet,
+                context.rpcMsb.state,
+                1n
+            );
             const broadcastRes = await request(context.server)
                 .post("/v1/broadcast-transaction")
                 .set("Accept", "application/json")
@@ -21,7 +16,7 @@ export const registerTxDetailsTests = (context) => {
             expect(broadcastRes.statusCode).toBe(200)
 
             const resConfirmed = await request(context.server)
-                .get(`/v1/tx/details/${txData.hash.toString('hex')}?confirmed=true`)
+                .get(`/v1/tx/details/${txHashHex}?confirmed=true`)
             expect(resConfirmed.statusCode).toBe(200)
 
             expect(resConfirmed.body).toMatchObject({
@@ -31,7 +26,7 @@ export const registerTxDetailsTests = (context) => {
             })
 
             const resUnconfirmed = await request(context.server)
-                .get(`/v1/tx/details/${txData.hash.toString('hex')}?confirmed=false`)
+                .get(`/v1/tx/details/${txHashHex}?confirmed=false`)
             expect(resUnconfirmed.statusCode).toBe(200)
 
             expect(resUnconfirmed.body).toMatchObject({
@@ -42,14 +37,11 @@ export const registerTxDetailsTests = (context) => {
         })
 
         it("handles null confirmed_length for unconfirmed transaction", async () => {
-            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 { payload, txHashHex } = await buildRpcSelfTransferPayload(
+                context.wallet,
+                context.rpcMsb.state,
+                1n
+            );
 
             const originalGetConfirmedLength = context.rpcMsb.state.getTransactionConfirmedLength
             context.rpcMsb.state.getTransactionConfirmedLength = async () => null
@@ -62,7 +54,7 @@ export const registerTxDetailsTests = (context) => {
                 expect(broadcastRes.statusCode).toBe(200)
 
                 const res = await request(context.server)
-                    .get(`/v1/tx/details/${txData.hash.toString('hex')}?confirmed=false`)
+                    .get(`/v1/tx/details/${txHashHex}?confirmed=false`)
                 expect(res.statusCode).toBe(200)
 
                 expect(res.body).toMatchObject({

package/tests/helpers/transactionPayloads.mjs

@@ -0,0 +1,78 @@
+import b4a from "b4a";
+import tracCrypto from "trac-crypto-api";
+
+import { $TNK } from "../../src/core/state/utils/balance.js";
+import { createMessage } from "../../src/utils/buffer.js";
+import { blake3Hash } from "../../src/utils/crypto.js";
+import { OperationType, NETWORK_ID } from "../../src/utils/constants.js";
+import { addressToBuffer } from "../../src/core/state/utils/address.js";
+
+/**
+ * Build a base64-encoded transfer payload and matching tx hash
+ * that are compatible with MSB's PartialTransfer validator.
+ *
+ * This helper mirrors the hashing/signing logic used by
+ * PartialOperation.validateSignature, so that tests broadcast
+ * transactions the node will accept without touching consensus code.
+ *
+ * @param {import("trac-wallet").default} wallet - Writer wallet used for signing.
+ * @param {import("../../src/core/state/State.js").default} state - MSB state instance.
+ * @param {bigint} [amountTnk=1n] - Transfer amount in TNK units.
+ * @returns {Promise<{ payload: string, txHashHex: string }>}
+ */
+export async function buildRpcSelfTransferPayload(wallet, state, amountTnk = 1n) {
+    const txvBuffer = await state.getIndexerSequenceState();
+    const txvHex = b4a.toString(txvBuffer, "hex");
+
+    const txData = await tracCrypto.transaction.preBuild(
+        wallet.address,
+        wallet.address,
+        b4a.toString($TNK(amountTnk), "hex"),
+        txvHex
+    );
+
+    const nonceHex = b4a.toString(txData.nonce, "hex");
+    const amountHex = txData.amount;
+    const toAddress = txData.to;
+
+    const txvBuf = b4a.from(txData.validity, "hex");
+    const nonceBuf = b4a.from(nonceHex, "hex");
+    const amountBuf = b4a.from(amountHex, "hex");
+    const toBuf = addressToBuffer(toAddress);
+
+    const message = createMessage(
+        NETWORK_ID,
+        txvBuf,
+        toBuf,
+        amountBuf,
+        nonceBuf,
+        OperationType.TRANSFER
+    );
+
+    const messageHash = await blake3Hash(message);
+    const signature = wallet.sign(messageHash);
+
+    const payloadObject = {
+        type: OperationType.TRANSFER,
+        address: wallet.address,
+        tro: {
+            tx: b4a.toString(messageHash, "hex"),
+            txv: txData.validity,
+            in: nonceHex,
+            to: toAddress,
+            am: amountHex,
+            is: b4a.toString(signature, "hex")
+        }
+    };
+
+    const payload = b4a.toString(
+        b4a.from(JSON.stringify(payloadObject)),
+        "base64"
+    );
+
+    return {
+        payload,
+        txHashHex: b4a.toString(messageHash, "hex")
+    };
+}
+