trac-msb 0.2.8 → 0.2.9

package/msb.mjs

@@ -15,8 +15,8 @@ const rpc = {
 }
 
 const options = args.includes('--rpc') ? rpc : { storeName }
-
-const msb = new MainSettlementBus(createConfig(ENV.MAINNET, options));
+const config = createConfig(ENV.MAINNET, options)
+const msb = new MainSettlementBus(config);
 
 msb.ready().then(async () => {
     if (runRpc) {
@@ -25,7 +25,7 @@ msb.ready().then(async () => {
         const port = (portIndex !== -1 && args[portIndex + 1]) ? parseInt(args[portIndex + 1], 10) : 5000;
         const hostIndex = args.indexOf('--host');
         const host = (hostIndex !== -1 && args[hostIndex + 1]) ? args[hostIndex + 1] : 'localhost';
-        startRpcServer(msb, host, port);
+        startRpcServer(msb, config , host, port);
     } else {
         console.log('RPC server will not be started.');
         msb.interactiveMode();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trac-msb",
   "main": "msb.mjs",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "pear": {
     "name": "trac-msb",
     "type": "terminal"
@@ -49,8 +49,9 @@
     "protomux-wakeup": "2.4.0",
     "readline": "npm:bare-node-readline",
     "ready-resource": "1.1.2",
-    "trac-wallet": "0.0.43-msb-r2.9",
-    "tty": "npm:bare-node-tty"
+    "trac-wallet": "1.0.1",
+    "tty": "npm:bare-node-tty",
+    "uuid": "^13.0.0"
   },
   "devDependencies": {
     "bare-os": "^3.6.1",
@@ -66,5 +67,9 @@
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Trac-Systems/main_settlement_bus"
   }
 }

package/proto/network.proto

@@ -0,0 +1,74 @@
+syntax = "proto3";
+
+package network.v1;
+
+enum MessageType {
+    MESSAGE_TYPE_UNSPECIFIED = 0;
+    MESSAGE_TYPE_VALIDATOR_CONNECTION_REQUEST = 1;
+    MESSAGE_TYPE_VALIDATOR_CONNECTION_RESPONSE = 2;
+    MESSAGE_TYPE_LIVENESS_REQUEST = 3;
+    MESSAGE_TYPE_LIVENESS_RESPONSE = 4;
+    MESSAGE_TYPE_BROADCAST_TRANSACTION_REQUEST = 5;
+    MESSAGE_TYPE_BROADCAST_TRANSACTION_RESPONSE = 6;
+}
+
+enum ResultCode {
+    RESULT_CODE_UNSPECIFIED = 0;
+    RESULT_CODE_OK = 1;
+    RESULT_CODE_INVALID_PAYLOAD = 2;
+    RESULT_CODE_UNSUPPORTED_VERSION = 3;
+    RESULT_CODE_RATE_LIMITED = 4;
+    RESULT_CODE_TIMEOUT = 5;
+    RESULT_CODE_SIGNATURE_INVALID = 6;
+}
+
+message ValidatorConnectionRequest {
+    string issuer_address = 1;
+    bytes nonce = 2;
+    bytes signature = 3;
+}
+
+message ValidatorConnectionResponse {
+    string issuer_address = 1;
+    bytes nonce = 2;
+    bytes signature = 3;
+    ResultCode result = 4;
+}
+
+message LivenessRequest {
+    bytes nonce = 1;
+    bytes signature = 2;
+}
+
+message LivenessResponse {
+    bytes nonce = 1;
+    bytes signature = 2;
+    ResultCode result = 3;
+}
+
+message BroadcastTransactionRequest {
+    bytes data = 1; // binary encoded payload
+    bytes nonce = 2;
+    bytes signature = 3;
+}
+
+message BroadcastTransactionResponse {
+    bytes nonce = 1;
+    bytes signature = 2;
+    ResultCode result = 3;
+}
+
+message MessageHeader {
+    MessageType type = 1;
+    string id = 2;
+    uint64 timestamp = 3;
+    oneof field {
+        ValidatorConnectionRequest            validator_connection_request  = 4;
+        ValidatorConnectionResponse           validator_connection_response  = 5;
+        LivenessRequest                       liveness_request = 6;
+        LivenessResponse                      liveness_response = 7;
+        BroadcastTransactionRequest           broadcast_transaction_request = 8;
+        BroadcastTransactionResponse          broadcast_transaction_response = 9;
+    }
+    repeated string capabilities = 10;
+}

package/rpc/create_server.js

@@ -3,7 +3,7 @@ import http from 'http'
 import { applyCors } from './cors.js';
 import { routes } from './routes/index.js';
 
-export const createServer = (msbInstance) => {
+export const createServer = (msbInstance, config) => {
   const server = http.createServer({}, async (req, res) => {
     
     // --- 1. Define safe 'respond' utility (Payload MUST be an object) ---
@@ -53,7 +53,7 @@ export const createServer = (msbInstance) => {
             try {
                 // This try/catch covers synchronous errors and errors from awaited promises
                 // within the route.handler function.
-                await route.handler({ req, res, respond, msbInstance });
+                await route.handler({ req, res, respond,  msbInstance, config});
             } catch (error) {
                 // Catch errors thrown directly from the handler (or its awaited parts)
                 console.error(`Error on ${route.path}:`, error);

package/rpc/handlers.js

@@ -52,7 +52,7 @@ export async function handleConfirmedLength({ msbInstance, respond }) {
     respond(200, { confirmed_length });
 }
 
-export async function handleBroadcastTransaction({ msbInstance, respond, req }) {
+export async function handleBroadcastTransaction({ msbInstance, config, respond, req }) {
     let body = '';
     req.on('data', chunk => {
         body += chunk.toString();
@@ -72,7 +72,7 @@ export async function handleBroadcastTransaction({ msbInstance, respond, req })
             const decodedPayload = decodeBase64Payload(payload);
             validatePayloadStructure(decodedPayload);
             const sanitizedPayload = sanitizeTransferPayload(decodedPayload);
-            const result = await broadcastTransaction(msbInstance, sanitizedPayload);
+            const result = await broadcastTransaction(msbInstance, config, sanitizedPayload);
             respond(200, { result });
         } catch (error) {
             let code = error instanceof SyntaxError ? 400 : 500;

package/rpc/rpc_server.js

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

package/rpc/rpc_services.js

@@ -1,6 +1,14 @@
 import { bufferToBigInt } from "../src/utils/amountSerialization.js";
-import { normalizeDecodedPayloadForJson } from "../src/utils/normalizers.js";
+import {
+    normalizeDecodedPayloadForJson,
+    normalizeTransactionOperation,
+    normalizeTransferOperation
+} from "../src/utils/normalizers.js";
 import { get_confirmed_tx_info, get_unconfirmed_tx_info } from "../src/utils/cli.js";
+import {OperationType} from "../src/utils/constants.js";
+import b4a from "b4a";
+import PartialTransaction from "../src/core/network/protocols/shared/validators/PartialTransaction.js";
+import PartialTransfer from "../src/core/network/protocols/shared/validators/PartialTransfer.js";
 
 export async function getBalance(msbInstance, address, confirmed) {
     const state = msbInstance.state;
@@ -36,8 +44,41 @@ export async function getUnconfirmedLength(msbInstance) {
     return msbInstance.state.getUnsignedLength();
 }
 
-export async function broadcastTransaction(msbInstance, payload) {
-    return msbInstance.broadcastTransactionCommand(payload);
+export async function broadcastTransaction(msbInstance, config, payload) {
+    if (!payload) {
+        throw new Error("Transaction payload is required for broadcasting.");
+    }
+    let normalizedPayload;
+    let isValid = false;
+    let hash;
+
+    const partialTransferValidator = new PartialTransfer(msbInstance.state, null , config);
+    const partialTransactionValidator = new PartialTransaction(msbInstance.state, null , config);
+
+    if (payload.type === OperationType.TRANSFER) {
+        normalizedPayload = normalizeTransferOperation(payload, config);
+        isValid = await partialTransferValidator.validate(normalizedPayload);
+        hash = b4a.toString(normalizedPayload.tro.tx, "hex");
+    } else if (payload.type === OperationType.TX) {
+        normalizedPayload = normalizeTransactionOperation(payload, config);
+        isValid = await partialTransactionValidator.validate(normalizedPayload);
+        hash = b4a.toString(normalizedPayload.txo.tx, "hex");
+    }
+
+    if (!isValid) {
+        throw new Error("Invalid transaction payload.");
+    }
+
+    const success = await msbInstance.broadcastPartialTransaction(payload);
+
+    if (!success) {
+        throw new Error("Failed to broadcast transaction after multiple attempts.");
+    }
+
+    const signedLength = msbInstance.state.getSignedLength();
+    const unsignedLength = msbInstance.state.getUnsignedLength();
+
+    return { message: "Transaction broadcasted successfully.", signedLength, unsignedLength, tx: hash };
 }
 
 export async function getTxHashes(msbInstance, start, end) {

package/rpc/utils/helpers.js

@@ -1,5 +1,5 @@
 import b4a from "b4a"
-import { operationToPayload } from "../../src/utils/operations.js"
+import { operationToPayload } from "../../src/utils/applyOperations.js"
 export function decodeBase64Payload(base64) {
 	let decodedPayloadString
 	try {

package/src/config/env.js

@@ -6,6 +6,8 @@ export const ENV = {
     DEVELOPMENT: 'development',
     TESTNET1: 'testnet1'
 }
+// TODO: CREATE TEST ENV CONFIG SIMILAR TO MAINNET AND USE IT IN TESTS.
+// TODO: CREATE TESTNET1 ENV CONFIG and update npm scripts to run node witn mainnet or testnet1.
 
 const configData = {
     [ENV.MAINNET]: {

package/src/core/network/Network.js

@@ -4,7 +4,7 @@ import w from 'protomux-wakeup';
 import b4a from 'b4a';
 import TransactionPoolService from './services/TransactionPoolService.js';
 import ValidatorObserverService from './services/ValidatorObserverService.js';
-import NetworkMessages from './messaging/NetworkMessages.js';
+import NetworkMessages from './protocols/NetworkMessages.js';
 import { sleep } from '../../utils/helpers.js';
 import {
     TRAC_NAMESPACE,
@@ -18,7 +18,8 @@ import ConnectionManager from './services/ConnectionManager.js';
 import MessageOrchestrator from './services/MessageOrchestrator.js';
 import NetworkWalletFactory from './identity/NetworkWalletFactory.js';
 import { EventType } from '../../utils/constants.js';
-
+import { networkMessageFactory } from '../../messages/network/v1/networkMessageFactory.js';
+import TransactionRateLimiterService from './services/TransactionRateLimiterService.js';
 // -- Debug Mode --
 // TODO: Implement a better debug system in the future. This is just temporary.
 const DEBUG = false;
@@ -42,6 +43,7 @@ class Network extends ReadyResource {
     #pendingConnections;
     #connectTimeoutMs;
     #maxPendingConnections;
+    #rateLimiter;
 
     /**
      * @param {State} state
@@ -53,18 +55,12 @@ class Network extends ReadyResource {
         this.#config = config
         this.#connectTimeoutMs = config.connectTimeoutMs || 5000;
         this.#maxPendingConnections = config.maxPendingConnections || 50;
-
         this.#pendingConnections = new Map();
         this.#transactionPoolService = new TransactionPoolService(state, address, this.#config);
         this.#validatorObserverService = new ValidatorObserverService(this, state, address, this.#config);
-        this.#networkMessages = new NetworkMessages(this, this.#config);
         this.#validatorConnectionManager = new ConnectionManager(this.#config);
         this.#validatorMessageOrchestrator = new MessageOrchestrator(this.#validatorConnectionManager, state, this.#config);
-        this.admin_stream = null;
-        this.admin = null;
-        this.validator = null;
-        this.custom_stream = null;
-        this.custom_node = null;
+
     }
 
     get swarm() {
@@ -97,6 +93,7 @@ class Network extends ReadyResource {
     }
 
     async _close() {
+        // TODO: Implement better "await" logic for stopping services
         console.log('Network: closing gracefully...');
         this.transactionPoolService.stopPool();
         await sleep(100);
@@ -119,7 +116,7 @@ class Network extends ReadyResource {
         });
 
         // VALIDATOR_CONNECTION_READY
-        this.on(EventType.VALIDATOR_CONNECTION_READY, ({ publicKey, type, connection }) => {
+        this.on(EventType.VALIDATOR_CONNECTION_READY, async ({ publicKey, type, connection }) => {
             debugLog(`Network Event: VALIDATOR_CONNECTION_READY | PublicKey: ${publicKey} | Type: ${type}`);
             const { timeoutId } = this.#pendingConnections.get(publicKey);
             if (!timeoutId) return;
@@ -128,19 +125,15 @@ class Network extends ReadyResource {
             this.#pendingConnections.delete(publicKey);
 
             if (type === 'validator') {
-                const target = b4a.from(publicKey, 'hex');
-                this.#validatorConnectionManager.addValidator(target, connection);
-                this.#sendRequestByType(connection, type);
+                await connection.protocolSession.send(NETWORK_MESSAGE_TYPES.GET.VALIDATOR);
             }
+
         });
     }
 
     cleanupNetworkListeners() {
-        // connect:timeout
-        this.removeAllListeners('connect:timeout');
-
-        // connect:ready
-        this.removeAllListeners('connect:ready');
+        this.removeAllListeners(EventType.VALIDATOR_CONNECTION_TIMEOUT);
+        this.removeAllListeners(EventType.VALIDATOR_CONNECTION_READY);
     }
 
     cleanupPendingConnections() {
@@ -167,12 +160,23 @@ class Network extends ReadyResource {
                 maxClientConnections: MAX_CLIENT_CONNECTIONS
             });
 
+            this.#rateLimiter = new TransactionRateLimiterService(this.#swarm);
+            this.#networkMessages = new NetworkMessages(
+                state,
+                wrappedWallet,
+                this.#rateLimiter,
+                this.#transactionPoolService,
+                this.#validatorConnectionManager,
+                this.#config
+            );
+
             console.log(`Channel: ${b4a.toString(this.#config.channel)}`);
-            this.#networkMessages.initializeMessageRouter(state, wrappedWallet);
 
             this.#swarm.on('connection', async (connection) => {
-                const { message_channel, message } = await this.#networkMessages.setupProtomuxMessages(connection);
-                connection.messenger = message;
+                // Per-peer connection initialization:
+                // - attach Protomux (legacy + v1 channels/messages)
+                // - attach connection.protocolSession (used later by tryConnect / orchestrators to send messages)
+                await this.#networkMessages.setupProtomuxMessages(connection);
 
                 // ATTENTION: Must be called AFTER the protomux init above
                 const stream = store.replicate(connection);
@@ -185,17 +189,9 @@ class Network extends ReadyResource {
                 }
 
                 connection.on('close', () => {
-                    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;
-                    }
-                    try { message_channel.close() } catch (e) { }
-
+                    this.#swarm.leavePeer(connection.remotePublicKey);
+                    this.#validatorConnectionManager.remove(publicKey);
+                    connection.protocolSession.close();
                 });
 
                 connection.on('error', (error) => {
@@ -209,7 +205,6 @@ class Network extends ReadyResource {
                         return;
                     }
                     console.error(error.message)
-
                 });
 
             });
@@ -259,7 +254,7 @@ class Network extends ReadyResource {
         const peerInfo = this.#swarm.peers.get(publicKey);
         if (peerInfo) {
             const connection = this.#swarm._allConnections.get(peerInfo.publicKey);
-            if (connection && connection.messenger) {
+            if (connection && connection.protocolSession) {
                 await this.#finalizeConnection(publicKey, type, connection);
             }
         }
@@ -276,33 +271,6 @@ class Network extends ReadyResource {
         debugLog(`Network.finalizeConnection: Connected to peer: ${publicKey} as type: ${type}`);
     }
 
-    async #sendRequestByType(stream, type) {
-        const waitFor = {
-            validator: () => this.validatorConnectionManager.connectionCount(),
-            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++;
-        }
-    }
-
     #getNetworkWalletWrapper(wallet, keyPair) {
         if (!this.#identityProvider) {
             this.#identityProvider = NetworkWalletFactory.provide({

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

@@ -1,7 +1,7 @@
 import PeerWallet from 'trac-wallet';
 import b4a from 'b4a';
 
-export class NetworkWalletFactory {
+class NetworkWalletFactory {
     static provide(options = {}) {
         const {
             enableWallet,
@@ -28,7 +28,7 @@ export class NetworkWalletFactory {
 // 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 {
+export class EphemeralWallet {
     #publicKey;
     #secretKey;
     #address;

package/src/core/network/protocols/LegacyProtocol.js

@@ -0,0 +1,67 @@
+import Protomux from 'protomux';
+import ProtocolInterface from './ProtocolInterface.js';
+import b4a from 'b4a';
+import c from 'compact-encoding';
+
+class LegacyProtocol extends ProtocolInterface {
+    #channel;
+    #session;
+    #config;
+    #router;
+
+    constructor(router, connection, config) {
+        super(router, connection, config);
+        this.#config = config;
+        this.#router = router;
+        this.init(connection);
+    }
+
+    get channel() {
+        return this.#channel;
+    }
+
+    get session() {
+        return this.#session;
+    }
+
+    init(connection) {
+        // TODO: Abstract in a separate function
+        const mux = Protomux.from(connection);
+        connection.userData = mux;
+
+        this.#channel = mux.createChannel({
+            protocol: b4a.toString(this.#config.channel, 'utf8'),
+            onopen() { },
+            onclose() { }
+        });
+
+        this.#channel.open();
+
+        // Todo: Abstract in a separate function
+        this.#session = this.#channel.addMessage({
+            encoding: c.json,
+            onmessage: async (incomingMessage) => {
+                try {
+                    if (typeof incomingMessage === 'object' || typeof incomingMessage === 'string') {
+                        await this.#router.route(incomingMessage, connection, this.#session);
+                    } else {
+                        throw new Error('NetworkMessages: Received message is undefined');
+                    }
+                } catch (error) {
+                    console.error(`NetworkMessages: Failed to handle incoming message: ${error.message}`);
+                }
+            }
+        });
+    }
+
+    send(message) {
+        this.#session.send(message);
+    }
+
+    close() {
+        this.#channel.close();
+    }
+
+}
+
+export default LegacyProtocol;

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

@@ -0,0 +1,48 @@
+
+import b4a from 'b4a';
+import NetworkMessageRouter from './legacy/NetworkMessageRouter.js';
+import NetworkMessageRouterV1 from './v1/NetworkMessageRouter.js';
+import ProtocolSession from './ProtocolSession.js';
+import LegacyProtocol from './LegacyProtocol.js';
+import V1Protocol from './V1Protocol.js';
+class NetworkMessages {
+    #legacyMessageRouter;
+    #v1MessageRouter;
+    #config;
+
+    /**
+     * @param {object} config
+     **/
+    constructor(state, wallet, rateLimiterService, txPoolService, connectionManager, config) {
+        this.#config = config;
+        this.#initializeMessageRouter(state, wallet, rateLimiterService, txPoolService, connectionManager);
+    }
+
+    #initializeMessageRouter(state, wallet, rateLimiterService, txPoolService, connectionManager) {
+        this.#legacyMessageRouter = new NetworkMessageRouter(
+            state,
+            wallet,
+            rateLimiterService,
+            txPoolService,
+            connectionManager,
+            this.#config
+        );
+        this.#v1MessageRouter = new NetworkMessageRouterV1(this.#config);
+    }
+
+    async setupProtomuxMessages(connection) {
+        // Attach a Protomux instance to this Hyperswarm connection.
+        // Protomux multiplexes multiple logical protocol channels over a single encrypted stream.
+
+        const legacyProtocol = new LegacyProtocol(this.#legacyMessageRouter, connection, this.#config);
+        const v1Protocol = new V1Protocol(this.#v1MessageRouter, connection, this.#config);
+
+        // ProtocolSession is attached to the Hyperswarm connection so other parts of the system (e.g. tryConnect)
+        // can send messages without knowing how Protomux was initialized.
+        const protocolSession = new ProtocolSession(legacyProtocol, v1Protocol);
+        connection.protocolSession = protocolSession;
+
+    }
+}
+
+export default NetworkMessages;

package/src/core/network/protocols/ProtocolInterface.js

@@ -0,0 +1,31 @@
+/**
+ * ProtocolInterface serves as a base class for all network protocol implementations.
+ * @interface
+ */
+
+class ProtocolInterface {
+    
+    // TODO: Refactor this so we don't need to pass a reference for the whole network instance
+    constructor(router, connection, config) {
+        if (new.target === ProtocolInterface) {
+            throw new Error('ProtocolInterface cannot be instantiated directly');
+        }
+    }
+
+    init(connection) {
+        // Abstract method. Need to be implemented by subclasses.
+        throw new Error('init() method must be implemented by subclass');
+    }
+
+    send(message) {
+        // Abstract method. Need to be implemented by subclasses.
+        throw new Error('send() method must be implemented by subclass');
+    }
+
+    close() {
+        // Abstract method. Need to be implemented by subclasses.
+        throw new Error('close() method must be implemented by subclass');
+    }
+}
+
+export default ProtocolInterface;

package/src/core/network/protocols/ProtocolSession.js

@@ -0,0 +1,59 @@
+// ProtocolSession is a per-peer (per Hyperswarm connection) wrapper that exposes the available
+// protocol messengers (legacy JSON, v1 binary) in one place.
+//
+// Why it exists:
+// - `setupProtomuxMessages(connection)` creates Protomux channels/messages for a specific peer.
+class ProtocolSession {
+    #legacyProtocol;
+    #v1Protocol;
+
+    constructor(legacyProtocol, v1Protocol) {
+        // These are Protomux "message" objects (returned by channel.addMessage).
+        // They are connection-scoped and expose .send(...), already wired to the channel's encoding.
+        this.#legacyProtocol = legacyProtocol;
+        this.#v1Protocol = v1Protocol;
+    }
+
+    getLegacy() {
+        return this.#legacyProtocol;
+    }
+
+    getV1() {
+        return this.#v1Protocol;
+    }
+
+    get(protocol) {
+        if (protocol === 'legacy') return this.#legacyProtocol;
+        if (protocol === 'v1') return this.#v1Protocol;
+        return null;
+    }
+
+    has(protocol) {
+        return Boolean(this.get(protocol));
+    }
+
+    send(message) {
+        // TODO: Support v1 messages
+        this.#legacyProtocol.send(message);
+    }
+
+    close() {
+        if (this.#legacyProtocol) {
+            try {
+                this.#legacyProtocol.close();
+            } catch (e) {
+                console.error('Failed to close legacy channel:', e); // TODO: Think about throwing instead
+            }
+        }
+
+        if (this.#v1Protocol) {
+            try {
+                this.#v1Protocol.close();
+            } catch (e) {
+                console.error('Failed to close v1 channel:', e); // TODO: Think about throwing instead
+            }
+        }
+    }
+}
+
+export default ProtocolSession;