trac-msb 0.2.3 → 0.2.5

package/rpc/handlers.mjs

@@ -1,26 +1,26 @@
 import { decodeBase64Payload, isBase64, sanitizeBulkPayloadsRequestBody, sanitizeTransferPayload, validatePayloadStructure } from "./utils/helpers.mjs"
-import { MAX_SIGNED_LENGTH } from "./constants.mjs";
-import { isHexString } from "../src/utils/helpers";
+import { MAX_SIGNED_LENGTH, ZERO_WK } from "./constants.mjs";
+import { buildRequestUrl } from "./utils/url.mjs";
+import { isHexString } from "../src/utils/helpers.js";
+import { bufferToBigInt, licenseBufferToBigInt } from "../src/utils/amountSerialization.js";
+import { isAddressValid } from "../src/core/state/utils/address.js";
+import { getConfirmedParameter } from "./utils/confirmedParameter.mjs";
 
 export async function handleBalance({ req, respond, msbInstance }) {
-    const [path, queryString] = req.url.split("?");
-    const parts = path.split("/").filter(Boolean);
+    const url = buildRequestUrl(req);
+    const parts = url.pathname.split("/").filter(Boolean);
     const address = parts[2];
 
-    let confirmed = true; // default
-    if (queryString) {
-        const params = new URLSearchParams(queryString);
-        if (params.has("confirmed")) {
-            confirmed = params.get("confirmed") === "true";
-        }
-    }
+    const confirmedParam = getConfirmedParameter(url);
+    const confirmed = confirmedParam === null ? false : confirmedParam; // invalid -> fallback to unconfirmed
 
+    // TODO: VALIDATION? 
     if (!address) {
         respond(400, { error: 'Wallet address is required' });
         return;
     }
-    
-    const commandString =`/get_balance ${address} ${confirmed}`;
+
+    const commandString = `/get_balance ${address} ${confirmed}`;
     const nodeInfo = await msbInstance.handleCommand(commandString);
     const balance = nodeInfo?.balance || 0;
     respond(200, { address, balance });
@@ -71,14 +71,14 @@ export async function handleBroadcastTransaction({ msbInstance, respond, req })
             let code = error instanceof SyntaxError ? 400 : 500;
             let errorMsg = code === 400 ? 'Invalid JSON payload.' : 'An error occurred processing the transaction.'
 
-            if(error.message.includes("Failed to broadcast transaction after multiple attempts.")){
+            if (error.message.includes("Failed to broadcast transaction after multiple attempts.")) {
                 code = 429;
                 errorMsg = "Failed to broadcast transaction after multiple attempts."
             }
-            
+
             console.error('Error in handleBroadcastTransaction:', error);
             // Use 400 for client errors (like bad JSON), 500 for server/command errors
-            respond(code, { error:  errorMsg});
+            respond(code, { error: errorMsg });
         }
     });
 
@@ -89,8 +89,10 @@ export async function handleBroadcastTransaction({ msbInstance, respond, req })
 }
 
 export async function handleTxHashes({ msbInstance, respond, req }) {
-    const startSignedLengthStr = req.url.split('/')[3];
-    const endSignedLengthStr = req.url.split('/')[4];
+    const url = buildRequestUrl(req);
+    const pathParts = url.pathname.split('/').filter(Boolean);
+    const startSignedLengthStr = pathParts[2];
+    const endSignedLengthStr = pathParts[3];
 
     const startSignedLength = parseInt(startSignedLengthStr);
     const endSignedLength = parseInt(endSignedLengthStr);
@@ -120,7 +122,7 @@ export async function handleTxHashes({ msbInstance, respond, req }) {
 
     // 5. Adjust the end index to not exceed the confirmed length.
     const adjustedEndLength = Math.min(endSignedLength, currentConfirmedLength)
-    
+
     // 6. Fetch txs hashes for the adjusted range, assuming the command takes start and end index.
     const commandString = `/get_txs_hashes ${startSignedLength} ${adjustedEndLength}`;
     const { hashes } = await msbInstance.handleCommand(commandString);
@@ -128,16 +130,21 @@ export async function handleTxHashes({ msbInstance, respond, req }) {
 }
 
 export async function handleUnconfirmedLength({ msbInstance, respond }) {
+    // TODO: VALIDATION? 
     const commandString = '/unconfirmed_length';
     const unconfirmed_length = await msbInstance.handleCommand(commandString);
     respond(200, { unconfirmed_length });
 }
 
 export async function handleTransactionDetails({ msbInstance, respond, req }) {
-    const hash = req.url.split('/')[3];
+    // TODO: VALIDATION? 
+    const url = buildRequestUrl(req);
+    const pathParts = url.pathname.split('/').filter(Boolean);
+    const hash = pathParts[2];
+
     const commandString = `/get_tx_details ${hash}`;
     const txDetails = await msbInstance.handleCommand(commandString);
-    respond(txDetails === null ? 404 : 200 , { txDetails });
+    respond(txDetails === null ? 404 : 200, { txDetails });
 }
 
 export async function handleFetchBulkTxPayloads({ msbInstance, respond, req }) {
@@ -150,9 +157,9 @@ export async function handleFetchBulkTxPayloads({ msbInstance, respond, req }) {
         if (headersSent) return; // Stop processing if response has started/errored
 
         bytesRead += chunk.length;
-        if (bytesRead > limitBytes) { 
+        if (bytesRead > limitBytes) {
             respond(413, { error: 'Request body too large.' });
-            headersSent = true; 
+            headersSent = true;
             req.destroy(); // Stop receiving data (GOOD PRACTICE)
             return;
         }
@@ -164,16 +171,16 @@ export async function handleFetchBulkTxPayloads({ msbInstance, respond, req }) {
 
 
         try {
-            if (body === null || body === ''){
+            if (body === null || body === '') {
                 return respond(400, { error: 'Missing payload.' });
             }
 
             const sanitizedPayload = sanitizeBulkPayloadsRequestBody(body);
 
-            if (sanitizedPayload === null){
+            if (sanitizedPayload === null) {
                 return respond(400, { error: 'Invalid payload.' });
             }
-            
+
             const { hashes } = sanitizedPayload;
 
             if (!Array.isArray(hashes) || hashes.length === 0) {
@@ -186,11 +193,11 @@ export async function handleFetchBulkTxPayloads({ msbInstance, respond, req }) {
 
             const uniqueHashes = [...new Set(hashes)];
 
-            const commandResult = await msbInstance.handleCommand( `/get_tx_payloads_bulk`, null, uniqueHashes)
+            const commandResult = await msbInstance.handleCommand(`/get_tx_payloads_bulk`, null, uniqueHashes)
 
             const responseString = JSON.stringify(commandResult);
             if (Buffer.byteLength(responseString, 'utf8') > 2_000_000) {
-                return respond(413, { error: 'Response too large. Reduce number of hashes.'});
+                return respond(413, { error: 'Response too large. Reduce number of hashes.' });
             }
 
             return respond(200, commandResult);
@@ -209,29 +216,23 @@ export async function handleFetchBulkTxPayloads({ msbInstance, respond, req }) {
 }
 
 export async function handleTransactionExtendedDetails({ msbInstance, respond, req }) {
-    const [path, queryString] = req.url.split("?");
-    const pathParts = path.split('/');
-    const hash = pathParts[4];
-    
+    const url = buildRequestUrl(req);
+    const pathParts = url.pathname.split('/').filter(Boolean);
+    const hash = pathParts[3];
+
     if (!hash) {
         return respond(400, { error: "Transaction hash is required" });
     }
-    
+
     if (isHexString(hash) === false || hash.length !== 64) {
         return respond(400, { error: "Invalid transaction hash format" });
     }
-    let confirmed = true; // default
-    if (queryString) {
-        const params = new URLSearchParams(queryString);
-        if (params.has("confirmed")) {
-            const confirmedParam = params.get("confirmed");
-            if (confirmedParam !== "true" && confirmedParam !== "false") {
-                return respond(400, { error: 'Parameter "confirmed" must be exactly "true" or "false"' });
-            }
-            confirmed = confirmedParam === "true";
-        }
+
+    const confirmed = getConfirmedParameter(url);
+    if (confirmed === null) {
+        return respond(400, { error: 'Parameter "confirmed" must be exactly "true" or "false"' });
     }
-    
+
     try {
         let txDetails;
         const commandString = `/get_extended_tx_details ${hash} ${confirmed}`;
@@ -249,4 +250,53 @@ export async function handleTransactionExtendedDetails({ msbInstance, respond, r
             respond(500, { error: 'An error occurred processing the request.' });
         }
     }
-}
+}
+
+export async function handleAccountDetails({ msbInstance, respond, req }) {
+    const url = buildRequestUrl(req);
+    const address = url.pathname.split('/').filter(Boolean)[2];
+
+    if (!address) {
+        return respond(400, { error: "Account address is required" });
+    }
+
+    const confirmed = getConfirmedParameter(url);
+    if (confirmed === null) {
+        return respond(400, { error: 'Parameter "confirmed" must be exactly "true" or "false"' });
+    }
+
+    if (!isAddressValid(address)) {
+        return respond(400, { error: "Invalid account address format" });
+    }
+
+    const defaultAccountState = {
+        address,
+        writingKey: ZERO_WK.toString('hex'),
+        isWhitelisted: false,
+        isValidator: false,
+        isIndexer: false,
+        license: null,
+        balance: '0',
+        stakedBalance: '0',
+    };
+
+    const nodeEntry = confirmed
+        ? await msbInstance.state.getNodeEntry(address)
+        : await msbInstance.state.getNodeEntryUnsigned(address);
+    if (!nodeEntry) {
+        return respond(200, defaultAccountState);
+    }
+
+    const licenseValue = licenseBufferToBigInt(nodeEntry.license);
+
+    return respond(200, {
+        ...defaultAccountState,
+        writingKey: nodeEntry.wk.toString('hex'),
+        isWhitelisted: nodeEntry.isWhitelisted,
+        isValidator: nodeEntry.isWriter,
+        isIndexer: nodeEntry.isIndexer,
+        license: licenseValue === 0n ? null : licenseValue.toString(),
+        balance: bufferToBigInt(nodeEntry.balance).toString(),
+        stakedBalance: bufferToBigInt(nodeEntry.stakedBalance).toString(),
+    });
+}

package/rpc/routes/v1.mjs

@@ -8,7 +8,8 @@ import {
     handleUnconfirmedLength,
     handleTransactionDetails,
     handleFetchBulkTxPayloads,
-    handleTransactionExtendedDetails
+    handleTransactionExtendedDetails,
+    handleAccountDetails
 } from '../handlers.mjs';
 
 export const v1Routes = [
@@ -22,4 +23,5 @@ export const v1Routes = [
     { method: 'GET', path: '/tx', handler: handleTransactionDetails },
     { method: 'POST', path: '/tx-payloads-bulk', handler: handleFetchBulkTxPayloads },
     { method: 'GET', path: '/tx/details', handler: handleTransactionExtendedDetails },
+    { method: 'GET', path: '/account', handler: handleAccountDetails },
 ];

package/rpc/utils/confirmedParameter.mjs

@@ -0,0 +1,17 @@
+export function getConfirmedParameter(url, { defaultValue = true } = {}) {
+    const confirmedParam = url.searchParams.get("confirmed");
+
+    if (confirmedParam === null) {
+        return defaultValue;
+    }
+
+    if (confirmedParam === "true") {
+        return true;
+    }
+
+    if (confirmedParam === "false") {
+        return false;
+    }
+
+    return null;
+}

package/rpc/utils/url.mjs

@@ -0,0 +1,38 @@
+const HOST_HEADER_PATTERN = /^[\[\]A-Za-z0-9:.-]+(:\d{1,5})?$/;
+
+const isValidHostHeader = (hostHeader) => {
+    if (!hostHeader) return false;
+    if (hostHeader.length > 255) return false;
+    const trimmed = hostHeader.trim();
+
+    if (/[\/\\\s]/.test(trimmed)) return false;
+
+    return HOST_HEADER_PATTERN.test(trimmed);
+};
+
+const socketAddressToHost = (address, port) => {
+    if (!address) return null;
+    const needsBrackets = address.includes(':') && !address.startsWith('[');
+    const host = needsBrackets ? `[${address}]` : address;
+    return port ? `${host}:${port}` : host;
+};
+
+const detectProtocol = (req) => {
+    const forwardedProto = req?.headers?.['x-forwarded-proto'];
+    if (forwardedProto === 'https') return 'https';
+    if (forwardedProto === 'http') return 'http';
+
+    if (req?.socket?.encrypted) return 'https';
+
+    return 'http';
+};
+
+export const buildRequestUrl = (req) => {
+    const safeHost = isValidHostHeader(req?.headers?.host)
+        ? req.headers.host.trim()
+        : socketAddressToHost(req?.socket?.localAddress, req?.socket?.localPort);
+
+    const protocol = detectProtocol(req);
+    const base = safeHost ? `${protocol}://${safeHost}` : `${protocol}://localhost`;
+    return new URL(req?.url || '/', base);
+};

package/src/core/network/Network.js

@@ -17,7 +17,7 @@ import {
     DHT_BOOTSTRAPS
 } from '../../utils/constants.js';
 import ConnectionManager from './services/ConnectionManager.js';
-
+import NetworkWalletFactory from './identity/NetworkWalletFactory.js';
 const wakeup = new w();
 
 class Network extends ReadyResource {
@@ -29,15 +29,18 @@ class Network extends ReadyResource {
     #transactionPoolService;
     #validatorObserverService;
     #validatorConnectionManager;
+    #options;
+    #identityProvider = null;
 
     constructor(state, channel, address = null, options = {}) {
         super();
+        this.#options = options;
         this.#enable_wallet = options.enable_wallet !== false;
         this.#channel = channel;
         this.#transactionPoolService = new TransactionPoolService(state, address, options);
-        this.#validatorObserverService = new ValidatorObserverService(this, state, address, options)
+        this.#validatorObserverService = new ValidatorObserverService(this, state, address, options);
         this.#networkMessages = new NetworkMessages(this, options);
-        this.#validatorConnectionManager = new ConnectionManager({ maxValidators: options.max_validators })
+        this.#validatorConnectionManager = new ConnectionManager({ maxValidators: options.max_validators });
         this.admin_stream = null;
         this.admin = null;
         this.validator = null;
@@ -90,6 +93,7 @@ class Network extends ReadyResource {
     ) {
         if (!this.#swarm) {
             const keyPair = await this.initializeNetworkingKeyPair(store, wallet);
+            const wrappedWallet = this.#getNetworkWalletWrapper(wallet, keyPair);
             this.#swarm = new Hyperswarm({
                 keyPair,
                 bootstrap: this.#dht_bootstrap,
@@ -100,7 +104,7 @@ class Network extends ReadyResource {
             });
 
             console.log(`Channel: ${b4a.toString(this.#channel)}`);
-            this.#networkMessages.initializeMessageRouter(state, wallet);
+            this.#networkMessages.initializeMessageRouter(state, wrappedWallet);
 
             this.#swarm.on('connection', async (connection) => {
                 const { message_channel, message } = await this.#networkMessages.setupProtomuxMessages(connection);
@@ -120,7 +124,7 @@ class Network extends ReadyResource {
                         this.custom_stream = null;
                         this.custom_node = null;
                     }
-                    try{ message_channel.close() }catch(e){}
+                    try { message_channel.close() } catch (e) { }
 
                 });
 
@@ -129,7 +133,7 @@ class Network extends ReadyResource {
                         error && error.message && (
                             error.message.includes('connection reset by peer') ||
                             error.message.includes('Duplicate connection') ||
-                            error.message.includes('connection timed out')                        )
+                            error.message.includes('connection timed out'))
                     ) {
                         // TODO: decide if we want to handle this error in a specific way. It generates a lot of logs.
                         return;
@@ -168,11 +172,11 @@ class Network extends ReadyResource {
                 cnt += 1;
             }
         }
-        
+
         if (this.#swarm.peers.has(publicKey)) {
             let stream;
             const peerInfo = this.#swarm.peers.get(publicKey)
-            stream = this.#swarm._allConnections.get(peerInfo.publicKey)            
+            stream = this.#swarm._allConnections.get(peerInfo.publicKey)
             if (stream !== undefined && stream.messenger !== undefined) {
                 if (type === 'validator') {
                     this.#validatorConnectionManager.addValidator(b4a.from(publicKey, 'hex'), stream)
@@ -183,8 +187,8 @@ class Network extends ReadyResource {
     }
 
     async isConnected(publicKey) {
-        return this.#swarm.peers.has(publicKey) && 
-                this.#swarm.peers.get(publicKey).connectedTime != -1
+        return this.#swarm.peers.has(publicKey) &&
+            this.#swarm.peers.get(publicKey).connectedTime != -1
     }
 
     async #sendRequestByType(stream, type) {
@@ -239,6 +243,19 @@ class Network extends ReadyResource {
             console.log(e)
         }
     }
+
+    #getNetworkWalletWrapper(wallet, keyPair) {
+        if (!this.#identityProvider) {
+            this.#identityProvider = NetworkWalletFactory.provide({
+                enableWallet: this.#enable_wallet,
+                wallet,
+                keyPair,
+                networkPrefix: this.#options?.networkPrefix
+            });
+        }
+        return this.#identityProvider;
+    }
+
 }
 
 export default Network;

package/src/core/network/identity/NetworkWalletFactory.js

@@ -0,0 +1,78 @@
+import PeerWallet from 'trac-wallet';
+import { TRAC_NETWORK_MSB_MAINNET_PREFIX } from 'trac-wallet/constants.js';
+import b4a from 'b4a';
+
+export class NetworkWalletFactory {
+    static provide(options = {}) {
+        const {
+            enableWallet = true,
+            wallet,
+            keyPair,
+            networkPrefix = TRAC_NETWORK_MSB_MAINNET_PREFIX
+        } = options;
+
+        if (enableWallet) {
+            if (!wallet) {
+                throw new Error('NetworkingWalletFactory: wallet instance is required when wallet is enabled');
+            }
+            return wallet;
+        }
+
+        if (!keyPair) {
+            throw new Error('NetworkingWalletFactory: keyPair must be provided when wallet is disabled');
+        }
+
+        return new EphemeralWallet(keyPair, networkPrefix);
+    }
+}
+
+// TODO: Once Wallet class in trac-wallet exposes a constructor/factory that accepts an existing keyPair
+// (e.g. Wallet.fromKeyPair({ publicKey, secretKey }, networkPrefix)), replace EphemeralWallet
+// with a thin wrapper around that functionality instead of duplicating signing/verification logic.
+class EphemeralWallet {
+    #publicKey;
+    #secretKey;
+    #address;
+
+    constructor(keyPair, networkPrefix = TRAC_NETWORK_MSB_MAINNET_PREFIX) {
+        
+        if (!keyPair?.publicKey || !keyPair?.secretKey) {
+            throw new Error('NetworkIdentityProvider: keyPair with publicKey and secretKey is required');
+        }
+        this.#assertBuffer(keyPair.publicKey);
+        this.#assertBuffer(keyPair.secretKey);
+
+        const address = PeerWallet.encodeBech32m(networkPrefix, keyPair.publicKey);
+        if (!address) {
+            throw new Error('NetworkIdentityProvider: failed to derive address from networking key pair');
+        }
+
+        this.#publicKey = keyPair.publicKey;
+        this.#secretKey = keyPair.secretKey;
+        this.#address = address;
+    }
+
+    get publicKey() {
+        return this.#publicKey;
+    }
+
+    get address() {
+        return this.#address;
+    }
+
+    sign(message) {
+        return PeerWallet.sign(message, this.#secretKey);
+    }
+
+    verify(signature, message, publicKey = this.#publicKey) {
+        return PeerWallet.verify(signature, message, publicKey);
+    }
+
+    #assertBuffer(value) {
+        if (!b4a.isBuffer(value)) {
+            throw new Error(`NetworkIdentityProvider: value must be a Buffer`);
+        }
+    }
+}
+
+export default NetworkWalletFactory;

package/src/core/network/services/ConnectionManager.js

@@ -1,4 +1,4 @@
-import { MAX_VALIDATORS } from "../../../utils/constants.js"
+import { MAX_VALIDATORS, MAX_REQUEST_COUNT } from "../../../utils/constants.js"
 import b4a from 'b4a'
 import PeerWallet from "trac-wallet"
 import { TRAC_NETWORK_MSB_MAINNET_PREFIX } from 'trac-wallet/constants.js';
@@ -19,7 +19,7 @@ class ConnectionManager {
     }
 
     send(message, retries = 3) {
-        if (this.#requestCount >= 10) {
+        if (this.#requestCount >= MAX_REQUEST_COUNT) {
             this.#requestCount = 0
             this.#updateNext()
         }

package/src/core/network/services/ValidatorObserverService.js

@@ -10,7 +10,6 @@ const DELAY_INTERVAL = 250
 
 class ValidatorObserverService {
     #enable_validator_observer;
-    #enable_wallet;
     #state;
     #network;
     #scheduler;
@@ -18,7 +17,7 @@ class ValidatorObserverService {
     #isInterrupted
 
     constructor(network, state, address, options = {}) {
-        this.#enable_wallet = options.enable_wallet !== false;
+        this.#enable_validator_observer = options.enable_validator_observer !== false;
         this.#network = network;
         this.#state = state;
         this.#address = address;
@@ -34,7 +33,7 @@ class ValidatorObserverService {
     // OS CALLS, ACCUMULATORS, MAYBE THIS IS POSSIBLE TO CHECK I/O QUEUE IF IT COINTAIN IT. FOR NOW WE ARE USING SLEEP.
     async start() {
         if (!this.#shouldRun()) {
-            console.info('ValidatorObserverService can not start. Wallet is not enabled');
+            console.info('ValidatorObserverService can not start. Disabled by configuration.');
             return;
         }
         if (this.#scheduler && this.#scheduler.isRunning) {
@@ -111,7 +110,11 @@ class ValidatorObserverService {
     };
 
     #shouldRun() {
-        return this.#enable_wallet && !this.#isInterrupted
+        if (!this.#enable_validator_observer || this.#isInterrupted) {
+            return false;
+        }
+
+        return true;
     }
 
     async #lengthEntry() {