trac-msb 0.1.75 → 0.1.77-msb-r2-dev.0

package/rpc/handlers.mjs

@@ -0,0 +1,167 @@
+import {decodeBase64Payload, isBase64, sanitizeBulkPayloadsRequestBody, sanitizeTransferPayload, validatePayloadStructure} from "./utils/helpers.mjs"
+import { MAX_SIGNED_LENGTH, SIGNED_LENGTH_OFFSET } from "./constants.mjs";
+
+export async function handleBalance({ req, respond, msbInstance }) {
+    const [path, queryString] = req.url.split("?");
+    const parts = path.split("/").filter(Boolean);
+    const address = parts[1];  
+
+    let confirmed = true; // default
+    if (queryString) {
+        const params = new URLSearchParams(queryString);
+        if (params.has("confirmed")) {
+            confirmed = params.get("confirmed") === "true";
+        }
+    }
+
+    if (!address) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Wallet address is required' }));
+        return;
+    }
+    
+    const commandString =`/get_balance ${address} ${confirmed}`;
+    const nodeInfo = await msbInstance.handleCommand(commandString);
+    const balance = nodeInfo?.balance || 0;
+    respond(200, { address, balance });
+}
+
+export async function handleTxv({ msbInstance, respond }) {
+    const commandString = '/get_txv';
+    const txvRaw = await msbInstance.handleCommand(commandString);
+    const txv = txvRaw.toString('hex');
+    respond(200, { txv });
+}
+
+export async function handleFee({ msbInstance, respond }) {
+    const commandString = '/get_fee';
+    const fee = await msbInstance.handleCommand(commandString);
+    respond(200, { fee });
+}
+
+export async function handleConfirmedLength({ msbInstance, respond }) {
+    const commandString = '/confirmed_length';
+    const confirmed_length = await msbInstance.handleCommand(commandString);
+    respond(200, { confirmed_length });
+}
+
+export async function handleBroadcastTransaction({ msbInstance, respond, req }) {
+    let body = '';
+    req.on('data', chunk => {
+        body += chunk.toString();
+    });
+
+    req.on('end', async () => {
+        const { payload } = JSON.parse(body);
+        if (!payload) {
+            return respond(400, { error: 'Payload is missing.' });
+        }
+
+        if (!isBase64(payload)) {
+            return respond(400, { error: 'Payload must be a valid base64 string.' });
+        }
+
+        const decodedPayload = decodeBase64Payload(payload);
+        validatePayloadStructure(decodedPayload);
+        const sanitizedPayload = sanitizeTransferPayload(decodedPayload);
+        const result = await msbInstance.handleCommand('/broadcast_transaction', null, sanitizedPayload);
+        respond(200, { result });
+    });
+}
+
+export async function handleTxHashes({ msbInstance, respond, req }) {
+    const startSignedLengthStr = req.url.split('/')[2];
+    const endSignedLengthStr = req.url.split('/')[3];
+
+    const startSignedLength = parseInt(startSignedLengthStr);
+    const endSignedLength = parseInt(endSignedLengthStr);
+
+    // 1. Check if the parsed values are valid numbers
+    if (isNaN(startSignedLength) || isNaN(endSignedLength)) {
+        return respond(400, { error: 'Params must be integer' });
+    }
+
+    // 2. Check for non-negative numbers
+    // The requirement is "non-negative," which includes 0.
+    if (startSignedLength < 0 || endSignedLength < 0) {
+        return respond(400, { error: 'Params must be non-negative' });
+    }
+
+    // 3. endSignedLength must be >= startSignedLength
+    if (endSignedLength < startSignedLength) {
+        return respond(400, { error: 'endSignedLength must be greater than or equal to startSignedLength.' });
+    }
+
+    if (endSignedLength - startSignedLength > MAX_SIGNED_LENGTH) {
+        return respond(400, { error: `The max range for signedLength must be ${MAX_SIGNED_LENGTH}.` });
+    }
+
+    // 4. Get current confirmed length
+    const currentConfirmedLength = await msbInstance.handleCommand('/confirmed_length');
+
+    // 5. Adjust the end index to not exceed the confirmed length.
+    const adjustedEndLength = Math.min(endSignedLength, currentConfirmedLength) + SIGNED_LENGTH_OFFSET // apply an offset to include in the end
+    
+    // 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);
+    respond(200, { hashes });
+}
+
+export async function handleUnconfirmedLength({ msbInstance, respond }) {
+    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('/')[2];
+    const commandString = `/get_tx_details ${hash}`;
+    const txDetails = await msbInstance.handleCommand(commandString);
+    respond(200, { txDetails });
+}
+
+export async function handleFetchBulkTxPayloads({ msbInstance, respond, req }) {
+    let body = ''
+    let bytesRead = 0;
+    let limitBytes = 1_000_000;
+
+    req.on('data', chunk => {
+        bytesRead += chunk.length;
+        if (bytesRead > limitBytes) { respond(413, { error: 'Request body too large.' }) }
+        body += chunk.toString();
+    });
+
+    req.on('end', async () => {
+        if (body === null || body === ''){
+            return respond(400, { error: 'Missing payload.' });
+        }
+
+        const sanitizedPayload = sanitizeBulkPayloadsRequestBody(body);
+
+        if (sanitizedPayload === null){
+            return respond(400, { error: 'Invalid payload.' });
+        }
+        
+        const { hashes } = sanitizedPayload;
+
+        if (!Array.isArray(hashes) || hashes.length === 0) {
+            return respond(400, { error: 'Missing hash list.' });
+        }
+
+        if (hashes.length > 1500) {
+            return respond(413, { error: 'Too many hashes. Max 1500 allowed per request.' });
+        }
+
+        const uniqueHashes = [...new Set(hashes)];
+
+        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(200, commandResult);
+    })
+}

package/rpc/router.mjs

@@ -0,0 +1,23 @@
+import {
+    handleBalance,
+    handleTxv,
+    handleFee,
+    handleConfirmedLength,
+    handleBroadcastTransaction,
+    handleTxHashes,
+    handleUnconfirmedLength,
+    handleTransactionDetails,
+    handleFetchBulkTxPayloads
+} from './handlers.mjs';
+
+export const routes = [
+    { method: 'GET', path: '/balance', handler: handleBalance },
+    { method: 'GET', path: '/txv', handler: handleTxv },
+    { method: 'GET', path: '/fee', handler: handleFee },
+    { method: 'GET', path: '/confirmed-length', handler: handleConfirmedLength },
+    { method: 'POST', path: '/broadcast-transaction', handler: handleBroadcastTransaction },
+    { method: 'GET', path: '/tx-hashes/', handler: handleTxHashes },
+    { method: 'GET', path: '/unconfirmed-length', handler: handleUnconfirmedLength },
+    { method: 'GET', path: '/tx', handler: handleTransactionDetails },
+    { method: 'POST', path: '/tx-payloads-bulk', handler: handleFetchBulkTxPayloads },
+];

package/rpc/rpc_server.mjs

@@ -0,0 +1,10 @@
+import { createServer } from "./create_server.mjs";
+
+// Called by msb.mjs file
+export function startRpcServer(msbInstance, port) {
+    const server = createServer(msbInstance)
+
+    return server.listen(port, () => {
+        console.log(`Running RPC with https at https://localhost:${port}`);
+    });
+}

package/rpc/utils/helpers.mjs

@@ -0,0 +1,67 @@
+import b4a from "b4a"
+
+export function decodeBase64Payload(base64) {
+  let decodedPayloadString
+  try {
+    decodedPayloadString = b4a.from(base64, "base64").toString("utf-8")
+  } catch (err) {
+    throw new Error("Failed to decode base64 payload.")
+  }
+
+  try {
+    return JSON.parse(decodedPayloadString)
+  } catch (err) {
+    throw new Error("Decoded payload is not valid JSON.")
+  }
+}
+
+export function isBase64(str) {
+  const base64Regex =
+    /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/
+  return base64Regex.test(str)
+}
+
+export function validatePayloadStructure(payload) {
+  if (
+    typeof payload !== "object" ||
+    payload === null ||
+    typeof payload.type !== "number" ||
+    typeof payload.address !== "string" ||
+    typeof payload.tro !== "object"
+  ) {
+    throw new Error("Invalid payload structure.")
+  }
+}
+
+export function sanitizeTransferPayload(payload) {
+  if (payload.address && typeof payload.address === "string") {
+    payload.address = payload.address.trim()
+  }
+
+  if (payload.tro && typeof payload.tro === "object") {
+    for (const [key, value] of Object.entries(payload.tro)) {
+      if (typeof value === "string") {
+        let sanitized = value.trim()
+
+        // normalize hex-like strings
+        if (/^[0-9A-F]+$/i.test(sanitized)) {
+          sanitized = sanitized.toLowerCase()
+        }
+
+        payload.tro[key] = sanitized
+      }
+    }
+  }
+
+  return payload
+}
+
+export function sanitizeBulkPayloadsRequestBody(body) { 
+  const cleanBody = body
+    .replace(/^\uFEFF/, '')
+    .replace(/\r/g, '')
+    .replace(/\0/g, '')
+    .trim();
+
+  return JSON.parse(cleanBody);
+}

package/scripts/generate-protobufs.js

@@ -0,0 +1,42 @@
+import fs from 'fs';
+import path from 'path';
+
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+
+function generateCJSFromProto(inputPath, outputPath) {
+    execSync(`protocol-buffers "${inputPath}" -o "${outputPath}"`);
+    console.log(`${outputPath} has been generated.`);
+}
+
+function transformToUseB4a(outputPath) {
+    let content = fs.readFileSync(outputPath, 'utf-8');
+    content = content.replace(/\bBuffer\.([a-zA-Z]+)/g, 'b4a.$1');
+    content = `var b4a = require('b4a');\n` + content;
+    fs.writeFileSync(outputPath, content, 'utf-8');
+    console.log(`${outputPath} has been modified to use b4a.`);
+}
+
+
+function main() {
+    const directoryName = path.dirname(fileURLToPath(import.meta.url));
+
+    const inputDir = path.join(directoryName, '../proto');
+    const outputDir = path.join(directoryName, '../src/utils/protobuf');
+
+    fs.mkdirSync(outputDir, { recursive: true });
+
+    const files = fs.readdirSync(inputDir).filter(f => f.endsWith('.proto'));
+
+    for (const file of files) {
+        const name = path.basename(file, '.proto');
+        const inputPath = path.join(inputDir, file);
+        const outputPath = path.join(outputDir, `${name}.cjs`);
+
+        generateCJSFromProto(inputPath, outputPath);
+        transformToUseB4a(outputPath);
+    }
+}
+
+main();
+

package/src/core/network/Network.js

@@ -0,0 +1,259 @@
+import ReadyResource from 'ready-resource';
+import Hyperswarm from 'hyperswarm';
+import w from 'protomux-wakeup';
+import b4a from 'b4a';
+
+import PoolService from './services/PoolService.js';
+import ValidatorObserverService from './services/ValidatorObserverService.js';
+import NetworkMessages from './messaging/NetworkMessages.js';
+import { sleep } from '../../utils/helpers.js';
+import {
+    TRAC_NAMESPACE,
+    MAX_PEERS,
+    MAX_PARALLEL,
+    MAX_SERVER_CONNECTIONS,
+    MAX_CLIENT_CONNECTIONS,
+    NETWORK_MESSAGE_TYPES,
+    DHT_BOOTSTRAPS
+} from '../../utils/constants.js';
+
+const wakeup = new w();
+
+class Network extends ReadyResource {
+    #dht_bootstrap = DHT_BOOTSTRAPS;
+    #swarm = null;
+    #enable_wallet;
+    #channel;
+    #networkMessages;
+    #poolService;
+    #validatorObserverService;
+
+    constructor(state, channel, options = {}) {
+        super();
+        this.#enable_wallet = options.enable_wallet !== false;
+        this.#channel = channel;
+        this.#poolService = new PoolService(state)
+        this.#validatorObserverService = new ValidatorObserverService(this, state, options)
+        this.#networkMessages = new NetworkMessages(this, options);
+        //TODO: move streams maybe to HASHMAP? To discuss because this change will affect the whole network module and it's usage. It is not a priority right now
+        //However, it gives us more flexibility in the future, because we can create set of streams. Maybe in this case exist better data structure?
+        this.admin_stream = null;
+        this.admin = null;
+        this.validator_stream = null;
+        this.validator = null;
+        this.custom_stream = null;
+        this.custom_node = null;
+    }
+
+    get swarm() {
+        return this.#swarm;
+    }
+
+    get channel() {
+        return this.#channel;
+    }
+
+    get poolService() {
+        return this.#poolService;
+    }
+
+    get validatorObserverService() {
+        return this.#validatorObserverService;
+    }
+
+    async _open() {
+        console.log('Network initialization...');
+        this.poolService.start();
+    }
+
+    async _close() {
+        console.log('Network: closing gracefully...');
+        this.poolService.stopPool();
+        await sleep(100);
+
+        if (this.#validatorObserverService.enable_validator_observer) {
+            this.#validatorObserverService.stopValidatorObserver();
+        }
+
+        await sleep(5_000);
+
+        if (this.#swarm !== null) {
+            this.#swarm.destroy();
+        }
+    }
+
+    startValidatorObserver(address) {
+        this.#validatorObserverService.startValidatorObserver();
+        this.#validatorObserverService.validatorObserver(address);
+    }
+
+    async replicate(
+        state,
+        store,
+        wallet,
+    ) {
+        if (!this.#swarm) {
+            const keyPair = await this.initializeNetworkingKeyPair(store, wallet);
+            this.#swarm = new Hyperswarm({
+                keyPair,
+                bootstrap: this.#dht_bootstrap,
+                maxPeers: MAX_PEERS,
+                maxParallel: MAX_PARALLEL,
+                maxServerConnections: MAX_SERVER_CONNECTIONS,
+                maxClientConnections: MAX_CLIENT_CONNECTIONS
+            });
+
+            console.log(`Channel: ${b4a.toString(this.#channel)}`);
+            this.#networkMessages.initializeMessageRouter(state, wallet);
+
+            this.#swarm.on('connection', async (connection) => {
+                const { message_channel, message } = this.#networkMessages.setupProtomuxMessages(connection);
+                connection.messenger = message;
+
+                connection.on('close', () => {
+                    if (this.validator_stream === connection) {
+                        this.validator_stream = null;
+                        this.validator = null;
+                    }
+
+                    if (this.admin_stream === connection) {
+                        this.admin_stream = null;
+                        this.admin = null;
+                    }
+
+                    if (this.custom_stream === connection) {
+                        this.custom_stream = null;
+                        this.custom_node = null;
+                    }
+
+                    message_channel.close()
+                });
+
+                // ATTENTION: Must be called AFTER the protomux init above
+                const stream = store.replicate(connection);
+                wakeup.addStream(stream);
+
+                connection.on('error', (error) => {
+                    if (
+                        error && error.message && (
+                            error.message.includes('connection reset by peer') ||
+                            error.message.includes('Duplicate connection')
+                        )
+                    ) {
+                        // TODO: decide if we want to handle this error in a specific way. It generates a lot of logs.
+                        return;
+                    }
+                    console.error(error.message)
+
+                });
+
+            });
+
+            this.#swarm.join(this.#channel, { server: true, client: true });
+            await this.#swarm.flush();
+        }
+    }
+
+    async initializeNetworkingKeyPair(store, wallet) {
+        if (!this.#enable_wallet) {
+            return await store.createKeyPair(TRAC_NAMESPACE);
+        } else {
+            return {
+                publicKey: wallet.publicKey,
+                secretKey: wallet.secretKey
+            };
+        }
+    }
+
+    async tryConnect(publicKey, type = null) {
+        
+        if (null === this.#swarm) throw new Error('Network swarm is not initialized');
+
+        if (this.validator_stream !== null && publicKey !== b4a.toString(this.validator_stream.remotePublicKey, 'hex')) {
+            this.#swarm.leavePeer(this.validator_stream.remotePublicKey);
+            this.validator_stream = null;
+            this.validator = null;
+        }
+        // trying to join a peer from the global swarm
+
+        if (false === this.#swarm.peers.has(publicKey)) {
+            this.#swarm.joinPeer(b4a.from(publicKey, 'hex'));
+            let cnt = 0;
+            while (false === this.#swarm.peers.has(publicKey)) {
+                if (cnt >= 1500) break;
+                await sleep(10);
+                cnt += 1;
+            }
+        }
+
+        if (this.#swarm.peers.has(publicKey)) {
+            let stream;
+            const peerInfo = this.#swarm.peers.get(publicKey)
+            stream = this.#swarm._allConnections.get(peerInfo.publicKey)
+
+            if (stream !== undefined && stream.messenger !== undefined) {
+                await this.#sendRequestByType(stream, type);
+            }
+        }
+    }
+
+    async isConnected(publicKey) {
+        return this.#swarm.peers.has(publicKey) && 
+                this.#swarm.peers.get(publicKey).connectedTime != -1
+    }
+
+    async #sendRequestByType(stream, type) {
+        const waitFor = {
+            validator: () => this.validator_stream,
+            admin: () => this.admin_stream,
+            node: () => this.custom_stream
+        }[type];
+
+        if (type === 'validator') {
+            await stream.messenger.send(NETWORK_MESSAGE_TYPES.GET.VALIDATOR);
+        } else if (type === 'admin') {
+            await stream.messenger.send(NETWORK_MESSAGE_TYPES.GET.ADMIN);
+        } else if (type === 'node') {
+            await stream.messenger.send(NETWORK_MESSAGE_TYPES.GET.NODE);
+        } else {
+            return;
+        }
+        await this.spinLock(() => !waitFor)
+    };
+
+    async spinLock(conditionFn, maxIterations = 1500, intervalMs = 10) {
+        let counter = 0;
+        while (conditionFn() && counter < maxIterations) {
+            await sleep(intervalMs);
+            counter++;
+        }
+    }
+
+    async sendMessageToNode(nodePublicKey, message) {
+        try {
+            if (!nodePublicKey || !message) {
+                return;
+            }
+            await this.tryConnect(nodePublicKey, 'node');
+
+            await this.spinLock(() =>
+                this.custom_stream === null ||
+                !b4a.equals(this.custom_node, b4a.from(nodePublicKey, 'hex'))
+            );
+            if (
+                this.custom_stream !== null &&
+                this.custom_node !== null &&
+                b4a.equals(this.custom_node, b4a.from(nodePublicKey, 'hex'))
+            ) {
+                await this.custom_stream.messenger.send(message);
+            } else {
+                throw new Error(`Failed to send message to node: ${nodePublicKey}`);
+            }
+
+        } catch (e) {
+            console.log(e)
+        }
+    }
+}
+
+export default Network;

package/src/core/network/messaging/NetworkMessages.js

@@ -0,0 +1,63 @@
+
+import Protomux from 'protomux';
+import b4a from 'b4a';
+import c from 'compact-encoding';
+import NetworkMessageRouter from './routes/NetworkMessageRouter.js';
+
+class NetworkMessages {
+    #messageRouter;
+    #network;
+    #options;
+
+    constructor(network, options = {}) {
+        this.#network = network;
+        this.#options = options;
+    }
+
+    get network() {
+        return this.#network;
+    }
+
+    initializeMessageRouter(state, wallet) {
+        this.#messageRouter = new NetworkMessageRouter(
+            this.network,
+            state,
+            wallet,
+            this.#options
+        );
+    }
+
+    setupProtomuxMessages(connection) {
+        const mux = Protomux.from(connection);
+        connection.userData = mux;
+        const message_channel = mux.createChannel({
+            protocol: b4a.toString(this.network.channel, 'utf8'),
+            onopen() { },
+            onclose() { }
+        });
+
+        message_channel.open();
+
+        const messageProtomux = message_channel.addMessage({
+            encoding: c.json,
+            onmessage: async (incomingMessage) => {
+                try {
+                    if (typeof incomingMessage === 'object' || typeof incomingMessage === 'string') {
+                        await this.#messageRouter.route(incomingMessage, connection, messageProtomux);
+                    } else {
+                        throw new Error('NetworkMessages: Received message is undefined');
+                    }
+                } catch (error) {
+                    throw new Error(`NetworkMessages: Failed to handle incoming message: ${error.message}`);
+                } finally {
+                    this.network.swarm.leavePeer(connection.remotePublicKey);
+                }
+            }
+        });
+
+        connection.messenger = messageProtomux;
+        return { message_channel, message: messageProtomux };
+    }
+}
+
+export default NetworkMessages;