trac-msb 0.2.8 → 0.2.10

package/tests/unit/utils/protobuf/operationHelpers.test.js

@@ -2,12 +2,20 @@ import test from 'brittle';
 import b4a from 'b4a';
 
 import applyOperations from '../../../../src/utils/protobuf/applyOperations.cjs';
+import {
+    decodeV1networkOperation,
+    encodeV1networkOperation,
+    normalizeIncomingMessage,
+    safeDecodeApplyOperation,
+    safeEncodeApplyOperation,
+} from '../../../../src/utils/protobuf/operationHelpers.js';
 import fixtures from '../../../fixtures/protobuf.fixtures.js';
+import networkV1Fixtures from '../../../fixtures/networkV1.fixtures.js';
 
-//TODO add missing operations tests and fill fixtures with them
 test('Happy path encode/decode roundtrip for protobuf applyOperation payloads', t => {
     const payloadsHashMap = new Map([
         ["txComplete", fixtures.validTransactionOperation],
+        ["txPartial", fixtures.validPartialTransactionOperation],
         ["addIndexer", fixtures.validAddIndexer],
         ["removeIndexer", fixtures.validRemoveIndexer],
         ["appendWhitelist", fixtures.validAppendWhitelist],
@@ -19,8 +27,12 @@ test('Happy path encode/decode roundtrip for protobuf applyOperation payloads',
         ["removeWriterPartial", fixtures.validPartialRemoveWriter],
         ["adminRecoveryComplete", fixtures.validCompleteAdminRecovery],
         ["adminRecoveryPartial", fixtures.validPartialAdminRecovery],
+        ["bootstrapDeploymentComplete", fixtures.validCompleteBootstrapDeployment],
+        ["bootstrapDeploymentPartial", fixtures.validPartialBootstrapDeployment],
         ["transferComplete", fixtures.validTransferOperation],
-        ["balanceInitialization", fixtures.validBalanceInitOperation]
+        ["transferPartial", fixtures.validPartialTransferOperation],
+        ["balanceInitialization", fixtures.validBalanceInitOperation],
+        ["disableInitialization", fixtures.validDisableInitialization],
     ]);
 
     for (const [key, value] of payloadsHashMap) {
@@ -101,6 +113,13 @@ test('Protobuf encode/decode is order-independent for all operation types', t =>
     let decoded = applyOperations.Operation.decode(encoded);
     t.ok(JSON.stringify(decoded) === JSON.stringify(fixtures.validTransactionOperation), 'TX operation encodes/decodes correctly with shuffled fields');
 
+    // Test TX operation (partial)
+    const shuffledPartialTxo = shuffleObject(fixtures.validPartialTransactionOperation.txo);
+    const shuffledPartialTx = { ...fixtures.validPartialTransactionOperation, txo: shuffledPartialTxo };
+    encoded = applyOperations.Operation.encode(shuffledPartialTx);
+    decoded = applyOperations.Operation.decode(encoded);
+    t.ok(JSON.stringify(decoded) === JSON.stringify(fixtures.validPartialTransactionOperation), 'Partial TX operation encodes/decodes correctly with shuffled fields');
+
     // Test TRANSFER operation
     const shuffledTro = shuffleObject(fixtures.validTransferOperation.tro);
     const shuffledTransfer = { ...fixtures.validTransferOperation, tro: shuffledTro };
@@ -108,6 +127,13 @@ test('Protobuf encode/decode is order-independent for all operation types', t =>
     decoded = applyOperations.Operation.decode(encoded);
     t.ok(JSON.stringify(decoded) === JSON.stringify(fixtures.validTransferOperation), 'TRANSFER operation encodes/decodes correctly with shuffled fields');
 
+    // Test TRANSFER operation (partial)
+    const shuffledPartialTro = shuffleObject(fixtures.validPartialTransferOperation.tro);
+    const shuffledPartialTransfer = { ...fixtures.validPartialTransferOperation, tro: shuffledPartialTro };
+    encoded = applyOperations.Operation.encode(shuffledPartialTransfer);
+    decoded = applyOperations.Operation.decode(encoded);
+    t.ok(JSON.stringify(decoded) === JSON.stringify(fixtures.validPartialTransferOperation), 'Partial TRANSFER operation encodes/decodes correctly with shuffled fields');
+
     // Test ADD_INDEXER operation
     const shuffledAco = shuffleObject(fixtures.validAddIndexer.aco);
     const shuffledAddIndexer = { ...fixtures.validAddIndexer, aco: shuffledAco };
@@ -184,4 +210,96 @@ test('Protobuf encode/decode is order-independent for all operation types', t =>
     encoded = applyOperations.Operation.encode(shuffledPartialAdminRecovery);
     decoded = applyOperations.Operation.decode(encoded);
     t.ok(JSON.stringify(decoded) === JSON.stringify(fixtures.validPartialAdminRecovery), 'Partial ADMIN_RECOVERY operation encodes/decodes correctly with shuffled fields');
+
+    // Test BOOTSTRAP_DEPLOYMENT (complete) operation
+    const shuffledCompleteBootstrapBdo = shuffleObject(fixtures.validCompleteBootstrapDeployment.bdo);
+    const shuffledCompleteBootstrap = { ...fixtures.validCompleteBootstrapDeployment, bdo: shuffledCompleteBootstrapBdo };
+    encoded = applyOperations.Operation.encode(shuffledCompleteBootstrap);
+    decoded = applyOperations.Operation.decode(encoded);
+    t.ok(JSON.stringify(decoded) === JSON.stringify(fixtures.validCompleteBootstrapDeployment), 'Complete BOOTSTRAP_DEPLOYMENT operation encodes/decodes correctly with shuffled fields');
+
+    // Test BOOTSTRAP_DEPLOYMENT (partial) operation
+    const shuffledPartialBootstrapBdo = shuffleObject(fixtures.validPartialBootstrapDeployment.bdo);
+    const shuffledPartialBootstrap = { ...fixtures.validPartialBootstrapDeployment, bdo: shuffledPartialBootstrapBdo };
+    encoded = applyOperations.Operation.encode(shuffledPartialBootstrap);
+    decoded = applyOperations.Operation.decode(encoded);
+    t.ok(JSON.stringify(decoded) === JSON.stringify(fixtures.validPartialBootstrapDeployment), 'Partial BOOTSTRAP_DEPLOYMENT operation encodes/decodes correctly with shuffled fields');
+
+    // Test BALANCE_INITIALIZATION operation
+    const shuffledBio = shuffleObject(fixtures.validBalanceInitOperation.bio);
+    const shuffledBalanceInit = { ...fixtures.validBalanceInitOperation, bio: shuffledBio };
+    encoded = applyOperations.Operation.encode(shuffledBalanceInit);
+    decoded = applyOperations.Operation.decode(encoded);
+    t.ok(JSON.stringify(decoded) === JSON.stringify(fixtures.validBalanceInitOperation), 'BALANCE_INITIALIZATION operation encodes/decodes correctly with shuffled fields');
+
+    // Test DISABLE_INITIALIZATION operation
+    const shuffledDisableCao = shuffleObject(fixtures.validDisableInitialization.cao);
+    const shuffledDisableInitialization = { ...fixtures.validDisableInitialization, cao: shuffledDisableCao };
+    encoded = applyOperations.Operation.encode(shuffledDisableInitialization);
+    decoded = applyOperations.Operation.decode(encoded);
+    t.ok(JSON.stringify(decoded) === JSON.stringify(fixtures.validDisableInitialization), 'DISABLE_INITIALIZATION operation encodes/decodes correctly with shuffled fields');
+});
+
+test('encodeV1networkOperation/decodeV1networkOperation roundtrip for network v1 payloads', t => {
+    const payloadsHashMap = new Map([
+        ['validatorConnectionRequest', networkV1Fixtures.payloadValidatorConnectionRequest],
+        ['validatorConnectionResponse', networkV1Fixtures.payloadValidatorConnectionResponse],
+        ['livenessRequest', networkV1Fixtures.payloadLivenessRequest],
+        ['livenessResponse', networkV1Fixtures.payloadLivenessResponse],
+        ['broadcastTransactionRequest', networkV1Fixtures.payloadBroadcastTransactionRequest],
+        ['broadcastTransactionResponse', networkV1Fixtures.payloadBroadcastTransactionResponse],
+    ]);
+
+    for (const [key, payload] of payloadsHashMap) {
+        const encoded = encodeV1networkOperation(payload);
+        const decoded = decodeV1networkOperation(encoded);
+        t.ok(b4a.isBuffer(encoded) && encoded.length > 0, `Payload ${key} encodes to a non-empty buffer`);
+        t.ok(JSON.stringify(decoded) === JSON.stringify(payload), `Payload ${key} decodes back correctly`);
+    }
+});
+
+test('safeEncodeApplyOperation returns an empty buffer on encode errors (and does not throw)', t => {
+    const originalLog = console.log;
+    console.log = () => {};
+    try {
+        const encoded = safeEncodeApplyOperation(fixtures.invalidPayloadWithMultipleOneOfKeys);
+        t.ok(b4a.isBuffer(encoded));
+        t.is(encoded.length, 0);
+    } finally {
+        console.log = originalLog;
+    }
+});
+
+test('safeEncodeApplyOperation encodes valid payloads to a non-empty buffer', t => {
+    const encoded = safeEncodeApplyOperation(fixtures.validTransactionOperation);
+    t.ok(b4a.isBuffer(encoded));
+    t.ok(encoded.length > 0);
+});
+
+test('safeDecodeApplyOperation returns null for invalid input (and does not throw)', t => {
+    t.is(safeDecodeApplyOperation(null), null);
+    t.is(safeDecodeApplyOperation({}), null);
+    t.is(safeDecodeApplyOperation('not-a-buffer'), null);
+
+    const originalLog = console.log;
+    console.log = () => {};
+    try {
+        t.is(safeDecodeApplyOperation(b4a.from([0x0F])), null);
+    } finally {
+        console.log = originalLog;
+    }
+});
+
+test('normalizeIncomingMessage decodes buffers and JSON buffers', t => {
+    const payload = fixtures.validTransactionOperation;
+    const encoded = applyOperations.Operation.encode(payload);
+
+    const decodedFromBuffer = normalizeIncomingMessage(encoded);
+    t.ok(JSON.stringify(decodedFromBuffer) === JSON.stringify(payload));
+
+    const decodedFromJsonBuffer = normalizeIncomingMessage({ type: 'Buffer', data: Array.from(encoded) });
+    t.ok(JSON.stringify(decodedFromJsonBuffer) === JSON.stringify(payload));
+
+    t.is(normalizeIncomingMessage(null), null);
+    t.is(normalizeIncomingMessage({ type: 'nope', data: [] }), null);
 });

package/tests/unit/utils/type/type.test.js

@@ -0,0 +1,25 @@
+import test from 'brittle';
+import { isDefined } from '../../../../src/utils/type.js';
+
+const assertIsDefined = (t, value, expected, message) => {
+    try {
+        t.is(isDefined(value), expected, message);
+    } catch (err) {
+        t.fail(`${message}. Threw: ${err.message}`);
+    }
+};
+
+test('isDefined returns false for nullish and NaN', t => {
+    assertIsDefined(t, null, false, 'null should be treated as not defined');
+    assertIsDefined(t, void 0, false, 'undefined should be treated as not defined');
+    assertIsDefined(t, NaN, false, 'NaN should be treated as not defined');
+});
+
+test('isDefined returns true for defined non-NaN values', t => {
+    assertIsDefined(t, 0, true, '0 should be treated as defined');
+    assertIsDefined(t, Infinity, true, 'Infinity should be treated as defined');
+    assertIsDefined(t, '', true, 'empty string should be treated as defined');
+    assertIsDefined(t, false, true, 'boolean false should be treated as defined');
+    assertIsDefined(t, {}, true, 'object should be treated as defined');
+    assertIsDefined(t, [], true, 'array should be treated as defined');
+});

package/tests/unit/utils/utils.test.js

@@ -12,6 +12,7 @@ async function runTests() {
 	await import('./fileUtils/readBalanceMigrationFile.test.js');
 	await import('./migrationUtils/validateAddressFromIncomingFile.test.js');
 	await import('./buffer/buffer.test.js')
+	await import('./type/type.test.js');
 	await import('./amountSerialization/amountSerialization.test.js');
 	test.resume();
 }

package/docs/networking-dualstack-plan.md

@@ -1,75 +0,0 @@
-# Dual-stack plan with design patterns (legacy JSON + network/v1)
-
-This is a design plan only (no implementation yet).
-
-## Project map (current)
-- `src/core/network/Network.js`: facade for swarm, services, and message setup.
-- `src/core/network/protocols/NetworkMessages.js`: Protomux wiring for legacy JSON.
-- `src/core/network/protocols/legacy/`: legacy router + handlers + validators.
-- `src/core/network/protocols/shared/`: shared operation handlers + validators.
-- `src/core/network/services/ConnectionManager.js`: validator pool and messaging.
-- `src/core/network/services/MessageOrchestrator.js`: legacy broadcast heuristic.
-- `src/messages/network/v1/`: builder/director/factory for v1 messages.
-- `proto/network.proto` + `src/utils/protobuf/network.cjs`: v1 schema/codec.
-
-## Design patterns to use (and where)
-- Strategy + Adapter: protocol-specific adapters per version (`legacy`, `v1`, future `v2`).
-- Registry + Factory: centralized list of protocol descriptors, created once.
-- Chain of Responsibility: routing table of predicates -> handlers (replace long if/else).
-- Template Method: already in `BaseOperationHandler`, keep as shared entry point.
-- Command: operation handlers as commands dispatched by a protocol router.
-- State Machine: handshake + capability negotiation for `network/v1`.
-- Mediator: `MessageOrchestrator` coordinates `ConnectionManager` and state.
-- Observer: emit connection/protocol events to interested services.
-- Decorator: wrap handlers with rate limit, logging, metrics.
-- Null Object: no-op messenger to avoid null checks in send paths.
-
-## Target architecture (pattern-oriented)
-1. ProtocolAdapter interface (Strategy + Adapter)
-   - Shape: `id`, `protocolName`, `encoding`, `router`, `handshake`, `encode`, `decode`.
-   - `LegacyProtocolAdapter` wraps `legacy/NetworkMessageRouter` with `c.json`.
-   - `V1ProtocolAdapter` wraps protobuf decode/encode and a v1 router.
-
-2. ProtocolRegistry (Registry + Factory)
-   - Single source of enabled protocols: `[legacyAdapter, v1Adapter]`.
-   - Owns protocol names (`legacy` channel from config, `network/v1`).
-   - Exposed to `NetworkMessages` for channel creation.
-
-3. ProtocolSession per connection (Facade + Null Object)
-   - `session.messengers.{legacy,v1}` with a `NullMessenger` fallback.
-   - `session.protocols` is a `Set` of negotiated protocols.
-   - Stored in `ConnectionManager` alongside peer metadata.
-
-4. Router refactor (Chain of Responsibility + Command)
-   - `legacy` router: table of `canHandle(message)` + `handler.execute()`.
-   - `v1` router: map `MessageType -> handler`.
-   - Shared operation handlers remain in `shared/handlers/`.
-
-5. Handshake state machine (State)
-   - Per-connection state: `init -> awaiting_ack -> open -> failed`.
-   - On success, mark `session.protocols.add('v1')`.
-   - On timeout, keep `legacy` only (no disconnect).
-
-6. Orchestrator protocol selection (Strategy)
-   - `ProtocolSelector`: choose v1 if peer supports it, else legacy.
-   - v1 ACK uses response codes; legacy uses state-based heuristic.
-   - Optional strict verify for v1: wait for append before success.
-
-7. Validators layout (Template Method + Adapter)
-   - Keep shared validators in `shared/validators/`.
-   - Protocol-specific validators live under `legacy/validators/` and `v1/validators/`.
-   - Protocol adapter decides which validator set to use.
-
-## Step-by-step plan
-1. Add `ProtocolRegistry` and `ProtocolAdapter` definitions (design only).
-2. Update `NetworkMessages` to iterate registry and open one channel per protocol.
-3. Introduce `ProtocolSession` and store it in `ConnectionManager`.
-4. Implement v1 router map based on `proto/network.proto` types.
-5. Add v1 handshake state machine and capability negotiation.
-6. Add `ProtocolSelector` in `MessageOrchestrator` with legacy fallback.
-7. Align validators: shared core + protocol-specific wrappers.
-8. Tests (future): legacy-only peers, v1 negotiation, mixed cluster.
-
-## Notes for v2
-- Add `network/v2` adapter + protobuf schema.
-- Registry chooses the highest common protocol per peer.

package/docs/networking-layer-redesign.md

@@ -1,155 +0,0 @@
-# Networking layer redesign (draft)
-
-Cel: uporządkować warstwę sieciową w `src/core/network`, wprowadzić binarne wiadomości (Protobuf + Protomux), system ACK/heartbeat, zunifikowane kody błędów oraz nowy endpoint RPC, bez ingerencji w istniejącą implementację (ten dokument jest tylko projektem).
-
-## Założenia
-- Komunikacja p2p przez Hyperswarm zostaje, ale wiadomości idą binarnie (Protobuf) na kanałach Protomux.
-- Każdy typ wiadomości zwraca `Result` z kodem sukcesu/błędu (własne kody, nie HTTP).
-- Heartbeat/liveness co ~10s z losowym jitterem; łatwa konfiguracja z `config`/`constants`.
-- Handshake z zachowaniem PKI, ale mniej round-tripów i z ochroną DoS.
-- Modularna architektura (klasy/serwisy), separacja transportu, protokołu, zdrowia, bezpieczeństwa i RPC.
-
-## Architektura warstw
-- **Transport (HyperswarmTransport)**: zarządza swarmem, tworzy kanały Protomux (binary encoding), egzekwuje limity połączeń.
-- **Protocol (EnvelopeCodec, Protobuf schemas)**: wspólny `Envelope` + `Result`; mapowanie typów wiadomości; validacja długości/pól przed dekodowaniem.
-- **Handshake (ValidatorHandshake)**: szybki trójfazowy handshake z wyzwaniem nonce + podpis, negocjacja wersji/capabilities, limity prób.
-- **Health (HeartbeatScheduler + LivenessStore)**: wysyła heartbeat do wszystkich znanych peerów (z konekcji lub z listy validatorów), aktualizuje liveness, generuje zdarzenia dla RPC.
-- **Security (DosGuard)**: rate limit per peer/endpoint, maks. rozmiary payloadów, kolejki handshake, banlista czasowa.
-- **RPC adapter (ValidatorStatusController)**: odczytuje `LivenessStore` i zwraca status walidatora.
-
-## Proponowane moduły / pliki (kierunek, bez implementacji)
-- `src/core/network/transport/HyperswarmTransport.js`: opakowanie na Hyperswarm + Protomux, jednolity interfejs kanałów binarnych.
-- `src/core/network/protocol/EnvelopeCodec.js`: enkodowanie/dekodowanie Protobuf, walidacja schematu, mapowanie `MessageType` -> handler.
-- `src/core/network/protocol/error-codes.js`: stałe kodów (`ErrorCode` enum) współdzielone między node'ami.
-- `src/core/network/handshake/ValidatorHandshake.js`: stan maszyny handshake, ochrona DoS, fallbacki wersji.
-- `src/core/network/health/HeartbeatScheduler.js`: harmonogram heartbeatów + jitter, retry/backoff.
-- `src/core/network/health/LivenessStore.js`: przechowuje `lastSeen`, `missed`, `state=active/inactive/banned`.
-- `src/core/network/security/DosGuard.js`: token bucket + ograniczenia równoległych handshake, limit rozmiaru wiadomości.
-- `src/core/network/rpc/ValidatorStatusController.js`: integracja z istniejącym RPC routerem (`/validators/:address/status`).
-
-## Szkic Protobuf (draft, do dodania jako nowy `.proto`)
-```proto
-syntax = "proto3";
-package network.v1;
-
-enum MessageType {
-  UNKNOWN = 0;
-  HANDSHAKE_INIT = 1;
-  HANDSHAKE_ACK = 2;
-  HEARTBEAT_PING = 3;
-  HEARTBEAT_ACK = 4;
-  VALIDATOR_STATUS_REQUEST = 5;
-  VALIDATOR_STATUS_RESPONSE = 6;
-  // ...pozostałe typy operacyjne (transfer/role) mogą być zmapowane później
-}
-
-enum ResultCode {
-  RESULT_OK = 0;
-  RESULT_RETRY = 1;            // używane do łagodnego backoffu
-  RESULT_INVALID_PAYLOAD = 2;
-  RESULT_UNAUTHORIZED = 3;
-  RESULT_UNAUTHENTICATED = 4;
-  RESULT_UNSUPPORTED_VERSION = 5;
-  RESULT_RATE_LIMITED = 6;
-  RESULT_TOO_MANY_CONNECTIONS = 7;
-  RESULT_BUSY = 8;
-  RESULT_TIMEOUT = 9;
-  RESULT_PEER_BANNED = 10;
-  RESULT_SIGNATURE_INVALID = 11;
-  RESULT_NOT_VALIDATOR = 12;
-  RESULT_INTERNAL = 13;
-}
-
-message Result {
-  ResultCode code = 1;
-  string reason = 2;
-}
-
-message Envelope {
-  uint64 session_id = 1;
-  MessageType type = 3;
-  bytes payload = 4;         // zakodowany message specyficzny dla type
-  Result result = 5;         // dla odpowiedzi/ACK
-  uint64 timestamp = 6;
-}
-
-message HandshakeInit {
-  bytes node_pk = 1;
-  uint32 version = 2;
-  bytes nonce = 3;
-  bytes signature = 4; // sig(nonce || channel || version)
-  repeated string capabilities = 5; // np. ["binary", "hb:v1"]
-}
-
-message HandshakeAck {
-  bytes nonce = 1;           // nonce od inicjatora
-  bytes signature = 2;       // sig(nonce || channel || version)
-  uint32 version = 3;        // negocjowany
-  Result result = 4;         // ERROR_UNSUPPORTED_VERSION itd.
-}
-
-message HeartbeatPing {
-  bytes node_pk = 1;
-  uint64 sequence = 2;
-  uint64 timestamp_ms = 3;
-}
-
-message HeartbeatAck {
-  uint64 sequence = 1;
-  Result result = 2;         // ERROR_OK lub powód degradacji
-  uint64 timestamp_ms = 3;
-}
-
-message ValidatorStatusRequest {
-  bytes validator_pk = 1;
-}
-
-message ValidatorStatusResponse {
-  Result result = 1;
-  bool active = 2;
-  uint64 last_seen_ms = 3;
-  uint32 missed_heartbeats = 4;
-}
-```
-
-## Handshake (przykładowy przebieg)
-1. **Init**: inicjator wysyła `HandshakeInit` na dedykowany kanał Protomux `protocol:handshake/v1` (binary). Dodajemy `DosGuard` limitujący równoległe init-y i weryfikujący rozmiar.
-2. **Ack**: odbiorca weryfikuje podpis i wersję, odpowiada `HandshakeAck` (sukces lub błąd). Przy sukcesie odkłada połączenie do `ConnectionManager` razem z metadanymi (rola, capabilities).
-3. **Promotion**: dopiero po sukcesie handshake kanały operacyjne/heartbeat są otwierane; w przeciwnym razie połączenie jest zamykane i peer może trafić na banlistę czasową.
-
-Minimalizuje to round-trip (1.5 RTT), utrzymuje PKI (nonce + podpis) i pozwala na rollback do niższej wersji jeśli różne węzły.
-
-## Heartbeat / liveness
-- **Interwał**: domyślnie 10s ± losowy jitter (np. 0–2s) by uniknąć szpilek. Parametryzacja w constants/config.
-- **Zakres**: każda znana para (aktywny validator + inne role) dostaje `HeartbeatPing`. Po 3 nieudanych ACK (lub braków w oknie czasowym) peer przechodzi w `inactive`, po większej liczbie w `unhealthy`.
-- **Integracja**: `HeartbeatScheduler` korzysta z `ConnectionManager` do nadawania; `LivenessStore` aktualizuje się na podstawie `HeartbeatAck` i czasu.
-- **Odpowiedź**: `HeartbeatAck.result.code` pozwala zakomunikować throttle (`ERROR_RATE_LIMITED`) lub przepełnienie (`ERROR_BUSY`), co zmniejsza logowanie błędów.
-
-## Nowy endpoint RPC
-- Ścieżka: `GET /validators/:address/status` w warstwie RPC.
-- Źródło prawdy: `LivenessStore` (ostatni heartbeat, liczba nieodebranych, stan). `active=true` gdy ostatni heartbeat < 3*interval i brak poważnych błędów.
-- Payload (200): `{ address, active, lastSeenMs, missed, reason }`. Brak zależności od kodów HTTP dla logiki aplikacyjnej; HTTP 404 tylko gdy adres niepoprawny (opcjonalnie 200 z `active:false` i `result.code=ERROR_NOT_VALIDATOR`).
-- Przygotować kontrakt dla klientów (CLI/SDK) by interpretowali `Result`.
-
-## Ochrona przed DoS
-- **Rate limiting**: token bucket per peer na handshake i heartbeat, limity równoległych handshake w `DosGuard`.
-- **Rozmiary**: twarde limity na rozmiar pakietu Protobuf przed deserializacją; odrzucenie z `ERROR_INVALID_PAYLOAD`.
-- **Kolejki**: ograniczona kolejka zadań handshake/heartbeat; przy przepełnieniu `ERROR_BUSY` w ACK i zamknięcie połączenia.
-- **Bany czasowe**: peer wysyłający zbyt wiele złych podpisów lub oversize payloadów trafia na banlistę na X minut.
-- **Separacja kanałów**: osobne kanały Protomux (handshake, control/heartbeat, operations) by odciąć hałas od głównych operacji.
-
-## Kody błędów (wspólny enum)
-- Sukces: `ERROR_OK`.
-- Autoryzacja: `ERROR_UNAUTHENTICATED`, `ERROR_UNAUTHORIZED`, `ERROR_SIGNATURE_INVALID`, `ERROR_NOT_VALIDATOR`.
-- Dostępność: `ERROR_RATE_LIMITED`, `ERROR_BUSY`, `ERROR_TOO_MANY_CONNECTIONS`, `ERROR_PEER_BANNED`.
-- Protokół: `ERROR_INVALID_PAYLOAD`, `ERROR_UNSUPPORTED_VERSION`, `ERROR_TIMEOUT`.
-- Ogólne: `ERROR_RETRY` (miękkie), `ERROR_INTERNAL`.
-
-## Plan wdrożenia (wysoki poziom)
-1. Dodać schemat `.proto` z Envelope/Result/Handshake/Heartbeat/Status.
-2. Wydzielić `transport/` + `protocol/` + `handshake/` + `health/` + `security/` katalogi i przenieść istniejące odpowiedniki (`NetworkMessages`, router, itp.) stopniowo.
-3. Zaimplementować `EnvelopeCodec` w Protomux (binary), przełączyć routing na typy wiadomości zamiast JSON.
-4. Zaimplementować handshake (1.5 RTT) i dołożyć `DosGuard` oraz limity na poziomie Protomux channel.
-5. Dodać HeartbeatScheduler + LivenessStore, zasilić je danymi do RPC.
-6. Dodać endpoint RPC `/validators/:address/status`, mapujący dane z LivenessStore.
-7. Testy: symulacja DoS (próby handshake > limit, oversize payload), degradacja heartbeat, negocjacja wersji i kompatybilności.

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

@@ -1,64 +0,0 @@
-
-import Protomux from 'protomux';
-import b4a from 'b4a';
-import c from 'compact-encoding';
-import NetworkMessageRouter from './routes/NetworkMessageRouter.js';
-import Network from '../Network.js';
-
-class NetworkMessages {
-    #messageRouter;
-    #network;
-    #config;
-
-    /**
-     * @param {Network} network
-     * @param {object} config
-     **/
-    constructor(network, config) {
-        this.#network = network;
-        this.#config = config;
-    }
-
-    initializeMessageRouter(state, wallet) {
-        this.#messageRouter = new NetworkMessageRouter(
-            this.#network,
-            state,
-            wallet,
-            this.#config
-        );
-    }
-
-    async setupProtomuxMessages(connection) {
-        const mux = Protomux.from(connection);
-        connection.userData = mux;
-        const message_channel = mux.createChannel({
-            protocol: b4a.toString(this.#config.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) {
-                    console.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;

package/src/core/network/messaging/handlers/GetRequestHandler.js

@@ -1,113 +0,0 @@
-import { NETWORK_MESSAGE_TYPES } from '../../../../utils/constants.js';
-import PeerWallet from 'trac-wallet';
-import b4a from 'b4a';
-
-class GetRequestHandler {
-    #wallet;
-    #state;
-
-    constructor(wallet, state) {
-        this.#wallet = wallet;
-        this.#state = state;
-    }
-
-    get state() {
-        return this.#state;
-    }
-
-    async handle(message, messageProtomux, connection, channelString) {
-        switch (message) {
-            case NETWORK_MESSAGE_TYPES.GET.VALIDATOR:
-                await this.handleGetValidatorResponse(messageProtomux, connection, channelString);
-                break;
-            case NETWORK_MESSAGE_TYPES.GET.ADMIN:
-                await this.handleGetAdminRequest(messageProtomux, connection, channelString);
-                break;
-            case NETWORK_MESSAGE_TYPES.GET.NODE:
-                await this.handleCustomNodeRequest(messageProtomux, connection, channelString);
-                break;
-            default:
-                throw new Error(`Unhandled GET type: ${message}`);
-        }
-    }
-
-    async handleGetValidatorResponse(messageProtomux, connection, channelString) {
-        const nonce = PeerWallet.generateNonce().toString('hex');
-        const payload = {
-            op: 'validatorResponse',
-            wk: this.state.writingKey.toString('hex'),
-            address: this.#wallet.address,
-            nonce: nonce,
-            channel: channelString,
-            issuer: connection.remotePublicKey.toString('hex'),
-            timestamp: Date.now(),
-        };
-
-
-        const hashInput = b4a.from(JSON.stringify(payload), 'utf8');
-        const hash = await PeerWallet.blake3(hashInput);
-        const sig = this.#wallet.sign(hash);
-
-        const responseMessage = {
-            ...payload,
-            sig: sig.toString('hex'),
-        };
-        messageProtomux.send(responseMessage);
-    }
-
-    async handleGetAdminRequest(messageProtomux, connection, channelString) {
-        const adminEntry = await this.state.getAdminEntry();
-        if (adminEntry === null) {
-            throw new Error("Admin entry is null. This is not possible to create admin stream.");
-        }
-
-        const adminPublicKey = PeerWallet.decodeBech32m(adminEntry.address);
-
-        if (!b4a.equals(this.#wallet.publicKey, adminPublicKey)) {
-            throw new Error("You are not an admin. This is not possible to create admin stream.");
-        }
-
-        const nonce = PeerWallet.generateNonce().toString('hex');
-        const payload = {
-            op: 'adminResponse',
-            wk: this.state.writingKey.toString('hex'),
-            address: this.#wallet.address,
-            nonce: nonce,
-            channel: channelString,
-            issuer: connection.remotePublicKey.toString('hex'),
-            timestamp: Date.now(),
-        };
-        const hash = await PeerWallet.blake3(JSON.stringify(payload));
-        const sig = this.#wallet.sign(hash);
-
-        const responseMessage = {
-            ...payload,
-            sig: sig.toString('hex'),
-        };
-        messageProtomux.send(responseMessage);
-    }
-
-    async handleCustomNodeRequest(messageProtomux, connection, channelString) {
-        const nonce = PeerWallet.generateNonce().toString('hex');
-        const payload = {
-            op: 'nodeResponse',
-            address: this.#wallet.address,
-            nonce: nonce,
-            channel: channelString,
-            issuer: connection.remotePublicKey.toString('hex'),
-            timestamp: Date.now(),
-        };
-        
-        const hash = await PeerWallet.blake3(JSON.stringify(payload));
-        const sig = this.#wallet.sign(hash);
-
-        const responseMessage = {
-            ...payload,
-            sig: sig.toString('hex'),
-        };
-        messageProtomux.send(responseMessage);
-
-    }
-}
-
-export default GetRequestHandler;