trac-msb 0.2.3 → 0.2.5

package/src/core/state/State.js

@@ -74,7 +74,7 @@ class State extends ReadyResource {
             bigBatches: false,
             optimistic: false,
             open: this.#setupHyperbee.bind(this),
-            apply: this.#apply.bind(this),
+            apply: this.applyHandler,
         })
     }
 
@@ -90,6 +90,10 @@ class State extends ReadyResource {
         return this.#bootstrap;
     }
 
+    get applyHandler() {
+        return this.#apply.bind(this);
+    }
+
     async _open() {
         console.log("State initialization...")
         await this.#base.ready();
@@ -259,7 +263,7 @@ class State extends ReadyResource {
         // Retrieve the flag to verify if initialization is allowed
         let initialization = await this.getSigned(EntryType.INITIALIZATION);
 
-        if (null === initialization) {
+        if (initialization === null) {
             return false
         } else {
             return b4a.equals(initialization, safeWriteUInt32BE(0, 0))
@@ -397,7 +401,7 @@ class State extends ReadyResource {
         }
         if (invalidOperations > 0) {
             await this.#validatorPenaltyApply(batchInvoker, batch, base, invalidOperations);
-            console.info(`Applied with ${invalidOperations} invalid operations.`);
+            this.#safeLogApply(`Applied with ${invalidOperations} invalid operations.`)
         }
 
         await batch.flush();
@@ -999,7 +1003,7 @@ class State extends ReadyResource {
         // charging fee from the requester (admin)
         const decodedAdminNodeEntry = nodeEntryUtils.decode(newAdminNodeEntry)
         if (decodedAdminNodeEntry === null) {
-            this.#safeLogApply(OperationType.ADMIN_RECOVERY, "Failed to decode admin entry.", node.from.key)
+            this.#safeLogApply(OperationType.ADMIN_RECOVERY, "Failed to decode node entry.", node.from.key)
             return Status.FAILURE;
         }
 
@@ -1532,7 +1536,7 @@ class State extends ReadyResource {
         // Charging fee from the requester
         const requesterBalance = toBalance(decodedRequesterNodeEntry.balance)
         if (requesterBalance === null) {
-            this.#safeLogApply(OperationType.ADD_WRITER, "Failed to verify requester balance.", node.from.key)
+            this.#safeLogApply(OperationType.ADD_WRITER, "Invalid requester balance.", node.from.key)
             return null;
         };
 
@@ -1543,7 +1547,7 @@ class State extends ReadyResource {
 
         const updatedBalance = requesterBalance.sub(BALANCE_FEE) // Remove the fee
         if (updatedBalance === null) {
-            this.#safeLogApply(OperationType.ADD_WRITER, "Failed to apply fee to node.", node.from.key)
+            this.#safeLogApply(OperationType.ADD_WRITER, "Failed to apply fee to requester balance.", node.from.key)
             return null;
         };
 
@@ -1834,7 +1838,7 @@ class State extends ReadyResource {
         };
         const chargedNodeEntry = updatedBalance.update(updatedNodeEntry);
         if (chargedNodeEntry === null) {
-            this.#safeLogApply(OperationType.REMOVE_WRITER, "Failed to update node entry.", node.from.key)
+            this.#safeLogApply(OperationType.REMOVE_WRITER, "Failed to update node balance.", node.from.key)
             return null;
         };
 
@@ -2009,7 +2013,7 @@ class State extends ReadyResource {
 
         const pretenderNodeEntry = await this.#getEntryApply(pretendingAddressString, batch);
         if (pretenderNodeEntry === null) {
-            this.#safeLogApply(OperationType.ADD_INDEXER, "Failed to verify pretender indexer entry.", node.from.key)
+            this.#safeLogApply(OperationType.ADD_INDEXER, "Failed to verify target indexer entry.", node.from.key)
             return null;
         };
 
@@ -2074,7 +2078,7 @@ class State extends ReadyResource {
         // 100% fee charged from admin will be burned
         const newAdminBalance = adminBalance.sub(feeAmount);
         if (newAdminBalance === null) {
-            this.#safeLogApply(OperationType.ADD_INDEXER, "Failed to apply fee to requester balance", node.from.key)
+            this.#safeLogApply(OperationType.ADD_INDEXER, "Failed to apply fee to requester balance.", node.from.key)
             return null;
         };
 
@@ -2280,7 +2284,7 @@ class State extends ReadyResource {
         // 100% fee will be burned
         const newAdminBalance = adminBalance.sub(BALANCE_FEE)
         if (newAdminBalance === null) {
-            this.#safeLogApply(OperationType.REMOVE_INDEXER, "Failed to apply fee to requester balance", node.from.key)
+            this.#safeLogApply(OperationType.REMOVE_INDEXER, "Failed to apply fee to requester balance.", node.from.key)
             return null;
         };
 
@@ -2793,13 +2797,13 @@ class State extends ReadyResource {
         // validate invoker signature
         const requesterAddressBuffer = op.address;
         const requesterAddressString = addressUtils.bufferToAddress(requesterAddressBuffer);
-        if (null === requesterAddressString) {
+        if (requesterAddressString === null) {
             this.#safeLogApply(OperationType.TX, "Invalid requester address.", node.from.key)
             return Status.FAILURE;
         };
 
         const requesterPublicKey = PeerWallet.decodeBech32mSafe(requesterAddressString);
-        if (null === requesterPublicKey) {
+        if (requesterPublicKey === null) {
             this.#safeLogApply(OperationType.TX, "Failed to decode requester public key.", node.from.key)
             return Status.FAILURE;
         };
@@ -2834,13 +2838,13 @@ class State extends ReadyResource {
         //second signature
         const validatorAddressBuffer = op.txo.va;
         const validatorAddressString = addressUtils.bufferToAddress(validatorAddressBuffer);
-        if (null === validatorAddressString) {
+        if (validatorAddressString === null) {
             this.#safeLogApply(OperationType.TX, "Invalid validator address.", node.from.key)
             return Status.FAILURE;
         };
 
         const validatorPublicKey = PeerWallet.decodeBech32mSafe(validatorAddressString);
-        if (null === validatorPublicKey) {
+        if (validatorPublicKey === null) {
             this.#safeLogApply(OperationType.TX, "Failed to decode validator public key.", node.from.key)
             return Status.FAILURE;
         };
@@ -2899,7 +2903,7 @@ class State extends ReadyResource {
         // point to payload, which is pointing to the txHash.
         const bootstrapHasBeenRegistered = await this.#getDeploymentEntryApply(op.txo.bs.toString('hex'), batch);
         if (bootstrapHasBeenRegistered === null) {
-            this.#safeLogApply(OperationType.TX, "Bootstrap already registered.", node.from.key)
+            this.#safeLogApply(OperationType.TX, "Bootstrap has not been registered.", node.from.key)
             return Status.FAILURE;
         };
 
@@ -2931,7 +2935,8 @@ class State extends ReadyResource {
             batch,
             node
         );
-
+        
+        // TODO: cover next 4 guards below with tests
         if (transferFeeTxOperationResult === null) {
             this.#safeLogApply(OperationType.TX, "Fee transfer operation failed completely.", node.from.key);
             return Status.FAILURE;
@@ -3148,7 +3153,7 @@ class State extends ReadyResource {
         };
 
         if (!isSelfTransfer) {
-            if (null === transferResult.recipientEntry) {
+            if (transferResult.recipientEntry === null) {
                 this.#safeLogApply(OperationType.TRANSFER, "Invalid recipient entry.", node.from.key)
                 return Status.FAILURE;
             };
@@ -3401,7 +3406,7 @@ class State extends ReadyResource {
     async #isApplyInitalizationDisabled(batch) {
         // Retrieve the flag to verify if initialization is allowed
         let initialization = await this.#getEntryApply(EntryType.INITIALIZATION, batch);
-        if (null === initialization) {
+        if (initialization === null) {
             return false
         } else {
             return b4a.equals(initialization, safeWriteUInt32BE(0, 0))
@@ -3412,7 +3417,7 @@ class State extends ReadyResource {
         // Retrieve and increment the writers length entry
         let length = await this.#getEntryApply(EntryType.WRITERS_LENGTH, batch);
         let incrementedLength = null;
-        if (null === length) {
+        if (length === null) {
             // Initialize the writers length entry if it does not exist
             const bufferedLength = lengthEntryUtils.init(0);
             length = lengthEntryUtils.decodeBE(bufferedLength);
@@ -3596,8 +3601,8 @@ class State extends ReadyResource {
             return;
         }
 
-        const deductedStakedBalance = penalty.greaterThanOrEquals(stakedBalance) ? BALANCE_ZERO : stakedBalance.sub(penalty);        
-        
+        const deductedStakedBalance = penalty.greaterThanOrEquals(stakedBalance) ? BALANCE_ZERO : stakedBalance.sub(penalty);
+
         if (deductedStakedBalance === null) {
             this.#safeLogApply("ValidatorPenalty", `Failed to subtract penalty from staked balance for validator address: ${validatorAddressString}`, writingKeyBuffer);
             return;
@@ -3668,7 +3673,7 @@ class State extends ReadyResource {
     async #applyAssignNewLicense(batch) {
         let licenseCount = await this.#applyGetLicenseCount(batch)
         let newLicenseLength;
-        if (null === licenseCount) {
+        if (licenseCount === null) {
             // Initialize the writers length entry if it does not exist
             const bufferedLength = lengthEntryUtils.init(0);
             licenseCount = lengthEntryUtils.decodeBE(bufferedLength);
@@ -3841,6 +3846,7 @@ class State extends ReadyResource {
             subnetworkCreatorEntry: updatedSubnetworkCreatorNodeEntry
         };
     }
+
 }
 
 export default State;

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,114 @@
+import request from "supertest"
+import tracCrypto from "trac-crypto-api"
+import b4a from "b4a"
+import { $TNK } from "../../../../src/core/state/utils/balance.js"
+
+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 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+)?$/) })
+        })
+    })
+}